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