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