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