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