sys/dev/sound/usb/uaudio.c

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