sys/dev/sound/usb/uaudio.c

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