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