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