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
  75 #define USB_DEBUG_VAR uaudio_debug
  76 #include <dev/usb/usb_debug.h>
  77
  78 #include <dev/usb/quirk/usb_quirk.h>
  79
  80 #include <sys/reboot.h>                 /* for bootverbose */
  81
  82 #ifdef HAVE_KERNEL_OPTION_HEADERS
  83 #include "opt_snd.h"
  84 #endif
  85
  86 #include <dev/sound/pcm/sound.h>
  87 #include <dev/sound/usb/uaudioreg.h>
  88 #include <dev/sound/usb/uaudio.h>
  89 #include <dev/sound/chip.h>
  90 #include "feeder_if.h"
  91
  92 static int uaudio_default_rate = 0;             /* use rate list */
  93 static int uaudio_default_bits = 32;
  94 static int uaudio_default_channels = 0;         /* use default */
  95
  96 #ifdef USB_DEBUG
  97 static int uaudio_debug = 0;
  98
  99 SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio");
 100
 101 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW,
 102     &uaudio_debug, 0, "uaudio debug level");
 103
 104 TUNABLE_INT("hw.usb.uaudio.default_rate", &uaudio_default_rate);
 105 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RW,
 106     &uaudio_default_rate, 0, "uaudio default sample rate");
 107
 108 TUNABLE_INT("hw.usb.uaudio.default_bits", &uaudio_default_bits);
 109 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RW,
 110     &uaudio_default_bits, 0, "uaudio default sample bits");
 111
 112 TUNABLE_INT("hw.usb.uaudio.default_channels", &uaudio_default_channels);
 113 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RW,
 114     &uaudio_default_channels, 0, "uaudio default sample channels");
 115 #endif
 116
 117 #define UAUDIO_NFRAMES          64      /* must be factor of 8 due HS-USB */
 118 #define UAUDIO_NCHANBUFS        2       /* number of outstanding request */
 119 #define UAUDIO_RECURSE_LIMIT   24       /* rounds */
 120
 121 #define MAKE_WORD(h,l) (((h) << 8) | (l))
 122 #define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1)
 123 #define UAUDIO_MAX_CHAN(x) (x)
 124
 125 struct uaudio_mixer_node {
 126         int32_t minval;
 127         int32_t maxval;
 128 #define MIX_MAX_CHAN 8
 129         int32_t wValue[MIX_MAX_CHAN];   /* using nchan */
 130         uint32_t mul;
 131         uint32_t ctl;
 132
 133         uint16_t wData[MIX_MAX_CHAN];   /* using nchan */
 134         uint16_t wIndex;
 135
 136         uint8_t update[(MIX_MAX_CHAN + 7) / 8];
 137         uint8_t nchan;
 138         uint8_t type;
 139 #define MIX_ON_OFF      1
 140 #define MIX_SIGNED_16   2
 141 #define MIX_UNSIGNED_16 3
 142 #define MIX_SIGNED_8    4
 143 #define MIX_SELECTOR    5
 144 #define MIX_UNKNOWN     6
 145 #define MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \
 146                       ((n) == MIX_UNSIGNED_16)) ? 2 : 1)
 147 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
 148
 149 #define MAX_SELECTOR_INPUT_PIN 256
 150         uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN];
 151         uint8_t class;
 152
 153         struct uaudio_mixer_node *next;
 154 };
 155
 156 struct uaudio_chan {
 157         struct pcmchan_caps pcm_cap;    /* capabilities */
 158
 159         struct snd_dbuf *pcm_buf;
 160         const struct usb_config *usb_cfg;
 161         struct mtx *pcm_mtx;            /* lock protecting this structure */
 162         struct uaudio_softc *priv_sc;
 163         struct pcm_channel *pcm_ch;
 164         struct usb_xfer *xfer[UAUDIO_NCHANBUFS];
 165         const struct usb_audio_streaming_interface_descriptor *p_asid;
 166         const struct usb_audio_streaming_type1_descriptor *p_asf1d;
 167         const struct usb_audio_streaming_endpoint_descriptor *p_sed;
 168         const usb_endpoint_descriptor_audio_t *p_ed1;
 169         const usb_endpoint_descriptor_audio_t *p_ed2;
 170         const struct uaudio_format *p_fmt;
 171
 172         uint8_t *buf;                   /* pointer to buffer */
 173         uint8_t *start;                 /* upper layer buffer start */
 174         uint8_t *end;                   /* upper layer buffer end */
 175         uint8_t *cur;                   /* current position in upper layer
 176                                          * buffer */
 177
 178         uint32_t intr_size;             /* in bytes */
 179         uint32_t intr_frames;           /* in units */
 180         uint32_t sample_rate;
 181         uint32_t frames_per_second;
 182         uint32_t sample_rem;
 183         uint32_t sample_curr;
 184
 185         uint32_t format;
 186         uint32_t pcm_format[2];
 187
 188         uint16_t bytes_per_frame[2];
 189
 190         uint16_t sample_size;
 191
 192         uint8_t valid;
 193         uint8_t iface_index;
 194         uint8_t iface_alt_index;
 195 };
 196
 197 #define UMIDI_CABLES_MAX   16           /* units */
 198 #define UMIDI_TX_FRAMES    256          /* units */
 199 #define UMIDI_TX_BUFFER    (UMIDI_TX_FRAMES * 4)        /* bytes */
 200
 201 enum {
 202         UMIDI_TX_TRANSFER,
 203         UMIDI_RX_TRANSFER,
 204         UMIDI_N_TRANSFER,
 205 };
 206
 207 struct umidi_sub_chan {
 208         struct usb_fifo_sc fifo;
 209         uint8_t *temp_cmd;
 210         uint8_t temp_0[4];
 211         uint8_t temp_1[4];
 212         uint8_t state;
 213 #define UMIDI_ST_UNKNOWN   0            /* scan for command */
 214 #define UMIDI_ST_1PARAM    1
 215 #define UMIDI_ST_2PARAM_1  2
 216 #define UMIDI_ST_2PARAM_2  3
 217 #define UMIDI_ST_SYSEX_0   4
 218 #define UMIDI_ST_SYSEX_1   5
 219 #define UMIDI_ST_SYSEX_2   6
 220
 221         uint8_t read_open:1;
 222         uint8_t write_open:1;
 223         uint8_t unused:6;
 224 };
 225
 226 struct umidi_chan {
 227
 228         struct umidi_sub_chan sub[UMIDI_CABLES_MAX];
 229         struct mtx mtx;
 230
 231         struct usb_xfer *xfer[UMIDI_N_TRANSFER];
 232
 233         uint8_t iface_index;
 234         uint8_t iface_alt_index;
 235
 236         uint8_t read_open_refcount;
 237         uint8_t write_open_refcount;
 238
 239         uint8_t curr_cable;
 240         uint8_t max_cable;
 241         uint8_t valid;
 242         uint8_t single_command;
 243 };
 244
 245 struct uaudio_softc {
 246         struct sbuf sc_sndstat;
 247         struct sndcard_func sc_sndcard_func;
 248         struct uaudio_chan sc_rec_chan;
 249         struct uaudio_chan sc_play_chan;
 250         struct umidi_chan sc_midi_chan;
 251
 252         struct usb_device *sc_udev;
 253         struct usb_xfer *sc_mixer_xfer[1];
 254         struct uaudio_mixer_node *sc_mixer_root;
 255         struct uaudio_mixer_node *sc_mixer_curr;
 256
 257         uint32_t sc_mix_info;
 258         uint32_t sc_recsrc_info;
 259
 260         uint16_t sc_audio_rev;
 261         uint16_t sc_mixer_count;
 262
 263         uint8_t sc_sndstat_valid;
 264         uint8_t sc_mixer_iface_index;
 265         uint8_t sc_mixer_iface_no;
 266         uint8_t sc_mixer_chan;
 267         uint8_t sc_pcm_registered:1;
 268         uint8_t sc_mixer_init:1;
 269         uint8_t sc_uq_audio_swap_lr:1;
 270         uint8_t sc_uq_au_inp_async:1;
 271         uint8_t sc_uq_au_no_xu:1;
 272         uint8_t sc_uq_bad_adc:1;
 273         uint8_t sc_uq_au_vendor_class:1;
 274 };
 275
 276 struct uaudio_search_result {
 277         uint8_t bit_input[(256 + 7) / 8];
 278         uint8_t bit_output[(256 + 7) / 8];
 279         uint8_t bit_visited[(256 + 7) / 8];
 280         uint8_t recurse_level;
 281         uint8_t id_max;
 282 };
 283
 284 struct uaudio_terminal_node {
 285         union {
 286                 const struct usb_descriptor *desc;
 287                 const struct usb_audio_input_terminal *it;
 288                 const struct usb_audio_output_terminal *ot;
 289                 const struct usb_audio_mixer_unit_0 *mu;
 290                 const struct usb_audio_selector_unit *su;
 291                 const struct usb_audio_feature_unit *fu;
 292                 const struct usb_audio_processing_unit_0 *pu;
 293                 const struct usb_audio_extension_unit_0 *eu;
 294         }       u;
 295         struct uaudio_search_result usr;
 296         struct uaudio_terminal_node *root;
 297 };
 298
 299 struct uaudio_format {
 300         uint16_t wFormat;
 301         uint8_t bPrecision;
 302         uint32_t freebsd_fmt;
 303         const char *description;
 304 };
 305
 306 static const struct uaudio_format uaudio_formats[] = {
 307
 308         {UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
 309         {UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
 310         {UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
 311         {UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
 312
 313         {UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
 314         {UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
 315         {UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
 316         {UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
 317
 318         {UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
 319         {UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
 320
 321         {0, 0, 0, NULL}
 322 };
 323
 324 #define UAC_OUTPUT      0
 325 #define UAC_INPUT       1
 326 #define UAC_EQUAL       2
 327 #define UAC_RECORD      3
 328 #define UAC_NCLASSES    4
 329
 330 #ifdef USB_DEBUG
 331 static const char *uac_names[] = {
 332         "outputs", "inputs", "equalization", "record"
 333 };
 334
 335 #endif
 336
 337 /* prototypes */
 338
 339 static device_probe_t uaudio_probe;
 340 static device_attach_t uaudio_attach;
 341 static device_detach_t uaudio_detach;
 342
 343 static usb_callback_t uaudio_chan_play_callback;
 344 static usb_callback_t uaudio_chan_record_callback;
 345 static usb_callback_t uaudio_mixer_write_cfg_callback;
 346 static usb_callback_t umidi_bulk_read_callback;
 347 static usb_callback_t umidi_bulk_write_callback;
 348
 349 static void     uaudio_chan_fill_info_sub(struct uaudio_softc *,
 350                     struct usb_device *, uint32_t, uint8_t, uint8_t);
 351 static void     uaudio_chan_fill_info(struct uaudio_softc *,
 352                     struct usb_device *);
 353 static void     uaudio_mixer_add_ctl_sub(struct uaudio_softc *,
 354                     struct uaudio_mixer_node *);
 355 static void     uaudio_mixer_add_ctl(struct uaudio_softc *,
 356                     struct uaudio_mixer_node *);
 357 static void     uaudio_mixer_add_input(struct uaudio_softc *,
 358                     const struct uaudio_terminal_node *, int);
 359 static void     uaudio_mixer_add_output(struct uaudio_softc *,
 360                     const struct uaudio_terminal_node *, int);
 361 static void     uaudio_mixer_add_mixer(struct uaudio_softc *,
 362                     const struct uaudio_terminal_node *, int);
 363 static void     uaudio_mixer_add_selector(struct uaudio_softc *,
 364                     const struct uaudio_terminal_node *, int);
 365 static uint32_t uaudio_mixer_feature_get_bmaControls(
 366                     const struct usb_audio_feature_unit *, uint8_t);
 367 static void     uaudio_mixer_add_feature(struct uaudio_softc *,
 368                     const struct uaudio_terminal_node *, int);
 369 static void     uaudio_mixer_add_processing_updown(struct uaudio_softc *,
 370                     const struct uaudio_terminal_node *, int);
 371 static void     uaudio_mixer_add_processing(struct uaudio_softc *,
 372                     const struct uaudio_terminal_node *, int);
 373 static void     uaudio_mixer_add_extension(struct uaudio_softc *,
 374                     const struct uaudio_terminal_node *, int);
 375 static struct   usb_audio_cluster uaudio_mixer_get_cluster(uint8_t,
 376                     const struct uaudio_terminal_node *);
 377 static uint16_t uaudio_mixer_determine_class(const struct uaudio_terminal_node *,
 378                     struct uaudio_mixer_node *);
 379 static uint16_t uaudio_mixer_feature_name(const struct uaudio_terminal_node *,
 380                     struct uaudio_mixer_node *);
 381 static const struct uaudio_terminal_node *uaudio_mixer_get_input(
 382                     const struct uaudio_terminal_node *, uint8_t);
 383 static const struct uaudio_terminal_node *uaudio_mixer_get_output(
 384                     const struct uaudio_terminal_node *, uint8_t);
 385 static void     uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *,
 386                     const uint8_t *, uint8_t, struct uaudio_search_result *);
 387 static void     uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *,
 388                     uint8_t, uint8_t, struct uaudio_search_result *);
 389 static void     uaudio_mixer_fill_info(struct uaudio_softc *,
 390                     struct usb_device *, void *);
 391 static uint16_t uaudio_mixer_get(struct usb_device *, uint8_t,
 392                     struct uaudio_mixer_node *);
 393 static void     uaudio_mixer_ctl_set(struct uaudio_softc *,
 394                     struct uaudio_mixer_node *, uint8_t, int32_t val);
 395 static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t);
 396 static int      uaudio_mixer_signext(uint8_t, int);
 397 static int      uaudio_mixer_bsd2value(struct uaudio_mixer_node *, int32_t val);
 398 static const void *uaudio_mixer_verify_desc(const void *, uint32_t);
 399 static void     uaudio_mixer_init(struct uaudio_softc *);
 400 static uint8_t  umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t);
 401 static struct   umidi_sub_chan *umidi_sub_by_fifo(struct usb_fifo *);
 402 static void     umidi_start_read(struct usb_fifo *);
 403 static void     umidi_stop_read(struct usb_fifo *);
 404 static void     umidi_start_write(struct usb_fifo *);
 405 static void     umidi_stop_write(struct usb_fifo *);
 406 static int      umidi_open(struct usb_fifo *, int);
 407 static int      umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int);
 408 static void     umidi_close(struct usb_fifo *, int);
 409 static void     umidi_init(device_t dev);
 410 static int      umidi_probe(device_t dev);
 411 static int      umidi_detach(device_t dev);
 412
 413 #ifdef USB_DEBUG
 414 static void     uaudio_chan_dump_ep_desc(
 415                     const usb_endpoint_descriptor_audio_t *);
 416 static void     uaudio_mixer_dump_cluster(uint8_t,
 417                     const struct uaudio_terminal_node *);
 418 static const char *uaudio_mixer_get_terminal_name(uint16_t);
 419 #endif
 420
 421 static const struct usb_config
 422         uaudio_cfg_record[UAUDIO_NCHANBUFS] = {
 423         [0] = {
 424                 .type = UE_ISOCHRONOUS,
 425                 .endpoint = UE_ADDR_ANY,
 426                 .direction = UE_DIR_IN,
 427                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 428                 .frames = UAUDIO_NFRAMES,
 429                 .flags = {.short_xfer_ok = 1,},
 430                 .callback = &uaudio_chan_record_callback,
 431         },
 432
 433         [1] = {
 434                 .type = UE_ISOCHRONOUS,
 435                 .endpoint = UE_ADDR_ANY,
 436                 .direction = UE_DIR_IN,
 437                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 438                 .frames = UAUDIO_NFRAMES,
 439                 .flags = {.short_xfer_ok = 1,},
 440                 .callback = &uaudio_chan_record_callback,
 441         },
 442 };
 443
 444 static const struct usb_config
 445         uaudio_cfg_play[UAUDIO_NCHANBUFS] = {
 446         [0] = {
 447                 .type = UE_ISOCHRONOUS,
 448                 .endpoint = UE_ADDR_ANY,
 449                 .direction = UE_DIR_OUT,
 450                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 451                 .frames = UAUDIO_NFRAMES,
 452                 .flags = {.short_xfer_ok = 1,},
 453                 .callback = &uaudio_chan_play_callback,
 454         },
 455
 456         [1] = {
 457                 .type = UE_ISOCHRONOUS,
 458                 .endpoint = UE_ADDR_ANY,
 459                 .direction = UE_DIR_OUT,
 460                 .bufsize = 0,   /* use "wMaxPacketSize * frames" */
 461                 .frames = UAUDIO_NFRAMES,
 462                 .flags = {.short_xfer_ok = 1,},
 463                 .callback = &uaudio_chan_play_callback,
 464         },
 465 };
 466
 467 static const struct usb_config
 468         uaudio_mixer_config[1] = {
 469         [0] = {
 470                 .type = UE_CONTROL,
 471                 .endpoint = 0x00,       /* Control pipe */
 472                 .direction = UE_DIR_ANY,
 473                 .bufsize = (sizeof(struct usb_device_request) + 4),
 474                 .callback = &uaudio_mixer_write_cfg_callback,
 475                 .timeout = 1000,        /* 1 second */
 476         },
 477 };
 478
 479 static const
 480 uint8_t umidi_cmd_to_len[16] = {
 481         [0x0] = 0,                      /* reserved */
 482         [0x1] = 0,                      /* reserved */
 483         [0x2] = 2,                      /* bytes */
 484         [0x3] = 3,                      /* bytes */
 485         [0x4] = 3,                      /* bytes */
 486         [0x5] = 1,                      /* bytes */
 487         [0x6] = 2,                      /* bytes */
 488         [0x7] = 3,                      /* bytes */
 489         [0x8] = 3,                      /* bytes */
 490         [0x9] = 3,                      /* bytes */
 491         [0xA] = 3,                      /* bytes */
 492         [0xB] = 3,                      /* bytes */
 493         [0xC] = 2,                      /* bytes */
 494         [0xD] = 2,                      /* bytes */
 495         [0xE] = 3,                      /* bytes */
 496         [0xF] = 1,                      /* bytes */
 497 };
 498
 499 static const struct usb_config
 500         umidi_config[UMIDI_N_TRANSFER] = {
 501         [UMIDI_TX_TRANSFER] = {
 502                 .type = UE_BULK,
 503                 .endpoint = UE_ADDR_ANY,
 504                 .direction = UE_DIR_OUT,
 505                 .bufsize = UMIDI_TX_BUFFER,
 506                 .callback = &umidi_bulk_write_callback,
 507         },
 508
 509         [UMIDI_RX_TRANSFER] = {
 510                 .type = UE_BULK,
 511                 .endpoint = UE_ADDR_ANY,
 512                 .direction = UE_DIR_IN,
 513                 .bufsize = 4,   /* bytes */
 514                 .flags = {.short_xfer_ok = 1,.proxy_buffer = 1,},
 515                 .callback = &umidi_bulk_read_callback,
 516         },
 517 };
 518
 519 static devclass_t uaudio_devclass;
 520
 521 static device_method_t uaudio_methods[] = {
 522         DEVMETHOD(device_probe, uaudio_probe),
 523         DEVMETHOD(device_attach, uaudio_attach),
 524         DEVMETHOD(device_detach, uaudio_detach),
 525         DEVMETHOD(device_suspend, bus_generic_suspend),
 526         DEVMETHOD(device_resume, bus_generic_resume),
 527         DEVMETHOD(device_shutdown, bus_generic_shutdown),
 528
 529         DEVMETHOD_END
 530 };
 531
 532 static driver_t uaudio_driver = {
 533         .name = "uaudio",
 534         .methods = uaudio_methods,
 535         .size = sizeof(struct uaudio_softc),
 536 };
 537
 538 static const STRUCT_USB_HOST_ID __used uaudio_devs[] = {
 539         /* Generic USB audio class match */
 540         {USB_IFACE_CLASS(UICLASS_AUDIO),
 541          USB_IFACE_SUBCLASS(UISUBCLASS_AUDIOCONTROL),},
 542         /* Generic USB MIDI class match */
 543         {USB_IFACE_CLASS(UICLASS_AUDIO),
 544          USB_IFACE_SUBCLASS(UISUBCLASS_MIDISTREAM),},
 545 };
 546
 547 static int
 548 uaudio_probe(device_t dev)
 549 {
 550         struct usb_attach_arg *uaa = device_get_ivars(dev);
 551
 552         if (uaa->usb_mode != USB_MODE_HOST)
 553                 return (ENXIO);
 554
 555         /* lookup non-standard device */
 556
 557         if (uaa->info.bInterfaceClass != UICLASS_AUDIO) {
 558                 if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS) == 0)
 559                         return (ENXIO);
 560         }
 561
 562         /* check for AUDIO control interface */
 563
 564         if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) {
 565                 if (usb_test_quirk(uaa, UQ_BAD_AUDIO))
 566                         return (ENXIO);
 567                 else
 568                         return (BUS_PROBE_GENERIC);
 569         }
 570
 571         /* check for MIDI stream */
 572
 573         if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) {
 574                 if (usb_test_quirk(uaa, UQ_BAD_MIDI))
 575                         return (ENXIO);
 576                 else
 577                         return (BUS_PROBE_GENERIC);
 578         }
 579         return (ENXIO);
 580 }
 581
 582 static int
 583 uaudio_attach(device_t dev)
 584 {
 585         struct usb_attach_arg *uaa = device_get_ivars(dev);
 586         struct uaudio_softc *sc = device_get_softc(dev);
 587         struct usb_interface_descriptor *id;
 588         device_t child;
 589
 590         sc->sc_play_chan.priv_sc = sc;
 591         sc->sc_rec_chan.priv_sc = sc;
 592         sc->sc_udev = uaa->device;
 593         sc->sc_mixer_iface_index = uaa->info.bIfaceIndex;
 594         sc->sc_mixer_iface_no = uaa->info.bIfaceNum;
 595
 596         if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR))
 597                 sc->sc_uq_audio_swap_lr = 1;
 598
 599         if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC))
 600                 sc->sc_uq_au_inp_async = 1;
 601
 602         if (usb_test_quirk(uaa, UQ_AU_NO_XU))
 603                 sc->sc_uq_au_no_xu = 1;
 604
 605         if (usb_test_quirk(uaa, UQ_BAD_ADC))
 606                 sc->sc_uq_bad_adc = 1;
 607
 608         if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS))
 609                 sc->sc_uq_au_vendor_class = 1;
 610
 611         umidi_init(dev);
 612
 613         device_set_usb_desc(dev);
 614
 615         id = usbd_get_interface_descriptor(uaa->iface);
 616
 617         uaudio_chan_fill_info(sc, uaa->device);
 618
 619         uaudio_mixer_fill_info(sc, uaa->device, id);
 620
 621         DPRINTF("audio rev %d.%02x\n",
 622             sc->sc_audio_rev >> 8,
 623             sc->sc_audio_rev & 0xff);
 624
 625         DPRINTF("%d mixer controls\n",
 626             sc->sc_mixer_count);
 627
 628         if (sc->sc_play_chan.valid) {
 629                 device_printf(dev, "Play: %d Hz, %d ch, %s format.\n",
 630                     sc->sc_play_chan.sample_rate,
 631                     sc->sc_play_chan.p_asf1d->bNrChannels,
 632                     sc->sc_play_chan.p_fmt->description);
 633         } else {
 634                 device_printf(dev, "No playback.\n");
 635         }
 636
 637         if (sc->sc_rec_chan.valid) {
 638                 device_printf(dev, "Record: %d Hz, %d ch, %s format.\n",
 639                     sc->sc_rec_chan.sample_rate,
 640                     sc->sc_rec_chan.p_asf1d->bNrChannels,
 641                     sc->sc_rec_chan.p_fmt->description);
 642         } else {
 643                 device_printf(dev, "No recording.\n");
 644         }
 645
 646         if (sc->sc_midi_chan.valid) {
 647
 648                 if (umidi_probe(dev)) {
 649                         goto detach;
 650                 }
 651                 device_printf(dev, "MIDI sequencer.\n");
 652         } else {
 653                 device_printf(dev, "No midi sequencer.\n");
 654         }
 655
 656         DPRINTF("doing child attach\n");
 657
 658         /* attach the children */
 659
 660         sc->sc_sndcard_func.func = SCF_PCM;
 661
 662         /*
 663          * Only attach a PCM device if we have a playback, recording
 664          * or mixer device present:
 665          */
 666         if (sc->sc_play_chan.valid ||
 667             sc->sc_rec_chan.valid ||
 668             sc->sc_mix_info) {
 669                 child = device_add_child(dev, "pcm", -1);
 670
 671                 if (child == NULL) {
 672                         DPRINTF("out of memory\n");
 673                         goto detach;
 674                 }
 675                 device_set_ivars(child, &sc->sc_sndcard_func);
 676         }
 677
 678         if (bus_generic_attach(dev)) {
 679                 DPRINTF("child attach failed\n");
 680                 goto detach;
 681         }
 682         return (0);                     /* success */
 683
 684 detach:
 685         uaudio_detach(dev);
 686         return (ENXIO);
 687 }
 688
 689 static void
 690 uaudio_pcm_setflags(device_t dev, uint32_t flags)
 691 {
 692         pcm_setflags(dev, pcm_getflags(dev) | flags);
 693 }
 694
 695 int
 696 uaudio_attach_sub(device_t dev, kobj_class_t mixer_class, kobj_class_t chan_class)
 697 {
 698         struct uaudio_softc *sc = device_get_softc(device_get_parent(dev));
 699         char status[SND_STATUSLEN];
 700
 701         uaudio_mixer_init(sc);
 702
 703         if (sc->sc_uq_audio_swap_lr) {
 704                 DPRINTF("hardware has swapped left and right\n");
 705                 /* uaudio_pcm_setflags(dev, SD_F_PSWAPLR); */
 706         }
 707         if (!(sc->sc_mix_info & SOUND_MASK_PCM)) {
 708
 709                 DPRINTF("emulating master volume\n");
 710
 711                 /*
 712                  * Emulate missing pcm mixer controller
 713                  * through FEEDER_VOLUME
 714                  */
 715                 uaudio_pcm_setflags(dev, SD_F_SOFTPCMVOL);
 716         }
 717         if (mixer_init(dev, mixer_class, sc)) {
 718                 goto detach;
 719         }
 720         sc->sc_mixer_init = 1;
 721
 722         snprintf(status, sizeof(status), "at ? %s", PCM_KLDSTRING(snd_uaudio));
 723
 724         if (pcm_register(dev, sc,
 725             sc->sc_play_chan.valid ? 1 : 0,
 726             sc->sc_rec_chan.valid ? 1 : 0)) {
 727                 goto detach;
 728         }
 729
 730         uaudio_pcm_setflags(dev, SD_F_MPSAFE);
 731         sc->sc_pcm_registered = 1;
 732
 733         if (sc->sc_play_chan.valid) {
 734                 pcm_addchan(dev, PCMDIR_PLAY, chan_class, sc);
 735         }
 736         if (sc->sc_rec_chan.valid) {
 737                 pcm_addchan(dev, PCMDIR_REC, chan_class, sc);
 738         }
 739         pcm_setstatus(dev, status);
 740
 741         return (0);                     /* success */
 742
 743 detach:
 744         uaudio_detach_sub(dev);
 745         return (ENXIO);
 746 }
 747
 748 int
 749 uaudio_detach_sub(device_t dev)
 750 {
 751         struct uaudio_softc *sc = device_get_softc(device_get_parent(dev));
 752         int error = 0;
 753
 754 repeat:
 755         if (sc->sc_pcm_registered) {
 756                 error = pcm_unregister(dev);
 757         } else {
 758                 if (sc->sc_mixer_init) {
 759                         error = mixer_uninit(dev);
 760                 }
 761         }
 762
 763         if (error) {
 764                 device_printf(dev, "Waiting for sound application to exit!\n");
 765                 usb_pause_mtx(NULL, 2 * hz);
 766                 goto repeat;            /* try again */
 767         }
 768         return (0);                     /* success */
 769 }
 770
 771 static int
 772 uaudio_detach(device_t dev)
 773 {
 774         struct uaudio_softc *sc = device_get_softc(dev);
 775
 776         if (bus_generic_detach(dev)) {
 777                 DPRINTF("detach failed!\n");
 778         }
 779         sbuf_delete(&sc->sc_sndstat);
 780         sc->sc_sndstat_valid = 0;
 781
 782         umidi_detach(dev);
 783
 784         return (0);
 785 }
 786
 787 /*========================================================================*
 788  * AS - Audio Stream - routines
 789  *========================================================================*/
 790
 791 #ifdef USB_DEBUG
 792 static void
 793 uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t *ed)
 794 {
 795         if (ed) {
 796                 DPRINTF("endpoint=%p bLength=%d bDescriptorType=%d \n"
 797                     "bEndpointAddress=%d bmAttributes=0x%x \n"
 798                     "wMaxPacketSize=%d bInterval=%d \n"
 799                     "bRefresh=%d bSynchAddress=%d\n",
 800                     ed, ed->bLength, ed->bDescriptorType,
 801                     ed->bEndpointAddress, ed->bmAttributes,
 802                     UGETW(ed->wMaxPacketSize), ed->bInterval,
 803                     UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0,
 804                     UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0);
 805         }
 806 }
 807
 808 #endif
 809
 810 /*
 811  * The following is a workaround for broken no-name USB audio devices
 812  * sold by dealextreme called "3D sound". The problem is that the
 813  * manufacturer computed wMaxPacketSize is too small to hold the
 814  * actual data sent. In other words the device sometimes sends more
 815  * data than it actually reports it can send in a single isochronous
 816  * packet.
 817  */
 818 static void
 819 uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep,
 820     uint32_t xps, uint32_t add)
 821 {
 822         uint32_t mps;
 823
 824         mps = UGETW(ep->wMaxPacketSize);
 825
 826         /*
 827          * If the device indicates it can send more data than what the
 828          * sample rate indicates, we apply the workaround.
 829          */
 830         if (mps > xps) {
 831
 832                 /* allow additional data */
 833                 xps += add;
 834
 835                 /* check against the maximum USB 1.x length */
 836                 if (xps > 1023)
 837                         xps = 1023;
 838
 839                 /* check if we should do an update */
 840                 if (mps < xps) {
 841                         /* simply update the wMaxPacketSize field */
 842                         USETW(ep->wMaxPacketSize, xps);
 843                         DPRINTF("Workaround: Updated wMaxPacketSize "
 844                             "from %d to %d bytes.\n",
 845                             (int)mps, (int)xps);
 846                 }
 847         }
 848 }
 849
 850 static void
 851 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
 852     uint32_t rate, uint8_t channels, uint8_t bit_resolution)
 853 {
 854         struct usb_descriptor *desc = NULL;
 855         const struct usb_audio_streaming_interface_descriptor *asid = NULL;
 856         const struct usb_audio_streaming_type1_descriptor *asf1d = NULL;
 857         const struct usb_audio_streaming_endpoint_descriptor *sed = NULL;
 858         usb_endpoint_descriptor_audio_t *ed1 = NULL;
 859         const usb_endpoint_descriptor_audio_t *ed2 = NULL;
 860         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
 861         struct usb_interface_descriptor *id;
 862         const struct uaudio_format *p_fmt;
 863         struct uaudio_chan *chan;
 864         uint16_t curidx = 0xFFFF;
 865         uint16_t lastidx = 0xFFFF;
 866         uint16_t alt_index = 0;
 867         uint16_t wFormat;
 868         uint8_t ep_dir;
 869         uint8_t bChannels;
 870         uint8_t bBitResolution;
 871         uint8_t x;
 872         uint8_t audio_if = 0;
 873         uint8_t uma_if_class;
 874
 875         while ((desc = usb_desc_foreach(cd, desc))) {
 876
 877                 if ((desc->bDescriptorType == UDESC_INTERFACE) &&
 878                     (desc->bLength >= sizeof(*id))) {
 879
 880                         id = (void *)desc;
 881
 882                         if (id->bInterfaceNumber != lastidx) {
 883                                 lastidx = id->bInterfaceNumber;
 884                                 curidx++;
 885                                 alt_index = 0;
 886
 887                         } else {
 888                                 alt_index++;
 889                         }
 890
 891                         uma_if_class =
 892                             ((id->bInterfaceClass == UICLASS_AUDIO) ||
 893                             ((id->bInterfaceClass == UICLASS_VENDOR) &&
 894                             (sc->sc_uq_au_vendor_class != 0)));
 895
 896                         if ((uma_if_class != 0) && (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) {
 897                                 audio_if = 1;
 898                         } else {
 899                                 audio_if = 0;
 900                         }
 901
 902                         if ((uma_if_class != 0) &&
 903                             (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) {
 904
 905                                 /*
 906                                  * XXX could allow multiple MIDI interfaces
 907                                  */
 908
 909                                 if ((sc->sc_midi_chan.valid == 0) &&
 910                                     usbd_get_iface(udev, curidx)) {
 911                                         sc->sc_midi_chan.iface_index = curidx;
 912                                         sc->sc_midi_chan.iface_alt_index = alt_index;
 913                                         sc->sc_midi_chan.valid = 1;
 914                                 }
 915                         }
 916                         asid = NULL;
 917                         asf1d = NULL;
 918                         ed1 = NULL;
 919                         ed2 = NULL;
 920                         sed = NULL;
 921                 }
 922                 if ((desc->bDescriptorType == UDESC_CS_INTERFACE) &&
 923                     (desc->bDescriptorSubtype == AS_GENERAL) &&
 924                     (desc->bLength >= sizeof(*asid))) {
 925                         if (asid == NULL) {
 926                                 asid = (void *)desc;
 927                         }
 928                 }
 929                 if ((desc->bDescriptorType == UDESC_CS_INTERFACE) &&
 930                     (desc->bDescriptorSubtype == FORMAT_TYPE) &&
 931                     (desc->bLength >= sizeof(*asf1d))) {
 932                         if (asf1d == NULL) {
 933                                 asf1d = (void *)desc;
 934                                 if (asf1d->bFormatType != FORMAT_TYPE_I) {
 935                                         DPRINTFN(11, "ignored bFormatType = %d\n",
 936                                             asf1d->bFormatType);
 937                                         asf1d = NULL;
 938                                         continue;
 939                                 }
 940                                 if (asf1d->bLength < (sizeof(*asf1d) +
 941                                     ((asf1d->bSamFreqType == 0) ? 6 :
 942                                     (asf1d->bSamFreqType * 3)))) {
 943                                         DPRINTFN(11, "'asf1d' descriptor is too short\n");
 944                                         asf1d = NULL;
 945                                         continue;
 946                                 }
 947                         }
 948                 }
 949                 if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
 950                     (desc->bLength >= UEP_MINSIZE)) {
 951                         if (ed1 == NULL) {
 952                                 ed1 = (void *)desc;
 953                                 if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) {
 954                                         ed1 = NULL;
 955                                 }
 956                         }
 957                 }
 958                 if ((desc->bDescriptorType == UDESC_CS_ENDPOINT) &&
 959                     (desc->bDescriptorSubtype == AS_GENERAL) &&
 960                     (desc->bLength >= sizeof(*sed))) {
 961                         if (sed == NULL) {
 962                                 sed = (void *)desc;
 963                         }
 964                 }
 965                 if (audio_if && asid && asf1d && ed1 && sed) {
 966
 967                         ep_dir = UE_GET_DIR(ed1->bEndpointAddress);
 968
 969                         /* We ignore sync endpoint information until further. */
 970
 971                         wFormat = UGETW(asid->wFormatTag);
 972                         bChannels = UAUDIO_MAX_CHAN(asf1d->bNrChannels);
 973                         bBitResolution = asf1d->bBitResolution;
 974
 975                         if (asf1d->bSamFreqType == 0) {
 976                                 DPRINTFN(16, "Sample rate: %d-%dHz\n",
 977                                     UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
 978
 979                                 if ((rate >= UA_SAMP_LO(asf1d)) &&
 980                                     (rate <= UA_SAMP_HI(asf1d))) {
 981                                         goto found_rate;
 982                                 }
 983                         } else {
 984
 985                                 for (x = 0; x < asf1d->bSamFreqType; x++) {
 986                                         DPRINTFN(16, "Sample rate = %dHz\n",
 987                                             UA_GETSAMP(asf1d, x));
 988
 989                                         if (rate == UA_GETSAMP(asf1d, x)) {
 990                                                 goto found_rate;
 991                                         }
 992                                 }
 993                         }
 994
 995                         audio_if = 0;
 996                         continue;
 997
 998         found_rate:
 999
1000                         for (p_fmt = uaudio_formats;
1001                             p_fmt->wFormat;
1002                             p_fmt++) {
1003                                 if ((p_fmt->wFormat == wFormat) &&
1004                                     (p_fmt->bPrecision == bBitResolution)) {
1005                                         goto found_format;
1006                                 }
1007                         }
1008
1009                         audio_if = 0;
1010                         continue;
1011
1012         found_format:
1013
1014                         if ((bChannels == channels) &&
1015                             (bBitResolution == bit_resolution)) {
1016
1017                                 chan = (ep_dir == UE_DIR_IN) ?
1018                                     &sc->sc_rec_chan :
1019                                     &sc->sc_play_chan;
1020
1021                                 if ((chan->valid == 0) && usbd_get_iface(udev, curidx)) {
1022
1023                                         chan->valid = 1;
1024 #ifdef USB_DEBUG
1025                                         uaudio_chan_dump_ep_desc(ed1);
1026                                         uaudio_chan_dump_ep_desc(ed2);
1027
1028                                         if (sed->bmAttributes & UA_SED_FREQ_CONTROL) {
1029                                                 DPRINTFN(2, "FREQ_CONTROL\n");
1030                                         }
1031                                         if (sed->bmAttributes & UA_SED_PITCH_CONTROL) {
1032                                                 DPRINTFN(2, "PITCH_CONTROL\n");
1033                                         }
1034 #endif
1035                                         DPRINTF("Sample rate = %dHz, channels = %d, "
1036                                             "bits = %d, format = %s\n", rate, channels,
1037                                             bit_resolution, p_fmt->description);
1038
1039                                         chan->sample_rate = rate;
1040                                         chan->p_asid = asid;
1041                                         chan->p_asf1d = asf1d;
1042                                         chan->p_ed1 = ed1;
1043                                         chan->p_ed2 = ed2;
1044                                         chan->p_fmt = p_fmt;
1045                                         chan->p_sed = sed;
1046                                         chan->iface_index = curidx;
1047                                         chan->iface_alt_index = alt_index;
1048
1049                                         if (ep_dir == UE_DIR_IN)
1050                                                 chan->usb_cfg =
1051                                                     uaudio_cfg_record;
1052                                         else
1053                                                 chan->usb_cfg =
1054                                                     uaudio_cfg_play;
1055
1056                                         chan->sample_size = ((
1057                                             UAUDIO_MAX_CHAN(chan->p_asf1d->bNrChannels) *
1058                                             chan->p_asf1d->bBitResolution) / 8);
1059
1060                                         if (ep_dir == UE_DIR_IN &&
1061                                             usbd_get_speed(udev) == USB_SPEED_FULL) {
1062                                                 uaudio_record_fix_fs(ed1,
1063                                                     chan->sample_size * (rate / 1000),
1064                                                     chan->sample_size * (rate / 4000));
1065                                         }
1066
1067                                         if (sc->sc_sndstat_valid) {
1068                                                 sbuf_printf(&sc->sc_sndstat, "\n\t"
1069                                                     "mode %d.%d:(%s) %dch, %d/%dbit, %s, %dHz",
1070                                                     curidx, alt_index,
1071                                                     (ep_dir == UE_DIR_IN) ? "input" : "output",
1072                                                     asf1d->bNrChannels, asf1d->bBitResolution,
1073                                                     asf1d->bSubFrameSize * 8,
1074                                                     p_fmt->description, rate);
1075                                         }
1076                                 }
1077                         }
1078                         audio_if = 0;
1079                         continue;
1080                 }
1081         }
1082 }
1083
1084 /* This structure defines all the supported rates. */
1085
1086 static const uint32_t uaudio_rate_list[] = {
1087         96000,
1088         88000,
1089         80000,
1090         72000,
1091         64000,
1092         56000,
1093         48000,
1094         44100,
1095         40000,
1096         32000,
1097         24000,
1098         22050,
1099         16000,
1100         11025,
1101         8000,
1102         0
1103 };
1104
1105 static void
1106 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev)
1107 {
1108         uint32_t rate = uaudio_default_rate;
1109         uint8_t z;
1110         uint8_t bits = uaudio_default_bits;
1111         uint8_t y;
1112         uint8_t channels = uaudio_default_channels;
1113         uint8_t x;
1114
1115         bits -= (bits % 8);
1116         if ((bits == 0) || (bits > 32)) {
1117                 /* set a valid value */
1118                 bits = 32;
1119         }
1120         if (channels == 0) {
1121                 switch (usbd_get_speed(udev)) {
1122                 case USB_SPEED_LOW:
1123                 case USB_SPEED_FULL:
1124                         /*
1125                          * Due to high bandwidth usage and problems
1126                          * with HIGH-speed split transactions we
1127                          * disable surround setups on FULL-speed USB
1128                          * by default
1129                          */
1130                         channels = 2;
1131                         break;
1132                 default:
1133                         channels = 16;
1134                         break;
1135                 }
1136         } else if (channels > 16) {
1137                 channels = 16;
1138         }
1139         if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND)) {
1140                 sc->sc_sndstat_valid = 1;
1141         }
1142         /* try to search for a valid config */
1143
1144         for (x = channels; x; x--) {
1145                 for (y = bits; y; y -= 8) {
1146
1147                         /* try user defined rate, if any */
1148                         if (rate != 0)
1149                                 uaudio_chan_fill_info_sub(sc, udev, rate, x, y);
1150
1151                         /* try find a matching rate, if any */
1152                         for (z = 0; uaudio_rate_list[z]; z++) {
1153                                 uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y);
1154
1155                                 if (sc->sc_rec_chan.valid &&
1156                                     sc->sc_play_chan.valid) {
1157                                         goto done;
1158                                 }
1159                         }
1160                 }
1161         }
1162
1163 done:
1164         if (sc->sc_sndstat_valid) {
1165                 sbuf_finish(&sc->sc_sndstat);
1166         }
1167 }
1168
1169 static void
1170 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error)
1171 {
1172         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
1173         struct usb_page_cache *pc;
1174         uint32_t total;
1175         uint32_t blockcount;
1176         uint32_t n;
1177         uint32_t offset;
1178         int actlen;
1179         int sumlen;
1180
1181         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
1182
1183         if (ch->end == ch->start) {
1184                 DPRINTF("no buffer!\n");
1185                 return;
1186         }
1187
1188         switch (USB_GET_STATE(xfer)) {
1189         case USB_ST_TRANSFERRED:
1190 tr_transferred:
1191                 if (actlen < sumlen) {
1192                         DPRINTF("short transfer, "
1193                             "%d of %d bytes\n", actlen, sumlen);
1194                 }
1195                 chn_intr(ch->pcm_ch);
1196
1197         case USB_ST_SETUP:
1198                 if (ch->bytes_per_frame[1] > usbd_xfer_max_framelen(xfer)) {
1199                         DPRINTF("bytes per transfer, %d, "
1200                             "exceeds maximum, %d!\n",
1201                             ch->bytes_per_frame[1],
1202                             usbd_xfer_max_framelen(xfer));
1203                         break;
1204                 }
1205
1206                 blockcount = ch->intr_frames;
1207
1208                 /* setup number of frames */
1209                 usbd_xfer_set_frames(xfer, blockcount);
1210
1211                 /* reset total length */
1212                 total = 0;
1213
1214                 /* setup frame lengths */
1215                 for (n = 0; n != blockcount; n++) {
1216                         ch->sample_curr += ch->sample_rem;
1217                         if (ch->sample_curr >= ch->frames_per_second) {
1218                                 ch->sample_curr -= ch->frames_per_second;
1219                                 usbd_xfer_set_frame_len(xfer, n, ch->bytes_per_frame[1]);
1220                                 total += ch->bytes_per_frame[1];
1221                         } else {
1222                                 usbd_xfer_set_frame_len(xfer, n, ch->bytes_per_frame[0]);
1223                                 total += ch->bytes_per_frame[0];
1224                         }
1225                 }
1226
1227                 DPRINTFN(6, "transfer %d bytes\n", total);
1228
1229                 offset = 0;
1230
1231                 pc = usbd_xfer_get_frame(xfer, 0);
1232                 while (total > 0) {
1233
1234                         n = (ch->end - ch->cur);
1235                         if (n > total) {
1236                                 n = total;
1237                         }
1238                         usbd_copy_in(pc, offset, ch->cur, n);
1239
1240                         total -= n;
1241                         ch->cur += n;
1242                         offset += n;
1243
1244                         if (ch->cur >= ch->end) {
1245                                 ch->cur = ch->start;
1246                         }
1247                 }
1248
1249                 usbd_transfer_submit(xfer);
1250                 break;
1251
1252         default:                        /* Error */
1253                 if (error == USB_ERR_CANCELLED) {
1254                         break;
1255                 }
1256                 goto tr_transferred;
1257         }
1258 }
1259
1260 static void
1261 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error)
1262 {
1263         struct uaudio_chan *ch = usbd_xfer_softc(xfer);
1264         struct usb_page_cache *pc;
1265         uint32_t n;
1266         uint32_t m;
1267         uint32_t blockcount;
1268         uint32_t offset0;
1269         uint32_t offset1;
1270         uint32_t mfl;
1271         int len;
1272         int actlen;
1273         int nframes;
1274
1275         usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
1276         mfl = usbd_xfer_max_framelen(xfer);
1277
1278         if (ch->end == ch->start) {
1279                 DPRINTF("no buffer!\n");
1280                 return;
1281         }
1282
1283         switch (USB_GET_STATE(xfer)) {
1284         case USB_ST_TRANSFERRED:
1285
1286                 DPRINTFN(6, "transferred %d bytes\n", actlen);
1287
1288                 offset0 = 0;
1289                 pc = usbd_xfer_get_frame(xfer, 0);
1290
1291                 for (n = 0; n != nframes; n++) {
1292
1293                         offset1 = offset0;
1294                         len = usbd_xfer_frame_len(xfer, n);
1295
1296                         while (len > 0) {
1297
1298                                 m = (ch->end - ch->cur);
1299
1300                                 if (m > len) {
1301                                         m = len;
1302                                 }
1303                                 usbd_copy_out(pc, offset1, ch->cur, m);
1304
1305                                 len -= m;
1306                                 offset1 += m;
1307                                 ch->cur += m;
1308
1309                                 if (ch->cur >= ch->end) {
1310                                         ch->cur = ch->start;
1311                                 }
1312                         }
1313
1314                         offset0 += mfl;
1315                 }
1316
1317                 chn_intr(ch->pcm_ch);
1318
1319         case USB_ST_SETUP:
1320 tr_setup:
1321                 blockcount = ch->intr_frames;
1322
1323                 usbd_xfer_set_frames(xfer, blockcount);
1324                 for (n = 0; n < blockcount; n++) {
1325                         usbd_xfer_set_frame_len(xfer, n, mfl);
1326                 }
1327
1328                 usbd_transfer_submit(xfer);
1329                 break;
1330
1331         default:                        /* Error */
1332                 if (error == USB_ERR_CANCELLED) {
1333                         break;
1334                 }
1335                 goto tr_setup;
1336         }
1337 }
1338
1339 void   *
1340 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b,
1341     struct pcm_channel *c, int dir)
1342 {
1343         struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ?
1344             &sc->sc_play_chan : &sc->sc_rec_chan);
1345         uint32_t buf_size;
1346         uint32_t frames;
1347         uint32_t format;
1348         uint16_t fps;
1349         uint8_t endpoint;
1350         uint8_t blocks;
1351         uint8_t iface_index;
1352         uint8_t alt_index;
1353         uint8_t fps_shift;
1354         usb_error_t err;
1355
1356         fps = usbd_get_isoc_fps(sc->sc_udev);
1357
1358         if (fps < 8000) {
1359                 /* FULL speed USB */
1360                 frames = 8;
1361         } else {
1362                 /* HIGH speed USB */
1363                 frames = UAUDIO_NFRAMES;
1364         }
1365
1366         /* setup play/record format */
1367
1368         ch->pcm_cap.fmtlist = ch->pcm_format;
1369
1370         ch->pcm_format[0] = 0;
1371         ch->pcm_format[1] = 0;
1372
1373         ch->pcm_cap.minspeed = ch->sample_rate;
1374         ch->pcm_cap.maxspeed = ch->sample_rate;
1375
1376         /* setup mutex and PCM channel */
1377
1378         ch->pcm_ch = c;
1379         ch->pcm_mtx = c->lock;
1380
1381         format = ch->p_fmt->freebsd_fmt;
1382
1383         switch (ch->p_asf1d->bNrChannels) {
1384         case 2:
1385                 /* stereo */
1386                 format = SND_FORMAT(format, 2, 0);
1387                 break;
1388         case 1:
1389                 /* mono */
1390                 format = SND_FORMAT(format, 1, 0);
1391                 break;
1392         default:
1393                 /* surround and more */
1394                 format = feeder_matrix_default_format(
1395                     SND_FORMAT(format, ch->p_asf1d->bNrChannels, 0));
1396                 break;
1397         }
1398
1399         ch->pcm_cap.fmtlist[0] = format;
1400         ch->pcm_cap.fmtlist[1] = 0;
1401
1402         /* check if format is not supported */
1403
1404         if (format == 0) {
1405                 DPRINTF("The selected audio format is not supported\n");
1406                 goto error;
1407         }
1408
1409         /* set alternate interface corresponding to the mode */
1410
1411         endpoint = ch->p_ed1->bEndpointAddress;
1412         iface_index = ch->iface_index;
1413         alt_index = ch->iface_alt_index;
1414
1415         DPRINTF("endpoint=0x%02x, speed=%d, iface=%d alt=%d\n",
1416             endpoint, ch->sample_rate, iface_index, alt_index);
1417
1418         err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, alt_index);
1419         if (err) {
1420                 DPRINTF("setting of alternate index failed: %s!\n",
1421                     usbd_errstr(err));
1422                 goto error;
1423         }
1424         usbd_set_parent_iface(sc->sc_udev, iface_index,
1425             sc->sc_mixer_iface_index);
1426
1427         /*
1428          * Only set the sample rate if the channel reports that it
1429          * supports the frequency control.
1430          */
1431         if (ch->p_sed->bmAttributes & UA_SED_FREQ_CONTROL) {
1432                 if (uaudio_set_speed(sc->sc_udev, endpoint, ch->sample_rate)) {
1433                         /*
1434                          * If the endpoint is adaptive setting the speed may
1435                          * fail.
1436                          */
1437                         DPRINTF("setting of sample rate failed! (continuing anyway)\n");
1438                 }
1439         }
1440         if (usbd_transfer_setup(sc->sc_udev, &iface_index, ch->xfer,
1441             ch->usb_cfg, UAUDIO_NCHANBUFS, ch, ch->pcm_mtx)) {
1442                 DPRINTF("could not allocate USB transfers!\n");
1443                 goto error;
1444         }
1445
1446         fps_shift = usbd_xfer_get_fps_shift(ch->xfer[0]);
1447
1448         /* down shift number of frames per second, if any */
1449         fps >>= fps_shift;
1450         frames >>= fps_shift;
1451
1452         /* bytes per frame should not be zero */
1453         ch->bytes_per_frame[0] = ((ch->sample_rate / fps) * ch->sample_size);
1454         ch->bytes_per_frame[1] = (((ch->sample_rate + fps - 1) / fps) * ch->sample_size);
1455
1456         /* setup data rate dithering, if any */
1457         ch->frames_per_second = fps;
1458         ch->sample_rem = ch->sample_rate % fps;
1459         ch->sample_curr = 0;
1460         ch->frames_per_second = fps;
1461
1462         /* compute required buffer size */
1463         buf_size = (ch->bytes_per_frame[1] * frames);
1464
1465         ch->intr_size = buf_size;
1466         ch->intr_frames = frames;
1467
1468         DPRINTF("fps=%d sample_rem=%d\n", fps, ch->sample_rem);
1469
1470         if (ch->intr_frames == 0) {
1471                 DPRINTF("frame shift is too high!\n");
1472                 goto error;
1473         }
1474
1475         /* setup double buffering */
1476         buf_size *= 2;
1477         blocks = 2;
1478
1479         ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
1480         if (ch->buf == NULL)
1481                 goto error;
1482         if (sndbuf_setup(b, ch->buf, buf_size) != 0)
1483                 goto error;
1484         if (sndbuf_resize(b, blocks, ch->intr_size))
1485                 goto error;
1486
1487         ch->start = ch->buf;
1488         ch->end = ch->buf + buf_size;
1489         ch->cur = ch->buf;
1490         ch->pcm_buf = b;
1491
1492         if (ch->pcm_mtx == NULL) {
1493                 DPRINTF("ERROR: PCM channels does not have a mutex!\n");
1494                 goto error;
1495         }
1496
1497         return (ch);
1498
1499 error:
1500         uaudio_chan_free(ch);
1501         return (NULL);
1502 }
1503
1504 int
1505 uaudio_chan_free(struct uaudio_chan *ch)
1506 {
1507         if (ch->buf != NULL) {
1508                 free(ch->buf, M_DEVBUF);
1509                 ch->buf = NULL;
1510         }
1511         usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS);
1512
1513         ch->valid = 0;
1514
1515         return (0);
1516 }
1517
1518 int
1519 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
1520 {
1521         return (ch->intr_size);
1522 }
1523
1524 int
1525 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize,
1526     uint32_t blockcount)
1527 {
1528         return (1);
1529 }
1530
1531 int
1532 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
1533 {
1534         if (speed != ch->sample_rate) {
1535                 DPRINTF("rate conversion required\n");
1536         }
1537         return (ch->sample_rate);
1538 }
1539
1540 int
1541 uaudio_chan_getptr(struct uaudio_chan *ch)
1542 {
1543         return (ch->cur - ch->start);
1544 }
1545
1546 struct pcmchan_caps *
1547 uaudio_chan_getcaps(struct uaudio_chan *ch)
1548 {
1549         return (&ch->pcm_cap);
1550 }
1551
1552 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = {
1553         .id = SND_CHN_MATRIX_DRV,
1554         .channels = 2,
1555         .ext = 0,
1556         .map = {
1557                 /* Right */
1558                 [0] = {
1559                         .type = SND_CHN_T_FR,
1560                         .members =
1561                             SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC |
1562                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR |
1563                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR
1564                 },
1565                 /* Left */
1566                 [1] = {
1567                         .type = SND_CHN_T_FL,
1568                         .members =
1569                             SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC |
1570                             SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL |
1571                             SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL
1572                 },
1573                 [2] = {
1574                         .type = SND_CHN_T_MAX,
1575                         .members = 0
1576                 }
1577         },
1578         .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL,
1579         .offset = {  1,  0, -1, -1, -1, -1, -1, -1, -1,
1580                     -1, -1, -1, -1, -1, -1, -1, -1, -1  }
1581 };
1582
1583 struct pcmchan_matrix *
1584 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
1585 {
1586         struct uaudio_softc *sc;
1587
1588         sc = ch->priv_sc;
1589
1590         if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
1591             AFMT_CHANNEL(format) == 2)
1592                 return (&uaudio_chan_matrix_swap_2_0);
1593
1594         return (feeder_matrix_format_map(format));
1595 }
1596
1597 int
1598 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
1599 {
1600         ch->format = format;
1601         return (0);
1602 }
1603
1604 int
1605 uaudio_chan_start(struct uaudio_chan *ch)
1606 {
1607         ch->cur = ch->start;
1608
1609 #if (UAUDIO_NCHANBUFS != 2)
1610 #error "please update code"
1611 #endif
1612         if (ch->xfer[0]) {
1613                 usbd_transfer_start(ch->xfer[0]);
1614         }
1615         if (ch->xfer[1]) {
1616                 usbd_transfer_start(ch->xfer[1]);
1617         }
1618         return (0);
1619 }
1620
1621 int
1622 uaudio_chan_stop(struct uaudio_chan *ch)
1623 {
1624 #if (UAUDIO_NCHANBUFS != 2)
1625 #error "please update code"
1626 #endif
1627         usbd_transfer_stop(ch->xfer[0]);
1628         usbd_transfer_stop(ch->xfer[1]);
1629         return (0);
1630 }
1631
1632 /*========================================================================*
1633  * AC - Audio Controller - routines
1634  *========================================================================*/
1635
1636 static void
1637 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
1638 {
1639         struct uaudio_mixer_node *p_mc_new =
1640             malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
1641
1642         if (p_mc_new != NULL) {
1643                 memcpy(p_mc_new, mc, sizeof(*p_mc_new));
1644                 p_mc_new->next = sc->sc_mixer_root;
1645                 sc->sc_mixer_root = p_mc_new;
1646                 sc->sc_mixer_count++;
1647         } else {
1648                 DPRINTF("out of memory\n");
1649         }
1650 }
1651
1652 static void
1653 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
1654 {
1655         int32_t res;
1656
1657         if (mc->class < UAC_NCLASSES) {
1658                 DPRINTF("adding %s.%d\n",
1659                     uac_names[mc->class], mc->ctl);
1660         } else {
1661                 DPRINTF("adding %d\n", mc->ctl);
1662         }
1663
1664         if (mc->type == MIX_ON_OFF) {
1665                 mc->minval = 0;
1666                 mc->maxval = 1;
1667         } else if (mc->type == MIX_SELECTOR) {
1668         } else {
1669
1670                 /* determine min and max values */
1671
1672                 mc->minval = uaudio_mixer_get(sc->sc_udev, GET_MIN, mc);
1673
1674                 mc->minval = uaudio_mixer_signext(mc->type, mc->minval);
1675
1676                 mc->maxval = uaudio_mixer_get(sc->sc_udev, GET_MAX, mc);
1677
1678                 mc->maxval = uaudio_mixer_signext(mc->type, mc->maxval);
1679
1680                 /* check if max and min was swapped */
1681
1682                 if (mc->maxval < mc->minval) {
1683                         res = mc->maxval;
1684                         mc->maxval = mc->minval;
1685                         mc->minval = res;
1686                 }
1687
1688                 /* compute value range */
1689                 mc->mul = mc->maxval - mc->minval;
1690                 if (mc->mul == 0)
1691                         mc->mul = 1;
1692
1693                 /* compute value alignment */
1694                 res = uaudio_mixer_get(sc->sc_udev, GET_RES, mc);
1695
1696                 DPRINTF("Resolution = %d\n", (int)res);
1697         }
1698
1699         uaudio_mixer_add_ctl_sub(sc, mc);
1700
1701 #ifdef USB_DEBUG
1702         if (uaudio_debug > 2) {
1703                 uint8_t i;
1704
1705                 for (i = 0; i < mc->nchan; i++) {
1706                         DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
1707                 }
1708                 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
1709                     "min=%d max=%d\n",
1710                     mc->wIndex, mc->type, mc->ctl,
1711                     mc->minval, mc->maxval);
1712         }
1713 #endif
1714 }
1715
1716 static void
1717 uaudio_mixer_add_input(struct uaudio_softc *sc,
1718     const struct uaudio_terminal_node *iot, int id)
1719 {
1720 #ifdef USB_DEBUG
1721         const struct usb_audio_input_terminal *d = iot[id].u.it;
1722
1723         DPRINTFN(3, "bTerminalId=%d wTerminalType=0x%04x "
1724             "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d "
1725             "iChannelNames=%d\n",
1726             d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
1727             d->bNrChannels, UGETW(d->wChannelConfig),
1728             d->iChannelNames);
1729 #endif
1730 }
1731
1732 static void
1733 uaudio_mixer_add_output(struct uaudio_softc *sc,
1734     const struct uaudio_terminal_node *iot, int id)
1735 {
1736 #ifdef USB_DEBUG
1737         const struct usb_audio_output_terminal *d = iot[id].u.ot;
1738
1739         DPRINTFN(3, "bTerminalId=%d wTerminalType=0x%04x "
1740             "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n",
1741             d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
1742             d->bSourceId, d->iTerminal);
1743 #endif
1744 }
1745
1746 static void
1747 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
1748     const struct uaudio_terminal_node *iot, int id)
1749 {
1750         struct uaudio_mixer_node mix;
1751
1752         const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu;
1753         const struct usb_audio_mixer_unit_1 *d1;
1754
1755         uint32_t bno;                   /* bit number */
1756         uint32_t p;                     /* bit number accumulator */
1757         uint32_t mo;                    /* matching outputs */
1758         uint32_t mc;                    /* matching channels */
1759         uint32_t ichs;                  /* input channels */
1760         uint32_t ochs;                  /* output channels */
1761         uint32_t c;
1762         uint32_t chs;                   /* channels */
1763         uint32_t i;
1764         uint32_t o;
1765
1766         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
1767             d0->bUnitId, d0->bNrInPins);
1768
1769         /* compute the number of input channels */
1770
1771         ichs = 0;
1772         for (i = 0; i < d0->bNrInPins; i++) {
1773                 ichs += (uaudio_mixer_get_cluster(d0->baSourceId[i], iot)
1774                     .bNrChannels);
1775         }
1776
1777         d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
1778
1779         /* and the number of output channels */
1780
1781         ochs = d1->bNrChannels;
1782
1783         DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
1784
1785         memset(&mix, 0, sizeof(mix));
1786
1787         mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
1788         uaudio_mixer_determine_class(&iot[id], &mix);
1789         mix.type = MIX_SIGNED_16;
1790
1791         if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) {
1792                 return;
1793         }
1794         for (p = i = 0; i < d0->bNrInPins; i++) {
1795                 chs = uaudio_mixer_get_cluster(d0->baSourceId[i], iot).bNrChannels;
1796                 mc = 0;
1797                 for (c = 0; c < chs; c++) {
1798                         mo = 0;
1799                         for (o = 0; o < ochs; o++) {
1800                                 bno = ((p + c) * ochs) + o;
1801                                 if (BIT_TEST(d1->bmControls, bno)) {
1802                                         mo++;
1803                                 }
1804                         }
1805                         if (mo == 1) {
1806                                 mc++;
1807                         }
1808                 }
1809                 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
1810
1811                         /* repeat bit-scan */
1812
1813                         mc = 0;
1814                         for (c = 0; c < chs; c++) {
1815                                 for (o = 0; o < ochs; o++) {
1816                                         bno = ((p + c) * ochs) + o;
1817                                         if (BIT_TEST(d1->bmControls, bno)) {
1818                                                 mix.wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
1819                                         }
1820                                 }
1821                         }
1822                         mix.nchan = chs;
1823                         uaudio_mixer_add_ctl(sc, &mix);
1824                 } else {
1825                         /* XXX */
1826                 }
1827                 p += chs;
1828         }
1829 }
1830
1831 static void
1832 uaudio_mixer_add_selector(struct uaudio_softc *sc,
1833     const struct uaudio_terminal_node *iot, int id)
1834 {
1835         const struct usb_audio_selector_unit *d = iot[id].u.su;
1836         struct uaudio_mixer_node mix;
1837         uint16_t i;
1838
1839         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
1840             d->bUnitId, d->bNrInPins);
1841
1842         if (d->bNrInPins == 0) {
1843                 return;
1844         }
1845         memset(&mix, 0, sizeof(mix));
1846
1847         mix.wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
1848         mix.wValue[0] = MAKE_WORD(0, 0);
1849         uaudio_mixer_determine_class(&iot[id], &mix);
1850         mix.nchan = 1;
1851         mix.type = MIX_SELECTOR;
1852
1853         mix.ctl = SOUND_MIXER_NRDEVICES;
1854         mix.minval = 1;
1855         mix.maxval = d->bNrInPins;
1856
1857         if (mix.maxval > MAX_SELECTOR_INPUT_PIN) {
1858                 mix.maxval = MAX_SELECTOR_INPUT_PIN;
1859         }
1860         mix.mul = (mix.maxval - mix.minval);
1861         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
1862                 mix.slctrtype[i] = SOUND_MIXER_NRDEVICES;
1863         }
1864
1865         for (i = 0; i < mix.maxval; i++) {
1866                 mix.slctrtype[i] = uaudio_mixer_feature_name
1867                     (&iot[d->baSourceId[i]], &mix);
1868         }
1869
1870         mix.class = 0;                  /* not used */
1871
1872         uaudio_mixer_add_ctl(sc, &mix);
1873 }
1874
1875 static uint32_t
1876 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
1877     uint8_t index)
1878 {
1879         uint32_t temp = 0;
1880         uint32_t offset = (index * d->bControlSize);
1881
1882         if (d->bControlSize > 0) {
1883                 temp |= d->bmaControls[offset];
1884                 if (d->bControlSize > 1) {
1885                         temp |= d->bmaControls[offset + 1] << 8;
1886                         if (d->bControlSize > 2) {
1887                                 temp |= d->bmaControls[offset + 2] << 16;
1888                                 if (d->bControlSize > 3) {
1889                                         temp |= d->bmaControls[offset + 3] << 24;
1890                                 }
1891                         }
1892                 }
1893         }
1894         return (temp);
1895 }
1896
1897 static void
1898 uaudio_mixer_add_feature(struct uaudio_softc *sc,
1899     const struct uaudio_terminal_node *iot, int id)
1900 {
1901         const struct usb_audio_feature_unit *d = iot[id].u.fu;
1902         struct uaudio_mixer_node mix;
1903         uint32_t fumask;
1904         uint32_t mmask;
1905         uint32_t cmask;
1906         uint16_t mixernumber;
1907         uint8_t nchan;
1908         uint8_t chan;
1909         uint8_t ctl;
1910         uint8_t i;
1911
1912         if (d->bControlSize == 0) {
1913                 return;
1914         }
1915         memset(&mix, 0, sizeof(mix));
1916
1917         nchan = (d->bLength - 7) / d->bControlSize;
1918         mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
1919         cmask = 0;
1920
1921         if (nchan == 0) {
1922                 return;
1923         }
1924         /* figure out what we can control */
1925
1926         for (chan = 1; chan < nchan; chan++) {
1927                 DPRINTFN(10, "chan=%d mask=%x\n",
1928                     chan, uaudio_mixer_feature_get_bmaControls(d, chan));
1929
1930                 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
1931         }
1932
1933         if (nchan > MIX_MAX_CHAN) {
1934                 nchan = MIX_MAX_CHAN;
1935         }
1936         mix.wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
1937
1938         for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
1939
1940                 fumask = FU_MASK(ctl);
1941
1942                 DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
1943                     ctl, fumask);
1944
1945                 if (mmask & fumask) {
1946                         mix.nchan = 1;
1947                         mix.wValue[0] = MAKE_WORD(ctl, 0);
1948                 } else if (cmask & fumask) {
1949                         mix.nchan = nchan - 1;
1950                         for (i = 1; i < nchan; i++) {
1951                                 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
1952                                         mix.wValue[i - 1] = MAKE_WORD(ctl, i);
1953                                 else
1954                                         mix.wValue[i - 1] = -1;
1955                         }
1956                 } else {
1957                         continue;
1958                 }
1959
1960                 mixernumber = uaudio_mixer_feature_name(&iot[id], &mix);
1961
1962                 switch (ctl) {
1963                 case MUTE_CONTROL:
1964                         mix.type = MIX_ON_OFF;
1965                         mix.ctl = SOUND_MIXER_NRDEVICES;
1966                         break;
1967
1968                 case VOLUME_CONTROL:
1969                         mix.type = MIX_SIGNED_16;
1970                         mix.ctl = mixernumber;
1971                         break;
1972
1973                 case BASS_CONTROL:
1974                         mix.type = MIX_SIGNED_8;
1975                         mix.ctl = SOUND_MIXER_BASS;
1976                         break;
1977
1978                 case MID_CONTROL:
1979                         mix.type = MIX_SIGNED_8;
1980                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1981                         break;
1982
1983                 case TREBLE_CONTROL:
1984                         mix.type = MIX_SIGNED_8;
1985                         mix.ctl = SOUND_MIXER_TREBLE;
1986                         break;
1987
1988                 case GRAPHIC_EQUALIZER_CONTROL:
1989                         continue;       /* XXX don't add anything */
1990                         break;
1991
1992                 case AGC_CONTROL:
1993                         mix.type = MIX_ON_OFF;
1994                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1995                         break;
1996
1997                 case DELAY_CONTROL:
1998                         mix.type = MIX_UNSIGNED_16;
1999                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
2000                         break;
2001
2002                 case BASS_BOOST_CONTROL:
2003                         mix.type = MIX_ON_OFF;
2004                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
2005                         break;
2006
2007                 case LOUDNESS_CONTROL:
2008                         mix.type = MIX_ON_OFF;
2009                         mix.ctl = SOUND_MIXER_LOUD;     /* Is this correct ? */
2010                         break;
2011
2012                 default:
2013                         mix.type = MIX_UNKNOWN;
2014                         break;
2015                 }
2016
2017                 if (mix.type != MIX_UNKNOWN) {
2018                         uaudio_mixer_add_ctl(sc, &mix);
2019                 }
2020         }
2021 }
2022
2023 static void
2024 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
2025     const struct uaudio_terminal_node *iot, int id)
2026 {
2027         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu;
2028         const struct usb_audio_processing_unit_1 *d1 =
2029         (const void *)(d0->baSourceId + d0->bNrInPins);
2030         const struct usb_audio_processing_unit_updown *ud =
2031         (const void *)(d1->bmControls + d1->bControlSize);
2032         struct uaudio_mixer_node mix;
2033         uint8_t i;
2034
2035         if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
2036                 return;
2037         }
2038         if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
2039             == NULL) {
2040                 return;
2041         }
2042         DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
2043             d0->bUnitId, ud->bNrModes);
2044
2045         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
2046                 DPRINTF("no mode select\n");
2047                 return;
2048         }
2049         memset(&mix, 0, sizeof(mix));
2050
2051         mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
2052         mix.nchan = 1;
2053         mix.wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
2054         uaudio_mixer_determine_class(&iot[id], &mix);
2055         mix.type = MIX_ON_OFF;          /* XXX */
2056
2057         for (i = 0; i < ud->bNrModes; i++) {
2058                 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
2059                 /* XXX */
2060         }
2061
2062         uaudio_mixer_add_ctl(sc, &mix);
2063 }
2064
2065 static void
2066 uaudio_mixer_add_processing(struct uaudio_softc *sc,
2067     const struct uaudio_terminal_node *iot, int id)
2068 {
2069         const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu;
2070         const struct usb_audio_processing_unit_1 *d1 =
2071         (const void *)(d0->baSourceId + d0->bNrInPins);
2072         struct uaudio_mixer_node mix;
2073         uint16_t ptype;
2074
2075         memset(&mix, 0, sizeof(mix));
2076
2077         ptype = UGETW(d0->wProcessType);
2078
2079         DPRINTFN(3, "wProcessType=%d bUnitId=%d "
2080             "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
2081
2082         if (d1->bControlSize == 0) {
2083                 return;
2084         }
2085         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
2086                 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
2087                 mix.nchan = 1;
2088                 mix.wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
2089                 uaudio_mixer_determine_class(&iot[id], &mix);
2090                 mix.type = MIX_ON_OFF;
2091                 uaudio_mixer_add_ctl(sc, &mix);
2092         }
2093         switch (ptype) {
2094         case UPDOWNMIX_PROCESS:
2095                 uaudio_mixer_add_processing_updown(sc, iot, id);
2096                 break;
2097
2098         case DOLBY_PROLOGIC_PROCESS:
2099         case P3D_STEREO_EXTENDER_PROCESS:
2100         case REVERBATION_PROCESS:
2101         case CHORUS_PROCESS:
2102         case DYN_RANGE_COMP_PROCESS:
2103         default:
2104                 DPRINTF("unit %d, type=%d is not implemented\n",
2105                     d0->bUnitId, ptype);
2106                 break;
2107         }
2108 }
2109
2110 static void
2111 uaudio_mixer_add_extension(struct uaudio_softc *sc,
2112     const struct uaudio_terminal_node *iot, int id)
2113 {
2114         const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu;
2115         const struct usb_audio_extension_unit_1 *d1 =
2116         (const void *)(d0->baSourceId + d0->bNrInPins);
2117         struct uaudio_mixer_node mix;
2118
2119         DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
2120             d0->bUnitId, d0->bNrInPins);
2121
2122         if (sc->sc_uq_au_no_xu) {
2123                 return;
2124         }
2125         if (d1->bControlSize == 0) {
2126                 return;
2127         }
2128         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
2129
2130                 memset(&mix, 0, sizeof(mix));
2131
2132                 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
2133                 mix.nchan = 1;
2134                 mix.wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
2135                 uaudio_mixer_determine_class(&iot[id], &mix);
2136                 mix.type = MIX_ON_OFF;
2137
2138                 uaudio_mixer_add_ctl(sc, &mix);
2139         }
2140 }
2141
2142 static const void *
2143 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
2144 {
2145         const struct usb_audio_mixer_unit_1 *d1;
2146         const struct usb_audio_extension_unit_1 *e1;
2147         const struct usb_audio_processing_unit_1 *u1;
2148
2149         union {
2150                 const struct usb_descriptor *desc;
2151                 const struct usb_audio_input_terminal *it;
2152                 const struct usb_audio_output_terminal *ot;
2153                 const struct usb_audio_mixer_unit_0 *mu;
2154                 const struct usb_audio_selector_unit *su;
2155                 const struct usb_audio_feature_unit *fu;
2156                 const struct usb_audio_processing_unit_0 *pu;
2157                 const struct usb_audio_extension_unit_0 *eu;
2158         }     u;
2159
2160         u.desc = arg;
2161
2162         if (u.desc == NULL) {
2163                 goto error;
2164         }
2165         if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
2166                 goto error;
2167         }
2168         switch (u.desc->bDescriptorSubtype) {
2169         case UDESCSUB_AC_INPUT:
2170                 len += sizeof(*u.it);
2171                 break;
2172
2173         case UDESCSUB_AC_OUTPUT:
2174                 len += sizeof(*u.ot);
2175                 break;
2176
2177         case UDESCSUB_AC_MIXER:
2178                 len += sizeof(*u.mu);
2179
2180                 if (u.desc->bLength < len) {
2181                         goto error;
2182                 }
2183                 len += u.mu->bNrInPins;
2184
2185                 if (u.desc->bLength < len) {
2186                         goto error;
2187                 }
2188                 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
2189
2190                 len += sizeof(*d1);
2191                 break;
2192
2193         case UDESCSUB_AC_SELECTOR:
2194                 len += sizeof(*u.su);
2195
2196                 if (u.desc->bLength < len) {
2197                         goto error;
2198                 }
2199                 len += u.su->bNrInPins;
2200                 break;
2201
2202         case UDESCSUB_AC_FEATURE:
2203                 len += (sizeof(*u.fu) + 1);
2204                 break;
2205
2206         case UDESCSUB_AC_PROCESSING:
2207                 len += sizeof(*u.pu);
2208
2209                 if (u.desc->bLength < len) {
2210                         goto error;
2211                 }
2212                 len += u.pu->bNrInPins;
2213
2214                 if (u.desc->bLength < len) {
2215                         goto error;
2216                 }
2217                 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
2218
2219                 len += sizeof(*u1);
2220
2221                 if (u.desc->bLength < len) {
2222                         goto error;
2223                 }
2224                 len += u1->bControlSize;
2225
2226                 break;
2227
2228         case UDESCSUB_AC_EXTENSION:
2229                 len += sizeof(*u.eu);
2230
2231                 if (u.desc->bLength < len) {
2232                         goto error;
2233                 }
2234                 len += u.eu->bNrInPins;
2235
2236                 if (u.desc->bLength < len) {
2237                         goto error;
2238                 }
2239                 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
2240
2241                 len += sizeof(*e1);
2242
2243                 if (u.desc->bLength < len) {
2244                         goto error;
2245                 }
2246                 len += e1->bControlSize;
2247                 break;
2248
2249         default:
2250                 goto error;
2251         }
2252
2253         if (u.desc->bLength < len) {
2254                 goto error;
2255         }
2256         return (u.desc);
2257
2258 error:
2259         if (u.desc) {
2260                 DPRINTF("invalid descriptor, type=%d, "
2261                     "sub_type=%d, len=%d of %d bytes\n",
2262                     u.desc->bDescriptorType,
2263                     u.desc->bDescriptorSubtype,
2264                     u.desc->bLength, len);
2265         }
2266         return (NULL);
2267 }
2268
2269 #ifdef USB_DEBUG
2270 static void
2271 uaudio_mixer_dump_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
2272 {
2273         static const char *channel_names[16] = {
2274                 "LEFT", "RIGHT", "CENTER", "LFE",
2275                 "LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER",
2276                 "SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP",
2277                 "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15",
2278         };
2279         uint16_t cc;
2280         uint8_t i;
2281         const struct usb_audio_cluster cl = uaudio_mixer_get_cluster(id, iot);
2282
2283         cc = UGETW(cl.wChannelConfig);
2284
2285         DPRINTF("cluster: bNrChannels=%u iChannelNames=%u wChannelConfig="
2286             "0x%04x:\n", cl.iChannelNames, cl.bNrChannels, cc);
2287
2288         for (i = 0; cc; i++) {
2289                 if (cc & 1) {
2290                         DPRINTF(" - %s\n", channel_names[i]);
2291                 }
2292                 cc >>= 1;
2293         }
2294 }
2295
2296 #endif
2297
2298 static struct usb_audio_cluster
2299 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
2300 {
2301         struct usb_audio_cluster r;
2302         const struct usb_descriptor *dp;
2303         uint8_t i;
2304
2305         for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {    /* avoid infinite loops */
2306                 dp = iot[id].u.desc;
2307                 if (dp == NULL) {
2308                         goto error;
2309                 }
2310                 switch (dp->bDescriptorSubtype) {
2311                 case UDESCSUB_AC_INPUT:
2312                         r.bNrChannels = iot[id].u.it->bNrChannels;
2313                         r.wChannelConfig[0] = iot[id].u.it->wChannelConfig[0];
2314                         r.wChannelConfig[1] = iot[id].u.it->wChannelConfig[1];
2315                         r.iChannelNames = iot[id].u.it->iChannelNames;
2316                         goto done;
2317
2318                 case UDESCSUB_AC_OUTPUT:
2319                         id = iot[id].u.ot->bSourceId;
2320                         break;
2321
2322                 case UDESCSUB_AC_MIXER:
2323                         r = *(const struct usb_audio_cluster *)
2324                             &iot[id].u.mu->baSourceId[iot[id].u.mu->
2325                             bNrInPins];
2326                         goto done;
2327
2328                 case UDESCSUB_AC_SELECTOR:
2329                         if (iot[id].u.su->bNrInPins > 0) {
2330                                 /* XXX This is not really right */
2331                                 id = iot[id].u.su->baSourceId[0];
2332                         }
2333                         break;
2334
2335                 case UDESCSUB_AC_FEATURE:
2336                         id = iot[id].u.fu->bSourceId;
2337                         break;
2338
2339                 case UDESCSUB_AC_PROCESSING:
2340                         r = *((const struct usb_audio_cluster *)
2341                             &iot[id].u.pu->baSourceId[iot[id].u.pu->
2342                             bNrInPins]);
2343                         goto done;
2344
2345                 case UDESCSUB_AC_EXTENSION:
2346                         r = *((const struct usb_audio_cluster *)
2347                             &iot[id].u.eu->baSourceId[iot[id].u.eu->
2348                             bNrInPins]);
2349                         goto done;
2350
2351                 default:
2352                         goto error;
2353                 }
2354         }
2355 error:
2356         DPRINTF("bad data\n");
2357         memset(&r, 0, sizeof(r));
2358 done:
2359         return (r);
2360 }
2361
2362 #ifdef USB_DEBUG
2363
2364 struct uaudio_tt_to_string {
2365         uint16_t terminal_type;
2366         const char *desc;
2367 };
2368
2369 static const struct uaudio_tt_to_string uaudio_tt_to_string[] = {
2370
2371         /* USB terminal types */
2372         {UAT_UNDEFINED, "UAT_UNDEFINED"},
2373         {UAT_STREAM, "UAT_STREAM"},
2374         {UAT_VENDOR, "UAT_VENDOR"},
2375
2376         /* input terminal types */
2377         {UATI_UNDEFINED, "UATI_UNDEFINED"},
2378         {UATI_MICROPHONE, "UATI_MICROPHONE"},
2379         {UATI_DESKMICROPHONE, "UATI_DESKMICROPHONE"},
2380         {UATI_PERSONALMICROPHONE, "UATI_PERSONALMICROPHONE"},
2381         {UATI_OMNIMICROPHONE, "UATI_OMNIMICROPHONE"},
2382         {UATI_MICROPHONEARRAY, "UATI_MICROPHONEARRAY"},
2383         {UATI_PROCMICROPHONEARR, "UATI_PROCMICROPHONEARR"},
2384
2385         /* output terminal types */
2386         {UATO_UNDEFINED, "UATO_UNDEFINED"},
2387         {UATO_SPEAKER, "UATO_SPEAKER"},
2388         {UATO_HEADPHONES, "UATO_HEADPHONES"},
2389         {UATO_DISPLAYAUDIO, "UATO_DISPLAYAUDIO"},
2390         {UATO_DESKTOPSPEAKER, "UATO_DESKTOPSPEAKER"},
2391         {UATO_ROOMSPEAKER, "UATO_ROOMSPEAKER"},
2392         {UATO_COMMSPEAKER, "UATO_COMMSPEAKER"},
2393         {UATO_SUBWOOFER, "UATO_SUBWOOFER"},
2394
2395         /* bidir terminal types */
2396         {UATB_UNDEFINED, "UATB_UNDEFINED"},
2397         {UATB_HANDSET, "UATB_HANDSET"},
2398         {UATB_HEADSET, "UATB_HEADSET"},
2399         {UATB_SPEAKERPHONE, "UATB_SPEAKERPHONE"},
2400         {UATB_SPEAKERPHONEESUP, "UATB_SPEAKERPHONEESUP"},
2401         {UATB_SPEAKERPHONEECANC, "UATB_SPEAKERPHONEECANC"},
2402
2403         /* telephony terminal types */
2404         {UATT_UNDEFINED, "UATT_UNDEFINED"},
2405         {UATT_PHONELINE, "UATT_PHONELINE"},
2406         {UATT_TELEPHONE, "UATT_TELEPHONE"},
2407         {UATT_DOWNLINEPHONE, "UATT_DOWNLINEPHONE"},
2408
2409         /* external terminal types */
2410         {UATE_UNDEFINED, "UATE_UNDEFINED"},
2411         {UATE_ANALOGCONN, "UATE_ANALOGCONN"},
2412         {UATE_LINECONN, "UATE_LINECONN"},
2413         {UATE_LEGACYCONN, "UATE_LEGACYCONN"},
2414         {UATE_DIGITALAUIFC, "UATE_DIGITALAUIFC"},
2415         {UATE_SPDIF, "UATE_SPDIF"},
2416         {UATE_1394DA, "UATE_1394DA"},
2417         {UATE_1394DV, "UATE_1394DV"},
2418
2419         /* embedded function terminal types */
2420         {UATF_UNDEFINED, "UATF_UNDEFINED"},
2421         {UATF_CALIBNOISE, "UATF_CALIBNOISE"},
2422         {UATF_EQUNOISE, "UATF_EQUNOISE"},
2423         {UATF_CDPLAYER, "UATF_CDPLAYER"},
2424         {UATF_DAT, "UATF_DAT"},
2425         {UATF_DCC, "UATF_DCC"},
2426         {UATF_MINIDISK, "UATF_MINIDISK"},
2427         {UATF_ANALOGTAPE, "UATF_ANALOGTAPE"},
2428         {UATF_PHONOGRAPH, "UATF_PHONOGRAPH"},
2429         {UATF_VCRAUDIO, "UATF_VCRAUDIO"},
2430         {UATF_VIDEODISCAUDIO, "UATF_VIDEODISCAUDIO"},
2431         {UATF_DVDAUDIO, "UATF_DVDAUDIO"},
2432         {UATF_TVTUNERAUDIO, "UATF_TVTUNERAUDIO"},
2433         {UATF_SATELLITE, "UATF_SATELLITE"},
2434         {UATF_CABLETUNER, "UATF_CABLETUNER"},
2435         {UATF_DSS, "UATF_DSS"},
2436         {UATF_RADIORECV, "UATF_RADIORECV"},
2437         {UATF_RADIOXMIT, "UATF_RADIOXMIT"},
2438         {UATF_MULTITRACK, "UATF_MULTITRACK"},
2439         {UATF_SYNTHESIZER, "UATF_SYNTHESIZER"},
2440
2441         /* unknown */
2442         {0x0000, "UNKNOWN"},
2443 };
2444
2445 static const char *
2446 uaudio_mixer_get_terminal_name(uint16_t terminal_type)
2447 {
2448         const struct uaudio_tt_to_string *uat = uaudio_tt_to_string;
2449
2450         while (uat->terminal_type) {
2451                 if (uat->terminal_type == terminal_type) {
2452                         break;
2453                 }
2454                 uat++;
2455         }
2456         if (uat->terminal_type == 0) {
2457                 DPRINTF("unknown terminal type (0x%04x)", terminal_type);
2458         }
2459         return (uat->desc);
2460 }
2461
2462 #endif
2463
2464 static uint16_t
2465 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot,
2466     struct uaudio_mixer_node *mix)
2467 {
2468         uint16_t terminal_type = 0x0000;
2469         const struct uaudio_terminal_node *input[2];
2470         const struct uaudio_terminal_node *output[2];
2471
2472         input[0] = uaudio_mixer_get_input(iot, 0);
2473         input[1] = uaudio_mixer_get_input(iot, 1);
2474
2475         output[0] = uaudio_mixer_get_output(iot, 0);
2476         output[1] = uaudio_mixer_get_output(iot, 1);
2477
2478         /*
2479          * check if there is only
2480          * one output terminal:
2481          */
2482         if (output[0] && (!output[1])) {
2483                 terminal_type = UGETW(output[0]->u.ot->wTerminalType);
2484         }
2485         /*
2486          * If the only output terminal is USB,
2487          * the class is UAC_RECORD.
2488          */
2489         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
2490
2491                 mix->class = UAC_RECORD;
2492                 if (input[0] && (!input[1])) {
2493                         terminal_type = UGETW(input[0]->u.it->wTerminalType);
2494                 } else {
2495                         terminal_type = 0;
2496                 }
2497                 goto done;
2498         }
2499         /*
2500          * if the unit is connected to just
2501          * one input terminal, the
2502          * class is UAC_INPUT:
2503          */
2504         if (input[0] && (!input[1])) {
2505                 mix->class = UAC_INPUT;
2506                 terminal_type = UGETW(input[0]->u.it->wTerminalType);
2507                 goto done;
2508         }
2509         /*
2510          * Otherwise, the class is UAC_OUTPUT.
2511          */
2512         mix->class = UAC_OUTPUT;
2513 done:
2514         return (terminal_type);
2515 }
2516
2517 struct uaudio_tt_to_feature {
2518         uint16_t terminal_type;
2519         uint16_t feature;
2520 };
2521
2522 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
2523
2524         {UAT_STREAM, SOUND_MIXER_PCM},
2525
2526         {UATI_MICROPHONE, SOUND_MIXER_MIC},
2527         {UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
2528         {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
2529         {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
2530         {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
2531         {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
2532
2533         {UATO_SPEAKER, SOUND_MIXER_SPEAKER},
2534         {UATO_DESKTOPSPEAKER, SOUND_MIXER_SPEAKER},
2535         {UATO_ROOMSPEAKER, SOUND_MIXER_SPEAKER},
2536         {UATO_COMMSPEAKER, SOUND_MIXER_SPEAKER},
2537
2538         {UATE_ANALOGCONN, SOUND_MIXER_LINE},
2539         {UATE_LINECONN, SOUND_MIXER_LINE},
2540         {UATE_LEGACYCONN, SOUND_MIXER_LINE},
2541
2542         {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
2543         {UATE_SPDIF, SOUND_MIXER_ALTPCM},
2544         {UATE_1394DA, SOUND_MIXER_ALTPCM},
2545         {UATE_1394DV, SOUND_MIXER_ALTPCM},
2546
2547         {UATF_CDPLAYER, SOUND_MIXER_CD},
2548
2549         {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
2550
2551         {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
2552         {UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
2553         {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
2554
2555         /* telephony terminal types */
2556         {UATT_UNDEFINED, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
2557         {UATT_PHONELINE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
2558         {UATT_TELEPHONE, SOUND_MIXER_PHONEIN},  /* SOUND_MIXER_PHONEOUT */
2559         {UATT_DOWNLINEPHONE, SOUND_MIXER_PHONEIN},      /* SOUND_MIXER_PHONEOUT */
2560
2561         {UATF_RADIORECV, SOUND_MIXER_RADIO},
2562         {UATF_RADIOXMIT, SOUND_MIXER_RADIO},
2563
2564         {UAT_UNDEFINED, SOUND_MIXER_VOLUME},
2565         {UAT_VENDOR, SOUND_MIXER_VOLUME},
2566         {UATI_UNDEFINED, SOUND_MIXER_VOLUME},
2567
2568         /* output terminal types */
2569         {UATO_UNDEFINED, SOUND_MIXER_VOLUME},
2570         {UATO_DISPLAYAUDIO, SOUND_MIXER_VOLUME},
2571         {UATO_SUBWOOFER, SOUND_MIXER_VOLUME},
2572         {UATO_HEADPHONES, SOUND_MIXER_VOLUME},
2573
2574         /* bidir terminal types */
2575         {UATB_UNDEFINED, SOUND_MIXER_VOLUME},
2576         {UATB_HANDSET, SOUND_MIXER_VOLUME},
2577         {UATB_HEADSET, SOUND_MIXER_VOLUME},
2578         {UATB_SPEAKERPHONE, SOUND_MIXER_VOLUME},
2579         {UATB_SPEAKERPHONEESUP, SOUND_MIXER_VOLUME},
2580         {UATB_SPEAKERPHONEECANC, SOUND_MIXER_VOLUME},
2581
2582         /* external terminal types */
2583         {UATE_UNDEFINED, SOUND_MIXER_VOLUME},
2584
2585         /* embedded function terminal types */
2586         {UATF_UNDEFINED, SOUND_MIXER_VOLUME},
2587         {UATF_CALIBNOISE, SOUND_MIXER_VOLUME},
2588         {UATF_EQUNOISE, SOUND_MIXER_VOLUME},
2589         {UATF_DAT, SOUND_MIXER_VOLUME},
2590         {UATF_DCC, SOUND_MIXER_VOLUME},
2591         {UATF_MINIDISK, SOUND_MIXER_VOLUME},
2592         {UATF_ANALOGTAPE, SOUND_MIXER_VOLUME},
2593         {UATF_PHONOGRAPH, SOUND_MIXER_VOLUME},
2594         {UATF_VCRAUDIO, SOUND_MIXER_VOLUME},
2595         {UATF_SATELLITE, SOUND_MIXER_VOLUME},
2596         {UATF_CABLETUNER, SOUND_MIXER_VOLUME},
2597         {UATF_DSS, SOUND_MIXER_VOLUME},
2598         {UATF_MULTITRACK, SOUND_MIXER_VOLUME},
2599         {0xffff, SOUND_MIXER_VOLUME},
2600
2601         /* default */
2602         {0x0000, SOUND_MIXER_VOLUME},
2603 };
2604
2605 static uint16_t
2606 uaudio_mixer_feature_name(const struct uaudio_terminal_node *iot,
2607     struct uaudio_mixer_node *mix)
2608 {
2609         const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
2610         uint16_t terminal_type = uaudio_mixer_determine_class(iot, mix);
2611
2612         if ((mix->class == UAC_RECORD) && (terminal_type == 0)) {
2613                 return (SOUND_MIXER_IMIX);
2614         }
2615         while (uat->terminal_type) {
2616                 if (uat->terminal_type == terminal_type) {
2617                         break;
2618                 }
2619                 uat++;
2620         }
2621
2622         DPRINTF("terminal_type=%s (0x%04x) -> %d\n",
2623             uaudio_mixer_get_terminal_name(terminal_type),
2624             terminal_type, uat->feature);
2625
2626         return (uat->feature);
2627 }
2628
2629 const static struct uaudio_terminal_node *
2630 uaudio_mixer_get_input(const struct uaudio_terminal_node *iot, uint8_t index)
2631 {
2632         struct uaudio_terminal_node *root = iot->root;
2633         uint8_t n;
2634
2635         n = iot->usr.id_max;
2636         do {
2637                 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) {
2638                         if (!index--) {
2639                                 return (root + n);
2640                         }
2641                 }
2642         } while (n--);
2643
2644         return (NULL);
2645 }
2646
2647 const static struct uaudio_terminal_node *
2648 uaudio_mixer_get_output(const struct uaudio_terminal_node *iot, uint8_t index)
2649 {
2650         struct uaudio_terminal_node *root = iot->root;
2651         uint8_t n;
2652
2653         n = iot->usr.id_max;
2654         do {
2655                 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) {
2656                         if (!index--) {
2657                                 return (root + n);
2658                         }
2659                 }
2660         } while (n--);
2661
2662         return (NULL);
2663 }
2664
2665 static void
2666 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
2667     const uint8_t *p_id, uint8_t n_id,
2668     struct uaudio_search_result *info)
2669 {
2670         struct uaudio_terminal_node *iot;
2671         uint8_t n;
2672         uint8_t i;
2673
2674         if (info->recurse_level >= UAUDIO_RECURSE_LIMIT) {
2675                 return;
2676         }
2677         info->recurse_level++;
2678
2679         for (n = 0; n < n_id; n++) {
2680
2681                 i = p_id[n];
2682
2683                 if (info->bit_visited[i / 8] & (1 << (i % 8))) {
2684                         /* don't go into a circle */
2685                         DPRINTF("avoided going into a circle at id=%d!\n", i);
2686                         continue;
2687                 } else {
2688                         info->bit_visited[i / 8] |= (1 << (i % 8));
2689                 }
2690
2691                 iot = (root + i);
2692
2693                 if (iot->u.desc == NULL) {
2694                         continue;
2695                 }
2696                 switch (iot->u.desc->bDescriptorSubtype) {
2697                 case UDESCSUB_AC_INPUT:
2698                         info->bit_input[i / 8] |= (1 << (i % 8));
2699                         break;
2700
2701                 case UDESCSUB_AC_FEATURE:
2702                         uaudio_mixer_find_inputs_sub
2703                             (root, &iot->u.fu->bSourceId, 1, info);
2704                         break;
2705
2706                 case UDESCSUB_AC_OUTPUT:
2707                         uaudio_mixer_find_inputs_sub
2708                             (root, &iot->u.ot->bSourceId, 1, info);
2709                         break;
2710
2711                 case UDESCSUB_AC_MIXER:
2712                         uaudio_mixer_find_inputs_sub
2713                             (root, iot->u.mu->baSourceId,
2714                             iot->u.mu->bNrInPins, info);
2715                         break;
2716
2717                 case UDESCSUB_AC_SELECTOR:
2718                         uaudio_mixer_find_inputs_sub
2719                             (root, iot->u.su->baSourceId,
2720                             iot->u.su->bNrInPins, info);
2721                         break;
2722
2723                 case UDESCSUB_AC_PROCESSING:
2724                         uaudio_mixer_find_inputs_sub
2725                             (root, iot->u.pu->baSourceId,
2726                             iot->u.pu->bNrInPins, info);
2727                         break;
2728
2729                 case UDESCSUB_AC_EXTENSION:
2730                         uaudio_mixer_find_inputs_sub
2731                             (root, iot->u.eu->baSourceId,
2732                             iot->u.eu->bNrInPins, info);
2733                         break;
2734
2735                 case UDESCSUB_AC_HEADER:
2736                 default:
2737                         break;
2738                 }
2739         }
2740         info->recurse_level--;
2741 }
2742
2743 static void
2744 uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *root, uint8_t id,
2745     uint8_t n_id, struct uaudio_search_result *info)
2746 {
2747         struct uaudio_terminal_node *iot = (root + id);
2748         uint8_t j;
2749
2750         j = n_id;
2751         do {
2752                 if ((j != id) && ((root + j)->u.desc) &&
2753                     ((root + j)->u.desc->bDescriptorSubtype == UDESCSUB_AC_OUTPUT)) {
2754
2755                         /*
2756                          * "j" (output) <--- virtual wire <--- "id" (input)
2757                          *
2758                          * if "j" has "id" on the input, then "id" have "j" on
2759                          * the output, because they are connected:
2760                          */
2761                         if ((root + j)->usr.bit_input[id / 8] & (1 << (id % 8))) {
2762                                 iot->usr.bit_output[j / 8] |= (1 << (j % 8));
2763                         }
2764                 }
2765         } while (j--);
2766 }
2767
2768 static void
2769 uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev,
2770     void *desc)
2771 {
2772         const struct usb_audio_control_descriptor *acdp;
2773         struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
2774         const struct usb_descriptor *dp;
2775         const struct usb_audio_unit *au;
2776         struct uaudio_terminal_node *iot = NULL;
2777         uint16_t wTotalLen;
2778         uint8_t ID_max = 0;             /* inclusive */
2779         uint8_t i;
2780
2781         desc = usb_desc_foreach(cd, desc);
2782
2783         if (desc == NULL) {
2784                 DPRINTF("no Audio Control header\n");
2785                 goto done;
2786         }
2787         acdp = desc;
2788
2789         if ((acdp->bLength < sizeof(*acdp)) ||
2790             (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
2791             (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
2792                 DPRINTF("invalid Audio Control header\n");
2793                 goto done;
2794         }
2795         /* "wTotalLen" is allowed to be corrupt */
2796         wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
2797
2798         /* get USB audio revision */
2799         sc->sc_audio_rev = UGETW(acdp->bcdADC);
2800
2801         DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
2802             sc->sc_audio_rev, wTotalLen);
2803
2804         if (sc->sc_audio_rev != UAUDIO_VERSION) {
2805
2806                 if (sc->sc_uq_bad_adc) {
2807
2808                 } else {
2809                         DPRINTF("invalid audio version\n");
2810                         goto done;
2811                 }
2812         }
2813         iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
2814             M_WAITOK | M_ZERO);
2815
2816         if (iot == NULL) {
2817                 DPRINTF("no memory!\n");
2818                 goto done;
2819         }
2820         while ((desc = usb_desc_foreach(cd, desc))) {
2821
2822                 dp = desc;
2823
2824                 if (dp->bLength > wTotalLen) {
2825                         break;
2826                 } else {
2827                         wTotalLen -= dp->bLength;
2828                 }
2829
2830                 au = uaudio_mixer_verify_desc(dp, 0);
2831
2832                 if (au) {
2833                         iot[au->bUnitId].u.desc = (const void *)au;
2834                         if (au->bUnitId > ID_max) {
2835                                 ID_max = au->bUnitId;
2836                         }
2837                 }
2838         }
2839
2840         DPRINTF("Maximum ID=%d\n", ID_max);
2841
2842         /*
2843          * determine sourcing inputs for
2844          * all nodes in the tree:
2845          */
2846         i = ID_max;
2847         do {
2848                 uaudio_mixer_find_inputs_sub(iot, &i, 1, &((iot + i)->usr));
2849         } while (i--);
2850
2851         /*
2852          * determine outputs for
2853          * all nodes in the tree:
2854          */
2855         i = ID_max;
2856         do {
2857                 uaudio_mixer_find_outputs_sub(iot, i, ID_max, &((iot + i)->usr));
2858         } while (i--);
2859
2860         /* set "id_max" and "root" */
2861
2862         i = ID_max;
2863         do {
2864                 (iot + i)->usr.id_max = ID_max;
2865                 (iot + i)->root = iot;
2866         } while (i--);
2867
2868 #ifdef USB_DEBUG
2869         i = ID_max;
2870         do {
2871                 uint8_t j;
2872
2873                 if (iot[i].u.desc == NULL) {
2874                         continue;
2875                 }
2876                 DPRINTF("id %d:\n", i);
2877
2878                 switch (iot[i].u.desc->bDescriptorSubtype) {
2879                 case UDESCSUB_AC_INPUT:
2880                         DPRINTF(" - AC_INPUT type=%s\n",
2881                             uaudio_mixer_get_terminal_name
2882                             (UGETW(iot[i].u.it->wTerminalType)));
2883                         uaudio_mixer_dump_cluster(i, iot);
2884                         break;
2885
2886                 case UDESCSUB_AC_OUTPUT:
2887                         DPRINTF(" - AC_OUTPUT type=%s "
2888                             "src=%d\n", uaudio_mixer_get_terminal_name
2889                             (UGETW(iot[i].u.ot->wTerminalType)),
2890                             iot[i].u.ot->bSourceId);
2891                         break;
2892
2893                 case UDESCSUB_AC_MIXER:
2894                         DPRINTF(" - AC_MIXER src:\n");
2895                         for (j = 0; j < iot[i].u.mu->bNrInPins; j++) {
2896                                 DPRINTF("   - %d\n", iot[i].u.mu->baSourceId[j]);
2897                         }
2898                         uaudio_mixer_dump_cluster(i, iot);
2899                         break;
2900
2901                 case UDESCSUB_AC_SELECTOR:
2902                         DPRINTF(" - AC_SELECTOR src:\n");
2903                         for (j = 0; j < iot[i].u.su->bNrInPins; j++) {
2904                                 DPRINTF("   - %d\n", iot[i].u.su->baSourceId[j]);
2905                         }
2906                         break;
2907
2908                 case UDESCSUB_AC_FEATURE:
2909                         DPRINTF(" - AC_FEATURE src=%d\n", iot[i].u.fu->bSourceId);
2910                         break;
2911
2912                 case UDESCSUB_AC_PROCESSING:
2913                         DPRINTF(" - AC_PROCESSING src:\n");
2914                         for (j = 0; j < iot[i].u.pu->bNrInPins; j++) {
2915                                 DPRINTF("   - %d\n", iot[i].u.pu->baSourceId[j]);
2916                         }
2917                         uaudio_mixer_dump_cluster(i, iot);
2918                         break;
2919
2920                 case UDESCSUB_AC_EXTENSION:
2921                         DPRINTF(" - AC_EXTENSION src:\n");
2922                         for (j = 0; j < iot[i].u.eu->bNrInPins; j++) {
2923                                 DPRINTF("%d ", iot[i].u.eu->baSourceId[j]);
2924                         }
2925                         uaudio_mixer_dump_cluster(i, iot);
2926                         break;
2927
2928                 default:
2929                         DPRINTF("unknown audio control (subtype=%d)\n",
2930                             iot[i].u.desc->bDescriptorSubtype);
2931                 }
2932
2933                 DPRINTF("Inputs to this ID are:\n");
2934
2935                 j = ID_max;
2936                 do {
2937                         if (iot[i].usr.bit_input[j / 8] & (1 << (j % 8))) {
2938                                 DPRINTF("  -- ID=%d\n", j);
2939                         }
2940                 } while (j--);
2941
2942                 DPRINTF("Outputs from this ID are:\n");
2943
2944                 j = ID_max;
2945                 do {
2946                         if (iot[i].usr.bit_output[j / 8] & (1 << (j % 8))) {
2947                                 DPRINTF("  -- ID=%d\n", j);
2948                         }
2949                 } while (j--);
2950
2951         } while (i--);
2952 #endif
2953
2954         /*
2955          * scan the config to create a linked
2956          * list of "mixer" nodes:
2957          */
2958
2959         i = ID_max;
2960         do {
2961                 dp = iot[i].u.desc;
2962
2963                 if (dp == NULL) {
2964                         continue;
2965                 }
2966                 DPRINTFN(11, "id=%d subtype=%d\n",
2967                     i, dp->bDescriptorSubtype);
2968
2969                 switch (dp->bDescriptorSubtype) {
2970                 case UDESCSUB_AC_HEADER:
2971                         DPRINTF("unexpected AC header\n");
2972                         break;
2973
2974                 case UDESCSUB_AC_INPUT:
2975                         uaudio_mixer_add_input(sc, iot, i);
2976                         break;
2977
2978                 case UDESCSUB_AC_OUTPUT:
2979                         uaudio_mixer_add_output(sc, iot, i);
2980                         break;
2981
2982                 case UDESCSUB_AC_MIXER:
2983                         uaudio_mixer_add_mixer(sc, iot, i);
2984                         break;
2985
2986                 case UDESCSUB_AC_SELECTOR:
2987                         uaudio_mixer_add_selector(sc, iot, i);
2988                         break;
2989
2990                 case UDESCSUB_AC_FEATURE:
2991                         uaudio_mixer_add_feature(sc, iot, i);
2992                         break;
2993
2994                 case UDESCSUB_AC_PROCESSING:
2995                         uaudio_mixer_add_processing(sc, iot, i);
2996                         break;
2997
2998                 case UDESCSUB_AC_EXTENSION:
2999                         uaudio_mixer_add_extension(sc, iot, i);
3000                         break;
3001
3002                 default:
3003                         DPRINTF("bad AC desc subtype=0x%02x\n",
3004                             dp->bDescriptorSubtype);
3005                         break;
3006                 }
3007
3008         } while (i--);
3009
3010 done:
3011         if (iot) {
3012                 free(iot, M_TEMP);
3013         }
3014 }
3015
3016 static uint16_t
3017 uaudio_mixer_get(struct usb_device *udev, uint8_t what,
3018     struct uaudio_mixer_node *mc)
3019 {
3020         struct usb_device_request req;
3021         uint16_t val;
3022         uint16_t len = MIX_SIZE(mc->type);
3023         uint8_t data[4];
3024         usb_error_t err;
3025
3026         if (mc->wValue[0] == -1) {
3027                 return (0);
3028         }
3029         req.bmRequestType = UT_READ_CLASS_INTERFACE;
3030         req.bRequest = what;
3031         USETW(req.wValue, mc->wValue[0]);
3032         USETW(req.wIndex, mc->wIndex);
3033         USETW(req.wLength, len);
3034
3035         err = usbd_do_request(udev, NULL, &req, data);
3036         if (err) {
3037                 DPRINTF("err=%s\n", usbd_errstr(err));
3038                 return (0);
3039         }
3040         if (len < 1) {
3041                 data[0] = 0;
3042         }
3043         if (len < 2) {
3044                 data[1] = 0;
3045         }
3046         val = (data[0] | (data[1] << 8));
3047
3048         DPRINTFN(3, "val=%d\n", val);
3049
3050         return (val);
3051 }
3052
3053 static void
3054 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
3055 {
3056         struct usb_device_request req;
3057         struct uaudio_softc *sc = usbd_xfer_softc(xfer);
3058         struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
3059         struct usb_page_cache *pc;
3060         uint16_t len;
3061         uint8_t repeat = 1;
3062         uint8_t update;
3063         uint8_t chan;
3064         uint8_t buf[2];
3065
3066         DPRINTF("\n");
3067
3068         switch (USB_GET_STATE(xfer)) {
3069         case USB_ST_TRANSFERRED:
3070 tr_transferred:
3071         case USB_ST_SETUP:
3072 tr_setup:
3073
3074                 if (mc == NULL) {
3075                         mc = sc->sc_mixer_root;
3076                         sc->sc_mixer_curr = mc;
3077                         sc->sc_mixer_chan = 0;
3078                         repeat = 0;
3079                 }
3080                 while (mc) {
3081                         while (sc->sc_mixer_chan < mc->nchan) {
3082
3083                                 len = MIX_SIZE(mc->type);
3084
3085                                 chan = sc->sc_mixer_chan;
3086
3087                                 sc->sc_mixer_chan++;
3088
3089                                 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
3090                                     (mc->wValue[chan] != -1));
3091
3092                                 mc->update[chan / 8] &= ~(1 << (chan % 8));
3093
3094                                 if (update) {
3095
3096                                         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
3097                                         req.bRequest = SET_CUR;
3098                                         USETW(req.wValue, mc->wValue[chan]);
3099                                         USETW(req.wIndex, mc->wIndex);
3100                                         USETW(req.wLength, len);
3101
3102                                         if (len > 0) {
3103                                                 buf[0] = (mc->wData[chan] & 0xFF);
3104                                         }
3105                                         if (len > 1) {
3106                                                 buf[1] = (mc->wData[chan] >> 8) & 0xFF;
3107                                         }
3108                                         pc = usbd_xfer_get_frame(xfer, 0);
3109                                         usbd_copy_in(pc, 0, &req, sizeof(req));
3110                                         pc = usbd_xfer_get_frame(xfer, 1);
3111                                         usbd_copy_in(pc, 0, buf, len);
3112
3113                                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
3114                                         usbd_xfer_set_frame_len(xfer, 1, len);
3115                                         usbd_xfer_set_frames(xfer, len ? 2 : 1);
3116                                         usbd_transfer_submit(xfer);
3117                                         return;
3118                                 }
3119                         }
3120
3121                         mc = mc->next;
3122                         sc->sc_mixer_curr = mc;
3123                         sc->sc_mixer_chan = 0;
3124                 }
3125
3126                 if (repeat) {
3127                         goto tr_setup;
3128                 }
3129                 break;
3130
3131         default:                        /* Error */
3132                 DPRINTF("error=%s\n", usbd_errstr(error));
3133                 if (error == USB_ERR_CANCELLED) {
3134                         /* do nothing - we are detaching */
3135                         break;
3136                 }
3137                 goto tr_transferred;
3138         }
3139 }
3140
3141 static usb_error_t
3142 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
3143 {
3144         struct usb_device_request req;
3145         uint8_t data[3];
3146
3147         DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
3148
3149         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
3150         req.bRequest = SET_CUR;
3151         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
3152         USETW(req.wIndex, endpt);
3153         USETW(req.wLength, 3);
3154         data[0] = speed;
3155         data[1] = speed >> 8;
3156         data[2] = speed >> 16;
3157
3158         return (usbd_do_request(udev, NULL, &req, data));
3159 }
3160
3161 static int
3162 uaudio_mixer_signext(uint8_t type, int val)
3163 {
3164         if (!MIX_UNSIGNED(type)) {
3165                 if (MIX_SIZE(type) == 2) {
3166                         val = (int16_t)val;
3167                 } else {
3168                         val = (int8_t)val;
3169                 }
3170         }
3171         return (val);
3172 }
3173
3174 static int
3175 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int32_t val)
3176 {
3177         if (mc->type == MIX_ON_OFF) {
3178                 val = (val != 0);
3179         } else if (mc->type == MIX_SELECTOR) {
3180                 if ((val < mc->minval) ||
3181                     (val > mc->maxval)) {
3182                         val = mc->minval;
3183                 }
3184         } else {
3185
3186                 /* compute actual volume */
3187                 val = (val * mc->mul) / 255;
3188
3189                 /* add lower offset */
3190                 val = val + mc->minval;
3191
3192                 /* make sure we don't write a value out of range */
3193                 if (val > mc->maxval)
3194                         val = mc->maxval;
3195                 else if (val < mc->minval)
3196                         val = mc->minval;
3197         }
3198
3199         DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
3200             mc->type, val, mc->minval, mc->maxval, val);
3201         return (val);
3202 }
3203
3204 static void
3205 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
3206     uint8_t chan, int32_t val)
3207 {
3208         val = uaudio_mixer_bsd2value(mc, val);
3209
3210         mc->update[chan / 8] |= (1 << (chan % 8));
3211         mc->wData[chan] = val;
3212
3213         /* start the transfer, if not already started */
3214
3215         usbd_transfer_start(sc->sc_mixer_xfer[0]);
3216 }
3217
3218 static void
3219 uaudio_mixer_init(struct uaudio_softc *sc)
3220 {
3221         struct uaudio_mixer_node *mc;
3222         int32_t i;
3223
3224         for (mc = sc->sc_mixer_root; mc;
3225             mc = mc->next) {
3226
3227                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
3228                         /*
3229                          * Set device mask bits. See
3230                          * /usr/include/machine/soundcard.h
3231                          */
3232                         sc->sc_mix_info |= (1 << mc->ctl);
3233                 }
3234                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
3235                     (mc->type == MIX_SELECTOR)) {
3236
3237                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
3238                                 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) {
3239                                         continue;
3240                                 }
3241                                 sc->sc_recsrc_info |= 1 << mc->slctrtype[i - 1];
3242                         }
3243                 }
3244         }
3245 }
3246
3247 int
3248 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
3249 {
3250         DPRINTF("\n");
3251
3252         if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
3253             sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
3254             mixer_get_lock(m))) {
3255                 DPRINTFN(0, "could not allocate USB "
3256                     "transfer for audio mixer!\n");
3257                 return (ENOMEM);
3258         }
3259         if (!(sc->sc_mix_info & SOUND_MASK_VOLUME)) {
3260                 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
3261                 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
3262         }
3263         mix_setdevs(m, sc->sc_mix_info);
3264         mix_setrecdevs(m, sc->sc_recsrc_info);
3265         return (0);
3266 }
3267
3268 int
3269 uaudio_mixer_uninit_sub(struct uaudio_softc *sc)
3270 {
3271         DPRINTF("\n");
3272
3273         usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
3274
3275         return (0);
3276 }
3277
3278 void
3279 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type,
3280     unsigned left, unsigned right)
3281 {
3282         struct uaudio_mixer_node *mc;
3283
3284         for (mc = sc->sc_mixer_root; mc;
3285             mc = mc->next) {
3286
3287                 if (mc->ctl == type) {
3288                         if (mc->nchan == 2) {
3289                                 /* set Right */
3290                                 uaudio_mixer_ctl_set(sc, mc, 1, (int)(right * 255) / 100);
3291                         }
3292                         /* set Left or Mono */
3293                         uaudio_mixer_ctl_set(sc, mc, 0, (int)(left * 255) / 100);
3294                 }
3295         }
3296 }
3297
3298 uint32_t
3299 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src)
3300 {
3301         struct uaudio_mixer_node *mc;
3302         uint32_t mask;
3303         uint32_t temp;
3304         int32_t i;
3305
3306         for (mc = sc->sc_mixer_root; mc;
3307             mc = mc->next) {
3308
3309                 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
3310                     (mc->type == MIX_SELECTOR)) {
3311
3312                         /* compute selector mask */
3313
3314                         mask = 0;
3315                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
3316                                 mask |= (1 << mc->slctrtype[i - 1]);
3317                         }
3318
3319                         temp = mask & src;
3320                         if (temp == 0) {
3321                                 continue;
3322                         }
3323                         /* find the first set bit */
3324                         temp = (-temp) & temp;
3325
3326                         /* update "src" */
3327                         src &= ~mask;
3328                         src |= temp;
3329
3330                         for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
3331                                 if (temp != (1 << mc->slctrtype[i - 1])) {
3332                                         continue;
3333                                 }
3334                                 uaudio_mixer_ctl_set(sc, mc, 0, i);
3335                                 break;
3336                         }
3337                 }
3338         }
3339         return (src);
3340 }
3341
3342 /*========================================================================*
3343  * MIDI support routines
3344  *========================================================================*/
3345
3346 static void
3347 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
3348 {
3349         struct umidi_chan *chan = usbd_xfer_softc(xfer);
3350         struct umidi_sub_chan *sub;
3351         struct usb_page_cache *pc;
3352         uint8_t buf[4];
3353         uint8_t cmd_len;
3354         uint8_t cn;
3355         uint16_t pos;
3356         int actlen;
3357
3358         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
3359
3360         switch (USB_GET_STATE(xfer)) {
3361         case USB_ST_TRANSFERRED:
3362
3363                 DPRINTF("actlen=%d bytes\n", actlen);
3364
3365                 pos = 0;
3366                 pc = usbd_xfer_get_frame(xfer, 0);
3367
3368                 while (actlen >= 4) {
3369
3370                         /* copy out the MIDI data */
3371                         usbd_copy_out(pc, pos, buf, 4);
3372                         /* command length */
3373                         cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
3374                         /* cable number */
3375                         cn = buf[0] >> 4;
3376                         /*
3377                          * Lookup sub-channel. The index is range
3378                          * checked below.
3379                          */
3380                         sub = &chan->sub[cn];
3381
3382                         if ((cmd_len != 0) &&
3383                             (cn < chan->max_cable) &&
3384                             (sub->read_open != 0)) {
3385
3386                                 /* Send data to the application */
3387                                 usb_fifo_put_data_linear(
3388                                     sub->fifo.fp[USB_FIFO_RX],
3389                                     buf + 1, cmd_len, 1);
3390                         }
3391                         actlen -= 4;
3392                         pos += 4;
3393                 }
3394
3395         case USB_ST_SETUP:
3396                 DPRINTF("start\n");
3397 tr_setup:
3398                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
3399                 usbd_transfer_submit(xfer);
3400                 break;
3401
3402         default:
3403                 DPRINTF("error=%s\n", usbd_errstr(error));
3404
3405                 if (error != USB_ERR_CANCELLED) {
3406                         /* try to clear stall first */
3407                         usbd_xfer_set_stall(xfer);
3408                         goto tr_setup;
3409                 }
3410                 break;
3411         }
3412 }
3413
3414 /*
3415  * The following statemachine, that converts MIDI commands to
3416  * USB MIDI packets, derives from Linux's usbmidi.c, which
3417  * was written by "Clemens Ladisch":
3418  *
3419  * Returns:
3420  *    0: No command
3421  * Else: Command is complete
3422  */
3423 static uint8_t
3424 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
3425 {
3426         uint8_t p0 = (cn << 4);
3427
3428         if (b >= 0xf8) {
3429                 sub->temp_0[0] = p0 | 0x0f;
3430                 sub->temp_0[1] = b;
3431                 sub->temp_0[2] = 0;
3432                 sub->temp_0[3] = 0;
3433                 sub->temp_cmd = sub->temp_0;
3434                 return (1);
3435
3436         } else if (b >= 0xf0) {
3437                 switch (b) {
3438                 case 0xf0:              /* system exclusive begin */
3439                         sub->temp_1[1] = b;
3440                         sub->state = UMIDI_ST_SYSEX_1;
3441                         break;
3442                 case 0xf1:              /* MIDI time code */
3443                 case 0xf3:              /* song select */
3444                         sub->temp_1[1] = b;
3445                         sub->state = UMIDI_ST_1PARAM;
3446                         break;
3447                 case 0xf2:              /* song position pointer */
3448                         sub->temp_1[1] = b;
3449                         sub->state = UMIDI_ST_2PARAM_1;
3450                         break;
3451                 case 0xf4:              /* unknown */
3452                 case 0xf5:              /* unknown */
3453                         sub->state = UMIDI_ST_UNKNOWN;
3454                         break;
3455                 case 0xf6:              /* tune request */
3456                         sub->temp_1[0] = p0 | 0x05;
3457                         sub->temp_1[1] = 0xf6;
3458                         sub->temp_1[2] = 0;
3459                         sub->temp_1[3] = 0;
3460                         sub->temp_cmd = sub->temp_1;
3461                         sub->state = UMIDI_ST_UNKNOWN;
3462                         return (1);
3463
3464                 case 0xf7:              /* system exclusive end */
3465                         switch (sub->state) {
3466                         case UMIDI_ST_SYSEX_0:
3467                                 sub->temp_1[0] = p0 | 0x05;
3468                                 sub->temp_1[1] = 0xf7;
3469                                 sub->temp_1[2] = 0;
3470                                 sub->temp_1[3] = 0;
3471                                 sub->temp_cmd = sub->temp_1;
3472                                 sub->state = UMIDI_ST_UNKNOWN;
3473                                 return (1);
3474                         case UMIDI_ST_SYSEX_1:
3475                                 sub->temp_1[0] = p0 | 0x06;
3476                                 sub->temp_1[2] = 0xf7;
3477                                 sub->temp_1[3] = 0;
3478                                 sub->temp_cmd = sub->temp_1;
3479                                 sub->state = UMIDI_ST_UNKNOWN;
3480                                 return (1);
3481                         case UMIDI_ST_SYSEX_2:
3482                                 sub->temp_1[0] = p0 | 0x07;
3483                                 sub->temp_1[3] = 0xf7;
3484                                 sub->temp_cmd = sub->temp_1;
3485                                 sub->state = UMIDI_ST_UNKNOWN;
3486                                 return (1);
3487                         }
3488                         sub->state = UMIDI_ST_UNKNOWN;
3489                         break;
3490                 }
3491         } else if (b >= 0x80) {
3492                 sub->temp_1[1] = b;
3493                 if ((b >= 0xc0) && (b <= 0xdf)) {
3494                         sub->state = UMIDI_ST_1PARAM;
3495                 } else {
3496                         sub->state = UMIDI_ST_2PARAM_1;
3497                 }
3498         } else {                        /* b < 0x80 */
3499                 switch (sub->state) {
3500                 case UMIDI_ST_1PARAM:
3501                         if (sub->temp_1[1] < 0xf0) {
3502                                 p0 |= sub->temp_1[1] >> 4;
3503                         } else {
3504                                 p0 |= 0x02;
3505                                 sub->state = UMIDI_ST_UNKNOWN;
3506                         }
3507                         sub->temp_1[0] = p0;
3508                         sub->temp_1[2] = b;
3509                         sub->temp_1[3] = 0;
3510                         sub->temp_cmd = sub->temp_1;
3511                         return (1);
3512                 case UMIDI_ST_2PARAM_1:
3513                         sub->temp_1[2] = b;
3514                         sub->state = UMIDI_ST_2PARAM_2;
3515                         break;
3516                 case UMIDI_ST_2PARAM_2:
3517                         if (sub->temp_1[1] < 0xf0) {
3518                                 p0 |= sub->temp_1[1] >> 4;
3519                                 sub->state = UMIDI_ST_2PARAM_1;
3520                         } else {
3521                                 p0 |= 0x03;
3522                                 sub->state = UMIDI_ST_UNKNOWN;
3523                         }
3524                         sub->temp_1[0] = p0;
3525                         sub->temp_1[3] = b;
3526                         sub->temp_cmd = sub->temp_1;
3527                         return (1);
3528                 case UMIDI_ST_SYSEX_0:
3529                         sub->temp_1[1] = b;
3530                         sub->state = UMIDI_ST_SYSEX_1;
3531                         break;
3532                 case UMIDI_ST_SYSEX_1:
3533                         sub->temp_1[2] = b;
3534                         sub->state = UMIDI_ST_SYSEX_2;
3535                         break;
3536                 case UMIDI_ST_SYSEX_2:
3537                         sub->temp_1[0] = p0 | 0x04;
3538                         sub->temp_1[3] = b;
3539                         sub->temp_cmd = sub->temp_1;
3540                         sub->state = UMIDI_ST_SYSEX_0;
3541                         return (1);
3542                 default:
3543                         break;
3544                 }
3545         }
3546         return (0);
3547 }
3548
3549 static void
3550 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
3551 {
3552         struct umidi_chan *chan = usbd_xfer_softc(xfer);
3553         struct umidi_sub_chan *sub;
3554         struct usb_page_cache *pc;
3555         uint32_t actlen;
3556         uint16_t nframes;
3557         uint8_t buf;
3558         uint8_t start_cable;
3559         uint8_t tr_any;
3560         int len;
3561
3562         usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
3563
3564         /*
3565          * NOTE: Some MIDI devices only accept 4 bytes of data per
3566          * short terminated USB transfer.
3567          */
3568         switch (USB_GET_STATE(xfer)) {
3569         case USB_ST_TRANSFERRED:
3570                 DPRINTF("actlen=%d bytes\n", len);
3571
3572         case USB_ST_SETUP:
3573 tr_setup:
3574                 DPRINTF("start\n");
3575
3576                 nframes = 0;    /* reset */
3577                 start_cable = chan->curr_cable;
3578                 tr_any = 0;
3579                 pc = usbd_xfer_get_frame(xfer, 0);
3580
3581                 while (1) {
3582
3583                         /* round robin de-queueing */
3584
3585                         sub = &chan->sub[chan->curr_cable];
3586
3587                         if (sub->write_open) {
3588                                 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
3589                                     &buf, 1, &actlen, 0);
3590                         } else {
3591                                 actlen = 0;
3592                         }
3593
3594                         if (actlen) {
3595
3596                                 tr_any = 1;
3597
3598                                 DPRINTF("byte=0x%02x from FIFO %u\n", buf,
3599                                     (unsigned int)chan->curr_cable);
3600
3601                                 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
3602
3603                                         DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
3604                                             sub->temp_cmd[0], sub->temp_cmd[1],
3605                                             sub->temp_cmd[2], sub->temp_cmd[3]);
3606
3607                                         usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
3608
3609                                         nframes++;
3610
3611                                         if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
3612                                                 break;
3613                                 } else {
3614                                         continue;
3615                                 }
3616                         }
3617
3618                         chan->curr_cable++;
3619                         if (chan->curr_cable >= chan->max_cable)
3620                                 chan->curr_cable = 0;
3621
3622                         if (chan->curr_cable == start_cable) {
3623                                 if (tr_any == 0)
3624                                         break;
3625                                 tr_any = 0;
3626                         }
3627                 }
3628
3629                 if (nframes != 0) {
3630                         DPRINTF("Transferring %d frames\n", (int)nframes);
3631                         usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
3632                         usbd_transfer_submit(xfer);
3633                 }
3634                 break;
3635
3636         default:                        /* Error */
3637
3638                 DPRINTF("error=%s\n", usbd_errstr(error));
3639
3640                 if (error != USB_ERR_CANCELLED) {
3641                         /* try to clear stall first */
3642                         usbd_xfer_set_stall(xfer);
3643                         goto tr_setup;
3644                 }
3645                 break;
3646         }
3647 }
3648
3649 static struct umidi_sub_chan *
3650 umidi_sub_by_fifo(struct usb_fifo *fifo)
3651 {
3652         struct umidi_chan *chan = usb_fifo_softc(fifo);
3653         struct umidi_sub_chan *sub;
3654         uint32_t n;
3655
3656         for (n = 0; n < UMIDI_CABLES_MAX; n++) {
3657                 sub = &chan->sub[n];
3658                 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
3659                     (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
3660                         return (sub);
3661                 }
3662         }
3663
3664         panic("%s:%d cannot find usb_fifo!\n",
3665             __FILE__, __LINE__);
3666
3667         return (NULL);
3668 }
3669
3670 static void
3671 umidi_start_read(struct usb_fifo *fifo)
3672 {
3673         struct umidi_chan *chan = usb_fifo_softc(fifo);
3674
3675         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
3676 }
3677
3678 static void
3679 umidi_stop_read(struct usb_fifo *fifo)
3680 {
3681         struct umidi_chan *chan = usb_fifo_softc(fifo);
3682         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
3683
3684         DPRINTF("\n");
3685
3686         sub->read_open = 0;
3687
3688         if (--(chan->read_open_refcount) == 0) {
3689                 /*
3690                  * XXX don't stop the read transfer here, hence that causes
3691                  * problems with some MIDI adapters
3692                  */
3693                 DPRINTF("(stopping read transfer)\n");
3694         }
3695 }
3696
3697 static void
3698 umidi_start_write(struct usb_fifo *fifo)
3699 {
3700         struct umidi_chan *chan = usb_fifo_softc(fifo);
3701
3702         usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
3703 }
3704
3705 static void
3706 umidi_stop_write(struct usb_fifo *fifo)
3707 {
3708         struct umidi_chan *chan = usb_fifo_softc(fifo);
3709         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
3710
3711         DPRINTF("\n");
3712
3713         sub->write_open = 0;
3714
3715         if (--(chan->write_open_refcount) == 0) {
3716                 DPRINTF("(stopping write transfer)\n");
3717                 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
3718         }
3719 }
3720
3721 static int
3722 umidi_open(struct usb_fifo *fifo, int fflags)
3723 {
3724         struct umidi_chan *chan = usb_fifo_softc(fifo);
3725         struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
3726
3727         if (fflags & FREAD) {
3728                 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
3729                         return (ENOMEM);
3730                 }
3731                 mtx_lock(&chan->mtx);
3732                 chan->read_open_refcount++;
3733                 sub->read_open = 1;
3734                 mtx_unlock(&chan->mtx);
3735         }
3736         if (fflags & FWRITE) {
3737                 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
3738                         return (ENOMEM);
3739                 }
3740                 /* clear stall first */
3741                 mtx_lock(&chan->mtx);
3742                 usbd_xfer_set_stall(chan->xfer[UMIDI_TX_TRANSFER]);
3743                 chan->write_open_refcount++;
3744                 sub->write_open = 1;
3745
3746                 /* reset */
3747                 sub->state = UMIDI_ST_UNKNOWN;
3748                 mtx_unlock(&chan->mtx);
3749         }
3750         return (0);                     /* success */
3751 }
3752
3753 static void
3754 umidi_close(struct usb_fifo *fifo, int fflags)
3755 {
3756         if (fflags & FREAD) {
3757                 usb_fifo_free_buffer(fifo);
3758         }
3759         if (fflags & FWRITE) {
3760                 usb_fifo_free_buffer(fifo);
3761         }
3762 }
3763
3764
3765 static int
3766 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
3767     int fflags)
3768 {
3769         return (ENODEV);
3770 }
3771
3772 static void
3773 umidi_init(device_t dev)
3774 {
3775         struct uaudio_softc *sc = device_get_softc(dev);
3776         struct umidi_chan *chan = &sc->sc_midi_chan;
3777
3778         mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
3779 }
3780
3781 static struct usb_fifo_methods umidi_fifo_methods = {
3782         .f_start_read = &umidi_start_read,
3783         .f_start_write = &umidi_start_write,
3784         .f_stop_read = &umidi_stop_read,
3785         .f_stop_write = &umidi_stop_write,
3786         .f_open = &umidi_open,
3787         .f_close = &umidi_close,
3788         .f_ioctl = &umidi_ioctl,
3789         .basename[0] = "umidi",
3790 };
3791
3792 static int
3793 umidi_probe(device_t dev)
3794 {
3795         struct uaudio_softc *sc = device_get_softc(dev);
3796         struct usb_attach_arg *uaa = device_get_ivars(dev);
3797         struct umidi_chan *chan = &sc->sc_midi_chan;
3798         struct umidi_sub_chan *sub;
3799         int unit = device_get_unit(dev);
3800         int error;
3801         uint32_t n;
3802
3803         if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
3804                 chan->single_command = 1;
3805
3806         if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index,
3807             chan->iface_alt_index)) {
3808                 DPRINTF("setting of alternate index failed!\n");
3809                 goto detach;
3810         }
3811         usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
3812             sc->sc_mixer_iface_index);
3813
3814         error = usbd_transfer_setup(uaa->device, &chan->iface_index,
3815             chan->xfer, umidi_config, UMIDI_N_TRANSFER,
3816             chan, &chan->mtx);
3817         if (error) {
3818                 DPRINTF("error=%s\n", usbd_errstr(error));
3819                 goto detach;
3820         }
3821         if ((chan->max_cable > UMIDI_CABLES_MAX) ||
3822             (chan->max_cable == 0)) {
3823                 chan->max_cable = UMIDI_CABLES_MAX;
3824         }
3825
3826         for (n = 0; n < chan->max_cable; n++) {
3827
3828                 sub = &chan->sub[n];
3829
3830                 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
3831                     &umidi_fifo_methods, &sub->fifo, unit, n,
3832                     chan->iface_index,
3833                     UID_ROOT, GID_OPERATOR, 0644);
3834                 if (error) {
3835                         goto detach;
3836                 }
3837         }
3838
3839         mtx_lock(&chan->mtx);
3840
3841         /* clear stall first */
3842         usbd_xfer_set_stall(chan->xfer[UMIDI_RX_TRANSFER]);
3843
3844         /*
3845          * NOTE: At least one device will not work properly unless the
3846          * BULK IN pipe is open all the time. This might have to do
3847          * about that the internal queues of the device overflow if we
3848          * don't read them regularly.
3849          */
3850         usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
3851
3852         mtx_unlock(&chan->mtx);
3853
3854         return (0);                     /* success */
3855
3856 detach:
3857         return (ENXIO);                 /* failure */
3858 }
3859
3860 static int
3861 umidi_detach(device_t dev)
3862 {
3863         struct uaudio_softc *sc = device_get_softc(dev);
3864         struct umidi_chan *chan = &sc->sc_midi_chan;
3865         uint32_t n;
3866
3867         for (n = 0; n < UMIDI_CABLES_MAX; n++) {
3868                 usb_fifo_detach(&chan->sub[n].fifo);
3869         }
3870
3871         mtx_lock(&chan->mtx);
3872
3873         usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
3874
3875         mtx_unlock(&chan->mtx);
3876
3877         usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
3878
3879         mtx_destroy(&chan->mtx);
3880
3881         return (0);
3882 }
3883
3884 DRIVER_MODULE(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0);
3885 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
3886 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
3887 MODULE_VERSION(uaudio, 1);