sys/dev/sound/usb/uaudio.c

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