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  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *        This product includes software developed by the NetBSD
  23  *        Foundation, Inc. and its contributors.
  24  * 4. Neither the name of The NetBSD Foundation nor the names of its
  25  *    contributors may be used to endorse or promote products derived
  26  *    from this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 /*
  42  * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf
  43  *                  http://www.usb.org/developers/devclass_docs/frmts10.pdf
  44  *                  http://www.usb.org/developers/devclass_docs/termt10.pdf
  45  */
  46
  47 #include <sys/cdefs.h>
  48 #if defined(__NetBSD__) || defined(__OpenBSD__)
  49 __KERNEL_RCSID(0, "$NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $");
  50 #endif
  51
  52 /*
  53  * Also merged:
  54  *  $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $
  55  *  $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $
  56  *  $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $
  57  *  $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $
  58  *  $NetBSD: uaudio.c,v 1.102 2006/04/14 17:00:55 christos Exp $
  59  *  $NetBSD: uaudio.c,v 1.103 2006/05/11 19:09:25 mrg Exp $
  60  *  $NetBSD: uaudio.c,v 1.105 2006/10/04 16:00:15 christos Exp $
  61  */
  62
  63 #include <sys/param.h>
  64 #include <sys/systm.h>
  65 #include <sys/kernel.h>
  66 #include <sys/malloc.h>
  67 #if defined(__NetBSD__) || defined(__OpenBSD__)
  68 #include <sys/device.h>
  69 #include <sys/ioctl.h>
  70 #endif
  71 #include <sys/tty.h>
  72 #include <sys/file.h>
  73 #include <sys/reboot.h>         /* for bootverbose */
  74 #include <sys/select.h>
  75 #include <sys/proc.h>
  76 #if defined(__NetBSD__) || defined(__OpenBSD__)
  77 #include <sys/device.h>
  78 #elif defined(__FreeBSD__)
  79 #include <sys/module.h>
  80 #include <sys/bus.h>
  81 #include <sys/conf.h>
  82 #endif
  83 #include <sys/poll.h>
  84 #if defined(__FreeBSD__)
  85 #include <sys/sysctl.h>
  86 #include <sys/sbuf.h>
  87 #endif
  88
  89 #if defined(__NetBSD__) || defined(__OpenBSD__)
  90 #include <sys/audioio.h>
  91 #include <dev/audio_if.h>
  92 #include <dev/audiovar.h>
  93 #include <dev/mulaw.h>
  94 #include <dev/auconv.h>
  95 #elif defined(__FreeBSD__)
  96 #include <dev/sound/pcm/sound.h>        /* XXXXX */
  97 #include <dev/sound/chip.h>
  98 #include "feeder_if.h"
  99 #endif
 100
 101 #include <dev/usb/usb_port.h>
 102 #include <dev/usb/usb.h>
 103 #include <dev/usb/usbdi.h>
 104 #include <dev/usb/usbdi_util.h>
 105 #include <dev/usb/usb_quirks.h>
 106
 107 #if defined(__NetBSD__) || defined(__OpenBSD__)
 108 #include <dev/usb/uaudioreg.h>
 109 #elif defined(__FreeBSD__)
 110 #include <dev/sound/usb/uaudioreg.h>
 111 #include <dev/sound/usb/uaudio.h>
 112 #endif
 113
 114 #if defined(__NetBSD__) || defined(__OpenBSD__)
 115 /* #define UAUDIO_DEBUG */
 116 #else
 117 /* #define USB_DEBUG */
 118 #endif
 119 /* #define UAUDIO_MULTIPLE_ENDPOINTS */
 120 #ifdef USB_DEBUG
 121 #define DPRINTF(x)      do { if (uaudiodebug) printf x; } while (0)
 122 #define DPRINTFN(n,x)   do { if (uaudiodebug>(n)) printf x; } while (0)
 123 int     uaudiodebug = 0;
 124 #if defined(__FreeBSD__)
 125 SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio");
 126 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW,
 127            &uaudiodebug, 0, "uaudio debug level");
 128 #endif
 129 #else
 130 #define DPRINTF(x)
 131 #define DPRINTFN(n,x)
 132 #endif
 133
 134 #define UAUDIO_NCHANBUFS 6      /* number of outstanding request */
 135 #if defined(__NetBSD__) || defined(__OpenBSD__)
 136 #define UAUDIO_NFRAMES   10     /* ms of sound in each request */
 137 #elif defined(__FreeBSD__)
 138 #define UAUDIO_NFRAMES   20     /* ms of sound in each request */
 139 #endif
 140
 141
 142 #define MIX_MAX_CHAN 8
 143 struct mixerctl {
 144         uint16_t        wValue[MIX_MAX_CHAN]; /* using nchan */
 145         uint16_t        wIndex;
 146         uint8_t         nchan;
 147         uint8_t         type;
 148 #define MIX_ON_OFF      1
 149 #define MIX_SIGNED_16   2
 150 #define MIX_UNSIGNED_16 3
 151 #define MIX_SIGNED_8    4
 152 #define MIX_SELECTOR    5
 153 #define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1)
 154 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
 155         int             minval, maxval;
 156         u_int           delta;
 157         u_int           mul;
 158 #if defined(__FreeBSD__) /* XXXXX */
 159         unsigned        ctl;
 160 #define MAX_SELECTOR_INPUT_PIN 256
 161         uint8_t         slctrtype[MAX_SELECTOR_INPUT_PIN];
 162 #endif
 163         uint8_t         class;
 164 #if !defined(__FreeBSD__)
 165         char            ctlname[MAX_AUDIO_DEV_LEN];
 166         char            *ctlunit;
 167 #endif
 168 };
 169 #define MAKE(h,l) (((h) << 8) | (l))
 170
 171 struct as_info {
 172         uint8_t         alt;
 173         uint8_t         encoding;
 174         uint8_t         attributes; /* Copy of bmAttributes of
 175                                      * usb_audio_streaming_endpoint_descriptor
 176                                      */
 177         usbd_interface_handle   ifaceh;
 178         const usb_interface_descriptor_t *idesc;
 179         const usb_endpoint_descriptor_audio_t *edesc;
 180         const usb_endpoint_descriptor_audio_t *edesc1;
 181         const struct usb_audio_streaming_type1_descriptor *asf1desc;
 182         int             sc_busy;        /* currently used */
 183 };
 184
 185 struct chan {
 186 #if defined(__NetBSD__) || defined(__OpenBSD__)
 187         void    (*intr)(void *);        /* DMA completion intr handler */
 188         void    *arg;           /* arg for intr() */
 189 #else
 190         struct pcm_channel *pcm_ch;
 191 #endif
 192         usbd_pipe_handle pipe;
 193         usbd_pipe_handle sync_pipe;
 194
 195         u_int   sample_size;
 196         u_int   sample_rate;
 197         u_int   bytes_per_frame;
 198         u_int   fraction;       /* fraction/1000 is the extra samples/frame */
 199         u_int   residue;        /* accumulates the fractional samples */
 200
 201         u_char  *start;         /* upper layer buffer start */
 202         u_char  *end;           /* upper layer buffer end */
 203         u_char  *cur;           /* current position in upper layer buffer */
 204         int     blksize;        /* chunk size to report up */
 205         int     transferred;    /* transferred bytes not reported up */
 206
 207         int     altidx;         /* currently used altidx */
 208
 209         int     curchanbuf;
 210         struct chanbuf {
 211                 struct chan     *chan;
 212                 usbd_xfer_handle xfer;
 213                 u_char          *buffer;
 214                 u_int16_t       sizes[UAUDIO_NFRAMES];
 215                 u_int16_t       offsets[UAUDIO_NFRAMES];
 216                 u_int16_t       size;
 217         } chanbufs[UAUDIO_NCHANBUFS];
 218
 219         struct uaudio_softc *sc; /* our softc */
 220 #if defined(__FreeBSD__)
 221         u_int32_t format;
 222         int     precision;
 223         int     channels;
 224 #endif
 225 };
 226
 227 struct uaudio_softc {
 228         device_t        sc_dev;         /* base device */
 229         usbd_device_handle sc_udev;     /* USB device */
 230         int             sc_ac_iface;    /* Audio Control interface */
 231         usbd_interface_handle   sc_ac_ifaceh;
 232         struct chan     sc_playchan;    /* play channel */
 233         struct chan     sc_recchan;     /* record channel */
 234         int             sc_nullalt;
 235         int             sc_audio_rev;
 236         struct as_info  *sc_alts;       /* alternate settings */
 237         int             sc_nalts;       /* # of alternate settings */
 238         int             sc_altflags;
 239 #define HAS_8           0x01
 240 #define HAS_16          0x02
 241 #define HAS_8U          0x04
 242 #define HAS_ALAW        0x08
 243 #define HAS_MULAW       0x10
 244 #define UA_NOFRAC       0x20            /* don't do sample rate adjustment */
 245 #define HAS_24          0x40
 246 #define HAS_32          0x80
 247         int             sc_mode;        /* play/record capability */
 248         struct mixerctl *sc_ctls;       /* mixer controls */
 249         int             sc_nctls;       /* # of mixer controls */
 250         device_t        sc_audiodev;
 251         char            sc_dying;
 252 #if defined(__FreeBSD__)
 253         struct sbuf     uaudio_sndstat;
 254         int             uaudio_sndstat_flag;
 255         int             async;
 256 #endif
 257         int             sc_vendor;
 258         int             sc_product;
 259         int             sc_release;
 260 };
 261
 262 struct terminal_list {
 263         int size;
 264         uint16_t terminals[1];
 265 };
 266 #define TERMINAL_LIST_SIZE(N)   (offsetof(struct terminal_list, terminals) \
 267                                 + sizeof(uint16_t) * (N))
 268
 269 struct io_terminal {
 270         union {
 271                 const usb_descriptor_t *desc;
 272                 const struct usb_audio_input_terminal *it;
 273                 const struct usb_audio_output_terminal *ot;
 274                 const struct usb_audio_mixer_unit *mu;
 275                 const struct usb_audio_selector_unit *su;
 276                 const struct usb_audio_feature_unit *fu;
 277                 const struct usb_audio_processing_unit *pu;
 278                 const struct usb_audio_extension_unit *eu;
 279         } d;
 280         int inputs_size;
 281         struct terminal_list **inputs; /* list of source input terminals */
 282         struct terminal_list *output; /* list of destination output terminals */
 283         int direct;             /* directly connected to an output terminal */
 284 };
 285
 286 #define UAC_OUTPUT      0
 287 #define UAC_INPUT       1
 288 #define UAC_EQUAL       2
 289 #define UAC_RECORD      3
 290 #define UAC_NCLASSES    4
 291 #ifdef USB_DEBUG
 292 #if defined(__FreeBSD__)
 293 #define AudioCinputs    "inputs"
 294 #define AudioCoutputs   "outputs"
 295 #define AudioCrecord    "record"
 296 #define AudioCequalization      "equalization"
 297 #endif
 298 static const char *uac_names[] = {
 299         AudioCoutputs, AudioCinputs, AudioCequalization, AudioCrecord,
 300 };
 301 #endif
 302
 303 static usbd_status uaudio_identify_ac
 304         (struct uaudio_softc *, const usb_config_descriptor_t *);
 305 static usbd_status uaudio_identify_as
 306         (struct uaudio_softc *, const usb_config_descriptor_t *);
 307 static usbd_status uaudio_process_as
 308         (struct uaudio_softc *, const char *, int *, int,
 309          const usb_interface_descriptor_t *);
 310
 311 static void     uaudio_add_alt(struct uaudio_softc *, const struct as_info *);
 312
 313 static const usb_interface_descriptor_t *uaudio_find_iface
 314         (const char *, int, int *, int);
 315
 316 static void     uaudio_mixer_add_ctl(struct uaudio_softc *, struct mixerctl *);
 317
 318 #if defined(__NetBSD__) || defined(__OpenBSD__)
 319 static char     *uaudio_id_name
 320         (struct uaudio_softc *, const struct io_terminal *, int);
 321 #endif
 322
 323 #ifdef USB_DEBUG
 324 static void     uaudio_dump_cluster(const struct usb_audio_cluster *);
 325 #endif
 326 static struct usb_audio_cluster uaudio_get_cluster
 327         (int, const struct io_terminal *);
 328 static void     uaudio_add_input
 329         (struct uaudio_softc *, const struct io_terminal *, int);
 330 static void     uaudio_add_output
 331         (struct uaudio_softc *, const struct io_terminal *, int);
 332 static void     uaudio_add_mixer
 333         (struct uaudio_softc *, const struct io_terminal *, int);
 334 static void     uaudio_add_selector
 335         (struct uaudio_softc *, const struct io_terminal *, int);
 336 #ifdef USB_DEBUG
 337 static const char *uaudio_get_terminal_name(int);
 338 #endif
 339 static int      uaudio_determine_class
 340         (const struct io_terminal *, struct mixerctl *);
 341 #if defined(__FreeBSD__)
 342 static int uaudio_feature_name(const struct io_terminal *,
 343         struct mixerctl *);
 344 #else
 345 static const char *uaudio_feature_name
 346         (const struct io_terminal *, struct mixerctl *);
 347 #endif
 348 static void     uaudio_add_feature
 349         (struct uaudio_softc *, const struct io_terminal *, int);
 350 static void     uaudio_add_processing_updown
 351         (struct uaudio_softc *, const struct io_terminal *, int);
 352 static void     uaudio_add_processing
 353         (struct uaudio_softc *, const struct io_terminal *, int);
 354 static void     uaudio_add_extension
 355         (struct uaudio_softc *, const struct io_terminal *, int);
 356 static struct terminal_list *uaudio_merge_terminal_list
 357         (const struct io_terminal *);
 358 static struct terminal_list *uaudio_io_terminaltype
 359         (int, struct io_terminal *, int);
 360 static usbd_status uaudio_identify
 361         (struct uaudio_softc *, const usb_config_descriptor_t *);
 362
 363 static int      uaudio_signext(int, int);
 364 #if defined(__NetBSD__) || defined(__OpenBSD__)
 365 static int      uaudio_value2bsd(struct mixerctl *, int);
 366 #endif
 367 static int      uaudio_bsd2value(struct mixerctl *, int);
 368 static int      uaudio_get(struct uaudio_softc *, int, int, int, int, int);
 369 #if defined(__NetBSD__) || defined(__OpenBSD__)
 370 static int      uaudio_ctl_get
 371         (struct uaudio_softc *, int, struct mixerctl *, int);
 372 #endif
 373 static void     uaudio_set
 374         (struct uaudio_softc *, int, int, int, int, int, int);
 375 static void     uaudio_ctl_set
 376         (struct uaudio_softc *, int, struct mixerctl *, int, int);
 377
 378 static usbd_status uaudio_set_speed(struct uaudio_softc *, int, u_int);
 379
 380 static usbd_status uaudio_chan_open(struct uaudio_softc *, struct chan *);
 381 static void     uaudio_chan_close(struct uaudio_softc *, struct chan *);
 382 static usbd_status uaudio_chan_alloc_buffers
 383         (struct uaudio_softc *, struct chan *);
 384 static void     uaudio_chan_free_buffers(struct uaudio_softc *, struct chan *);
 385
 386 #if defined(__NetBSD__) || defined(__OpenBSD__)
 387 static void     uaudio_chan_init
 388         (struct chan *, int, const struct audio_params *, int);
 389 static void     uaudio_chan_set_param(struct chan *, u_char *, u_char *, int);
 390 #endif
 391
 392 static void     uaudio_chan_ptransfer(struct chan *);
 393 static void     uaudio_chan_pintr
 394         (usbd_xfer_handle, usbd_private_handle, usbd_status);
 395
 396 static void     uaudio_chan_rtransfer(struct chan *);
 397 static void     uaudio_chan_rintr
 398         (usbd_xfer_handle, usbd_private_handle, usbd_status);
 399
 400 #if defined(__NetBSD__) || defined(__OpenBSD__)
 401 static int      uaudio_open(void *, int);
 402 static void     uaudio_close(void *);
 403 static int      uaudio_drain(void *);
 404 static int      uaudio_query_encoding(void *, struct audio_encoding *);
 405 static void     uaudio_get_minmax_rates
 406         (int, const struct as_info *, const struct audio_params *,
 407          int, u_long *, u_long *);
 408 static int      uaudio_match_alt_sub
 409         (int, const struct as_info *, const struct audio_params *, int, u_long);
 410 static int      uaudio_match_alt_chan
 411         (int, const struct as_info *, struct audio_params *, int);
 412 static int      uaudio_match_alt
 413         (int, const struct as_info *, struct audio_params *, int);
 414 static int      uaudio_set_params
 415         (void *, int, int, struct audio_params *, struct audio_params *);
 416 static int      uaudio_round_blocksize(void *, int);
 417 static int      uaudio_trigger_output
 418         (void *, void *, void *, int, void (*)(void *), void *,
 419          struct audio_params *);
 420 static int      uaudio_trigger_input
 421         (void *, void *, void *, int, void (*)(void *), void *,
 422          struct audio_params *);
 423 static int      uaudio_halt_in_dma(void *);
 424 static int      uaudio_halt_out_dma(void *);
 425 static int      uaudio_getdev(void *, struct audio_device *);
 426 static int      uaudio_mixer_set_port(void *, mixer_ctrl_t *);
 427 static int      uaudio_mixer_get_port(void *, mixer_ctrl_t *);
 428 static int      uaudio_query_devinfo(void *, mixer_devinfo_t *);
 429 static int      uaudio_get_props(void *);
 430
 431 static const struct audio_hw_if uaudio_hw_if = {
 432         uaudio_open,
 433         uaudio_close,
 434         uaudio_drain,
 435         uaudio_query_encoding,
 436         uaudio_set_params,
 437         uaudio_round_blocksize,
 438         NULL,
 439         NULL,
 440         NULL,
 441         NULL,
 442         NULL,
 443         uaudio_halt_out_dma,
 444         uaudio_halt_in_dma,
 445         NULL,
 446         uaudio_getdev,
 447         NULL,
 448         uaudio_mixer_set_port,
 449         uaudio_mixer_get_port,
 450         uaudio_query_devinfo,
 451         NULL,
 452         NULL,
 453         NULL,
 454         NULL,
 455         uaudio_get_props,
 456         uaudio_trigger_output,
 457         uaudio_trigger_input,
 458         NULL,
 459 };
 460
 461 static struct audio_device uaudio_device = {
 462         "USB audio",
 463         "",
 464         "uaudio"
 465 };
 466
 467 #elif defined(__FreeBSD__)
 468 static int      audio_attach_mi(device_t);
 469 static int      uaudio_init_params(struct uaudio_softc * sc, struct chan *ch, int mode);
 470 static int      uaudio_sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose);
 471
 472 /* for NetBSD compatibirity */
 473 #define AUMODE_PLAY     0x01
 474 #define AUMODE_RECORD   0x02
 475
 476 #define AUDIO_PROP_FULLDUPLEX   0x01
 477
 478 #define AUDIO_ENCODING_ULAW             1
 479 #define AUDIO_ENCODING_ALAW             2
 480 #define AUDIO_ENCODING_SLINEAR_LE       6
 481 #define AUDIO_ENCODING_SLINEAR_BE       7
 482 #define AUDIO_ENCODING_ULINEAR_LE       8
 483 #define AUDIO_ENCODING_ULINEAR_BE       9
 484
 485 #endif  /* FreeBSD */
 486
 487
 488 #if defined(__NetBSD__) || defined(__OpenBSD__)
 489
 490 USB_DECLARE_DRIVER(uaudio);
 491
 492 #elif defined(__FreeBSD__)
 493
 494 USB_DECLARE_DRIVER_INIT(uaudio,
 495                 DEVMETHOD(device_suspend, bus_generic_suspend),
 496                 DEVMETHOD(device_resume, bus_generic_resume),
 497                 DEVMETHOD(device_shutdown, bus_generic_shutdown),
 498                 DEVMETHOD(bus_print_child, bus_generic_print_child)
 499                 );
 500 #endif
 501
 502
 503 USB_MATCH(uaudio)
 504 {
 505         USB_MATCH_START(uaudio, uaa);
 506         usb_interface_descriptor_t *id;
 507
 508         if (uaa->iface == NULL)
 509                 return UMATCH_NONE;
 510
 511         id = usbd_get_interface_descriptor(uaa->iface);
 512         /* Trigger on the control interface. */
 513         if (id == NULL ||
 514             id->bInterfaceClass != UICLASS_AUDIO ||
 515             id->bInterfaceSubClass != UISUBCLASS_AUDIOCONTROL ||
 516             (usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO))
 517                 return UMATCH_NONE;
 518
 519         return UMATCH_IFACECLASS_IFACESUBCLASS;
 520 }
 521
 522 USB_ATTACH(uaudio)
 523 {
 524         USB_ATTACH_START(uaudio, sc, uaa);
 525         usb_interface_descriptor_t *id;
 526         usb_config_descriptor_t *cdesc;
 527 #if !defined(__FreeBSD__)
 528         char devinfo[1024];
 529 #endif
 530         usbd_status err;
 531         int i, j, found;
 532
 533 #if defined(__FreeBSD__)
 534         sc->sc_dev = self;
 535 #else
 536         usbd_devinfo(uaa->device, 0, devinfo, sizeof(devinfo));
 537         printf(": %s\n", devinfo);
 538 #endif
 539
 540         sc->sc_udev = uaa->device;
 541         sc->sc_vendor = uaa->vendor;
 542         sc->sc_product = uaa->product;
 543         sc->sc_release = uaa->release;
 544 #if defined(__FreeBSD__)
 545         if (resource_int_value(device_get_name(sc->sc_dev),
 546             device_get_unit(sc->sc_dev), "async", &i) == 0 && i != 0)
 547                 sc->async = 1;
 548         else
 549                 sc->async = 0;
 550 #endif
 551
 552         cdesc = usbd_get_config_descriptor(sc->sc_udev);
 553         if (cdesc == NULL) {
 554                 printf("%s: failed to get configuration descriptor\n",
 555                        device_get_nameunit(sc->sc_dev));
 556                 return ENXIO;
 557         }
 558
 559         err = uaudio_identify(sc, cdesc);
 560         if (err) {
 561                 printf("%s: audio descriptors make no sense, error=%d\n",
 562                        device_get_nameunit(sc->sc_dev), err);
 563                 return ENXIO;
 564         }
 565
 566         sc->sc_ac_ifaceh = uaa->iface;
 567         /* Pick up the AS interface. */
 568         for (i = 0; i < uaa->nifaces; i++) {
 569                 if (uaa->ifaces[i] == NULL)
 570                         continue;
 571                 id = usbd_get_interface_descriptor(uaa->ifaces[i]);
 572                 if (id == NULL)
 573                         continue;
 574                 found = 0;
 575                 for (j = 0; j < sc->sc_nalts; j++) {
 576                         if (id->bInterfaceNumber ==
 577                             sc->sc_alts[j].idesc->bInterfaceNumber) {
 578                                 sc->sc_alts[j].ifaceh = uaa->ifaces[i];
 579                                 found = 1;
 580                         }
 581                 }
 582                 if (found)
 583                         uaa->ifaces[i] = NULL;
 584         }
 585
 586         for (j = 0; j < sc->sc_nalts; j++) {
 587                 if (sc->sc_alts[j].ifaceh == NULL) {
 588                         printf("%s: alt %d missing AS interface(s)\n",
 589                             device_get_nameunit(sc->sc_dev), j);
 590                         return ENXIO;
 591                 }
 592         }
 593
 594         printf("%s: audio rev %d.%02x\n", device_get_nameunit(sc->sc_dev),
 595                sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff);
 596
 597         sc->sc_playchan.sc = sc->sc_recchan.sc = sc;
 598         sc->sc_playchan.altidx = -1;
 599         sc->sc_recchan.altidx = -1;
 600
 601         if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_FRAC)
 602                 sc->sc_altflags |= UA_NOFRAC;
 603
 604 #ifndef USB_DEBUG
 605         if (bootverbose)
 606 #endif
 607                 printf("%s: %d mixer controls\n", device_get_nameunit(sc->sc_dev),
 608                     sc->sc_nctls);
 609
 610 #if !defined(__FreeBSD__)
 611         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
 612                            USBDEV(sc->sc_dev));
 613 #endif
 614
 615         DPRINTF(("uaudio_attach: doing audio_attach_mi\n"));
 616 #if defined(__OpenBSD__)
 617         audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
 618 #elif defined(__NetBSD__)
 619         sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
 620 #elif defined(__FreeBSD__)
 621         sc->sc_dying = 0;
 622         if (audio_attach_mi(sc->sc_dev)) {
 623                 printf("audio_attach_mi failed\n");
 624                 return ENXIO;
 625         }
 626 #endif
 627
 628 #if defined(__FreeBSD__)
 629         SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->sc_dev),
 630             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)),
 631             OID_AUTO, "async", CTLFLAG_RW, &sc->async, 0,
 632             "Asynchronous USB request");
 633 #endif
 634         return 0;
 635 }
 636
 637 #if defined(__NetBSD__) || defined(__OpenBSD__)
 638 int
 639 uaudio_activate(device_t self, enum devact act)
 640 {
 641         struct uaudio_softc *sc;
 642         int rv;
 643
 644         sc = (struct uaudio_softc *)self;
 645         rv = 0;
 646         switch (act) {
 647         case DVACT_ACTIVATE:
 648                 return EOPNOTSUPP;
 649
 650         case DVACT_DEACTIVATE:
 651                 if (sc->sc_audiodev != NULL)
 652                         rv = config_deactivate(sc->sc_audiodev);
 653                 sc->sc_dying = 1;
 654                 break;
 655         }
 656         return rv;
 657 }
 658 #endif
 659
 660 #if defined(__NetBSD__) || defined(__OpenBSD__)
 661 int
 662 uaudio_detach(device_t self, int flags)
 663 {
 664         struct uaudio_softc *sc;
 665         int rv;
 666
 667         sc = (struct uaudio_softc *)self;
 668         rv = 0;
 669         /* Wait for outstanding requests to complete. */
 670         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
 671
 672         if (sc->sc_audiodev != NULL)
 673                 rv = config_detach(sc->sc_audiodev, flags);
 674
 675         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
 676                            USBDEV(sc->sc_dev));
 677
 678         return rv;
 679 }
 680 #elif defined(__FreeBSD__)
 681
 682 USB_DETACH(uaudio)
 683 {
 684         struct sndcard_func *func;
 685         device_t *devlist = NULL;
 686         int err, i, devcount;
 687
 688         USB_DETACH_START(uaudio, sc);
 689
 690         sbuf_delete(&(sc->uaudio_sndstat));
 691         sc->uaudio_sndstat_flag = 0;
 692
 693         sc->sc_dying = 1;
 694
 695 #if 0 /* XXX */
 696         /* Wait for outstanding requests to complete. */
 697         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
 698 #endif
 699
 700         err = bus_generic_detach(sc->sc_dev);
 701
 702         if (err == 0) {
 703                 device_get_children(sc->sc_dev, &devlist, &devcount);
 704                 for (i = 0; devlist != NULL && i < devcount; i++) {
 705                         func = device_get_ivars(devlist[i]);
 706                         if (func != NULL && func->func == SCF_PCM &&
 707                             func->varinfo == NULL) {
 708                                 device_set_ivars(devlist[i], NULL);
 709                                 free(func, M_DEVBUF);
 710                                 device_delete_child(sc->sc_dev, devlist[i]);
 711                         }
 712                 }
 713                 if (devlist != NULL)
 714                         free(devlist, M_TEMP);
 715         }
 716
 717         return err;
 718 }
 719 #endif
 720
 721 #if defined(__NetBSD__) || defined(__OpenBSD__)
 722 static int
 723 uaudio_query_encoding(void *addr, struct audio_encoding *fp)
 724 {
 725         struct uaudio_softc *sc;
 726         int flags;
 727         int idx;
 728
 729         sc = addr;
 730         flags = sc->sc_altflags;
 731         if (sc->sc_dying)
 732                 return EIO;
 733
 734         if (sc->sc_nalts == 0 || flags == 0)
 735                 return ENXIO;
 736
 737         idx = fp->index;
 738         switch (idx) {
 739         case 0:
 740                 strlcpy(fp->name, AudioEulinear, sizeof(fp->name));
 741                 fp->encoding = AUDIO_ENCODING_ULINEAR;
 742                 fp->precision = 8;
 743                 fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
 744                 return (0);
 745         case 1:
 746                 strlcpy(fp->name, AudioEmulaw, sizeof(fp->name));
 747                 fp->encoding = AUDIO_ENCODING_ULAW;
 748                 fp->precision = 8;
 749                 fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
 750                 return (0);
 751         case 2:
 752                 strlcpy(fp->name, AudioEalaw, sizeof(fp->name));
 753                 fp->encoding = AUDIO_ENCODING_ALAW;
 754                 fp->precision = 8;
 755                 fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
 756                 return (0);
 757         case 3:
 758                 strlcpy(fp->name, AudioEslinear, sizeof(fp->name));
 759                 fp->encoding = AUDIO_ENCODING_SLINEAR;
 760                 fp->precision = 8;
 761                 fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
 762                 return (0);
 763         case 4:
 764                 strlcpy(fp->name, AudioEslinear_le, sizeof(fp->name));
 765                 fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
 766                 fp->precision = 16;
 767                 fp->flags = 0;
 768                 return (0);
 769         case 5:
 770                 strlcpy(fp->name, AudioEulinear_le, sizeof(fp->name));
 771                 fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
 772                 fp->precision = 16;
 773                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 774                 return (0);
 775         case 6:
 776                 strlcpy(fp->name, AudioEslinear_be, sizeof(fp->name));
 777                 fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
 778                 fp->precision = 16;
 779                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 780                 return (0);
 781         case 7:
 782                 strlcpy(fp->name, AudioEulinear_be, sizeof(fp->name));
 783                 fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
 784                 fp->precision = 16;
 785                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 786                 return (0);
 787         default:
 788                 return (EINVAL);
 789         }
 790 }
 791 #endif
 792
 793 static const usb_interface_descriptor_t *
 794 uaudio_find_iface(const char *buf, int size, int *offsp, int subtype)
 795 {
 796         const usb_interface_descriptor_t *d;
 797
 798         while (*offsp < size) {
 799                 d = (const void *)(buf + *offsp);
 800                 *offsp += d->bLength;
 801                 if (d->bDescriptorType == UDESC_INTERFACE &&
 802                     d->bInterfaceClass == UICLASS_AUDIO &&
 803                     d->bInterfaceSubClass == subtype)
 804                         return d;
 805         }
 806         return NULL;
 807 }
 808
 809 static void
 810 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct mixerctl *mc)
 811 {
 812         int res;
 813         size_t len;
 814         struct mixerctl *nmc;
 815
 816 #if defined(__FreeBSD__)
 817         if (mc->class < UAC_NCLASSES) {
 818                 DPRINTF(("%s: adding %s.%d\n",
 819                          __func__, uac_names[mc->class], mc->ctl));
 820         } else {
 821                 DPRINTF(("%s: adding %d\n", __func__, mc->ctl));
 822         }
 823 #else
 824         if (mc->class < UAC_NCLASSES) {
 825                 DPRINTF(("%s: adding %s.%s\n",
 826                          __func__, uac_names[mc->class], mc->ctlname));
 827         } else {
 828                 DPRINTF(("%s: adding %s\n", __func__, mc->ctlname));
 829         }
 830 #endif
 831         len = sizeof(*mc) * (sc->sc_nctls + 1);
 832         nmc = malloc(len, M_USBDEV, M_NOWAIT);
 833         if (nmc == NULL) {
 834                 printf("uaudio_mixer_add_ctl: no memory\n");
 835                 return;
 836         }
 837         /* Copy old data, if there was any */
 838         if (sc->sc_nctls != 0) {
 839                 memcpy(nmc, sc->sc_ctls, sizeof(*mc) * (sc->sc_nctls));
 840                 free(sc->sc_ctls, M_USBDEV);
 841         }
 842         sc->sc_ctls = nmc;
 843
 844         mc->delta = 0;
 845         if (mc->type == MIX_ON_OFF) {
 846                 mc->minval = 0;
 847                 mc->maxval = 1;
 848         } else if (mc->type == MIX_SELECTOR) {
 849                 ;
 850         } else {
 851                 /* Determine min and max values. */
 852                 mc->minval = uaudio_signext(mc->type,
 853                         uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE,
 854                                    mc->wValue[0], mc->wIndex,
 855                                    MIX_SIZE(mc->type)));
 856                 mc->maxval = 1 + uaudio_signext(mc->type,
 857                         uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE,
 858                                    mc->wValue[0], mc->wIndex,
 859                                    MIX_SIZE(mc->type)));
 860                 mc->mul = mc->maxval - mc->minval;
 861                 if (mc->mul == 0)
 862                         mc->mul = 1;
 863                 res = uaudio_get(sc, GET_RES, UT_READ_CLASS_INTERFACE,
 864                                  mc->wValue[0], mc->wIndex,
 865                                  MIX_SIZE(mc->type));
 866                 if (res > 0)
 867                         mc->delta = (res * 255 + mc->mul/2) / mc->mul;
 868         }
 869
 870         sc->sc_ctls[sc->sc_nctls++] = *mc;
 871
 872 #ifdef USB_DEBUG
 873         if (uaudiodebug > 2) {
 874                 int i;
 875                 DPRINTF(("uaudio_mixer_add_ctl: wValue=%04x",mc->wValue[0]));
 876                 for (i = 1; i < mc->nchan; i++)
 877                         DPRINTF((",%04x", mc->wValue[i]));
 878 #if defined(__FreeBSD__)
 879                 DPRINTF((" wIndex=%04x type=%d ctl='%d' "
 880                          "min=%d max=%d\n",
 881                          mc->wIndex, mc->type, mc->ctl,
 882                          mc->minval, mc->maxval));
 883 #else
 884                 DPRINTF((" wIndex=%04x type=%d name='%s' unit='%s' "
 885                          "min=%d max=%d\n",
 886                          mc->wIndex, mc->type, mc->ctlname, mc->ctlunit,
 887                          mc->minval, mc->maxval));
 888 #endif
 889         }
 890 #endif
 891 }
 892
 893 #if defined(__NetBSD__) || defined(__OpenBSD__)
 894 static char *
 895 uaudio_id_name(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
 896 {
 897         static char buf[32];
 898
 899         snprintf(buf, sizeof(buf), "i%d", id);
 900         return buf;
 901 }
 902 #endif
 903
 904 #ifdef USB_DEBUG
 905 static void
 906 uaudio_dump_cluster(const struct usb_audio_cluster *cl)
 907 {
 908         static const char *channel_names[16] = {
 909                 "LEFT", "RIGHT", "CENTER", "LFE",
 910                 "LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER",
 911                 "SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP",
 912                 "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15",
 913         };
 914         int cc, i, first;
 915
 916         cc = UGETW(cl->wChannelConfig);
 917         printf("cluster: bNrChannels=%u wChannelConfig=0x%.4x",
 918                   cl->bNrChannels, cc);
 919         first = TRUE;
 920         for (i = 0; cc != 0; i++) {
 921                 if (cc & 1) {
 922                         printf("%c%s", first ? '<' : ',', channel_names[i]);
 923                         first = FALSE;
 924                 }
 925                 cc = cc >> 1;
 926         }
 927         printf("> iChannelNames=%u", cl->iChannelNames);
 928 }
 929 #endif
 930
 931 static struct usb_audio_cluster
 932 uaudio_get_cluster(int id, const struct io_terminal *iot)
 933 {
 934         struct usb_audio_cluster r;
 935         const usb_descriptor_t *dp;
 936         int i;
 937
 938         for (i = 0; i < 25; i++) { /* avoid infinite loops */
 939                 dp = iot[id].d.desc;
 940                 if (dp == 0)
 941                         goto bad;
 942                 switch (dp->bDescriptorSubtype) {
 943                 case UDESCSUB_AC_INPUT:
 944                         r.bNrChannels = iot[id].d.it->bNrChannels;
 945                         USETW(r.wChannelConfig, UGETW(iot[id].d.it->wChannelConfig));
 946                         r.iChannelNames = iot[id].d.it->iChannelNames;
 947                         return r;
 948                 case UDESCSUB_AC_OUTPUT:
 949                         id = iot[id].d.ot->bSourceId;
 950                         break;
 951                 case UDESCSUB_AC_MIXER:
 952                         r = *(const struct usb_audio_cluster *)
 953                                 &iot[id].d.mu->baSourceId[iot[id].d.mu->bNrInPins];
 954                         return r;
 955                 case UDESCSUB_AC_SELECTOR:
 956                         /* XXX This is not really right */
 957                         id = iot[id].d.su->baSourceId[0];
 958                         break;
 959                 case UDESCSUB_AC_FEATURE:
 960                         id = iot[id].d.fu->bSourceId;
 961                         break;
 962                 case UDESCSUB_AC_PROCESSING:
 963                         r = *(const struct usb_audio_cluster *)
 964                                 &iot[id].d.pu->baSourceId[iot[id].d.pu->bNrInPins];
 965                         return r;
 966                 case UDESCSUB_AC_EXTENSION:
 967                         r = *(const struct usb_audio_cluster *)
 968                                 &iot[id].d.eu->baSourceId[iot[id].d.eu->bNrInPins];
 969                         return r;
 970                 default:
 971                         goto bad;
 972                 }
 973         }
 974  bad:
 975         printf("uaudio_get_cluster: bad data\n");
 976         memset(&r, 0, sizeof r);
 977         return r;
 978
 979 }
 980
 981 static void
 982 uaudio_add_input(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
 983 {
 984 #ifdef USB_DEBUG
 985         const struct usb_audio_input_terminal *d = iot[id].d.it;
 986
 987         DPRINTFN(2,("uaudio_add_input: bTerminalId=%d wTerminalType=0x%04x "
 988                     "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d "
 989                     "iChannelNames=%d iTerminal=%d\n",
 990                     d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
 991                     d->bNrChannels, UGETW(d->wChannelConfig),
 992                     d->iChannelNames, d->iTerminal));
 993 #endif
 994 }
 995
 996 static void
 997 uaudio_add_output(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
 998 {
 999 #ifdef USB_DEBUG
1000         const struct usb_audio_output_terminal *d;
1001
1002         d = iot[id].d.ot;
1003         DPRINTFN(2,("uaudio_add_output: bTerminalId=%d wTerminalType=0x%04x "
1004                     "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n",
1005                     d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
1006                     d->bSourceId, d->iTerminal));
1007 #endif
1008 }
1009
1010 static void
1011 uaudio_add_mixer(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1012 {
1013         const struct usb_audio_mixer_unit *d = iot[id].d.mu;
1014         const struct usb_audio_mixer_unit_1 *d1;
1015         int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k;
1016         const uByte *bm;
1017         struct mixerctl mix;
1018
1019         DPRINTFN(2,("uaudio_add_mixer: bUnitId=%d bNrInPins=%d\n",
1020                     d->bUnitId, d->bNrInPins));
1021
1022         /* Compute the number of input channels */
1023         ichs = 0;
1024         for (i = 0; i < d->bNrInPins; i++)
1025                 ichs += uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels;
1026
1027         /* and the number of output channels */
1028         d1 = (const struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins];
1029         ochs = d1->bNrChannels;
1030         DPRINTFN(2,("uaudio_add_mixer: ichs=%d ochs=%d\n", ichs, ochs));
1031
1032         bm = d1->bmControls;
1033         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1034         uaudio_determine_class(&iot[id], &mix);
1035         mix.type = MIX_SIGNED_16;
1036 #if !defined(__FreeBSD__)       /* XXXXX */
1037         mix.ctlunit = AudioNvolume;
1038 #endif
1039
1040 #define BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1)
1041         for (p = i = 0; i < d->bNrInPins; i++) {
1042                 chs = uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels;
1043                 mc = 0;
1044                 for (c = 0; c < chs; c++) {
1045                         mo = 0;
1046                         for (o = 0; o < ochs; o++) {
1047                                 bno = (p + c) * ochs + o;
1048                                 if (BIT(bno))
1049                                         mo++;
1050                         }
1051                         if (mo == 1)
1052                                 mc++;
1053                 }
1054                 if (mc == chs && chs <= MIX_MAX_CHAN) {
1055                         k = 0;
1056                         for (c = 0; c < chs; c++)
1057                                 for (o = 0; o < ochs; o++) {
1058                                         bno = (p + c) * ochs + o;
1059                                         if (BIT(bno))
1060                                                 mix.wValue[k++] =
1061                                                         MAKE(p+c+1, o+1);
1062                                 }
1063 #if !defined(__FreeBSD__)
1064                         snprintf(mix.ctlname, sizeof(mix.ctlname), "mix%d-%s",
1065                             d->bUnitId, uaudio_id_name(sc, iot,
1066                             d->baSourceId[i]));
1067 #endif
1068                         mix.nchan = chs;
1069                         uaudio_mixer_add_ctl(sc, &mix);
1070                 } else {
1071                         /* XXX */
1072                 }
1073 #undef BIT
1074                 p += chs;
1075         }
1076
1077 }
1078
1079 static void
1080 uaudio_add_selector(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1081 {
1082         const struct usb_audio_selector_unit *d;
1083         struct mixerctl mix;
1084 #if !defined(__FreeBSD__)
1085         int i, wp;
1086 #else
1087         int i;
1088         struct mixerctl dummy;
1089 #endif
1090
1091         d = iot[id].d.su;
1092         DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n",
1093                     d->bUnitId, d->bNrInPins));
1094         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1095         mix.wValue[0] = MAKE(0, 0);
1096         uaudio_determine_class(&iot[id], &mix);
1097         mix.nchan = 1;
1098         mix.type = MIX_SELECTOR;
1099 #if defined(__FreeBSD__)
1100         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1101         mix.minval = 1;
1102         mix.maxval = d->bNrInPins;
1103         mix.mul = mix.maxval - mix.minval;
1104         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
1105                 mix.slctrtype[i] = SOUND_MIXER_NRDEVICES;
1106         }
1107         for (i = mix.minval; i <= mix.maxval; i++) {
1108                 mix.slctrtype[i - 1] = uaudio_feature_name(&iot[d->baSourceId[i - 1]], &dummy);
1109         }
1110 #else
1111         mix.ctlunit = "";
1112         mix.minval = 1;
1113         mix.maxval = d->bNrInPins;
1114         mix.mul = mix.maxval - mix.minval;
1115         wp = snprintf(mix.ctlname, MAX_AUDIO_DEV_LEN, "sel%d-", d->bUnitId);
1116         for (i = 1; i <= d->bNrInPins; i++) {
1117                 wp += snprintf(mix.ctlname + wp, MAX_AUDIO_DEV_LEN - wp,
1118                                "i%d", d->baSourceId[i - 1]);
1119                 if (wp > MAX_AUDIO_DEV_LEN - 1)
1120                         break;
1121         }
1122 #endif
1123         uaudio_mixer_add_ctl(sc, &mix);
1124 }
1125
1126 #ifdef USB_DEBUG
1127 static const char *
1128 uaudio_get_terminal_name(int terminal_type)
1129 {
1130         static char buf[100];
1131
1132         switch (terminal_type) {
1133         /* USB terminal types */
1134         case UAT_UNDEFINED:     return "UAT_UNDEFINED";
1135         case UAT_STREAM:        return "UAT_STREAM";
1136         case UAT_VENDOR:        return "UAT_VENDOR";
1137         /* input terminal types */
1138         case UATI_UNDEFINED:    return "UATI_UNDEFINED";
1139         case UATI_MICROPHONE:   return "UATI_MICROPHONE";
1140         case UATI_DESKMICROPHONE:       return "UATI_DESKMICROPHONE";
1141         case UATI_PERSONALMICROPHONE:   return "UATI_PERSONALMICROPHONE";
1142         case UATI_OMNIMICROPHONE:       return "UATI_OMNIMICROPHONE";
1143         case UATI_MICROPHONEARRAY:      return "UATI_MICROPHONEARRAY";
1144         case UATI_PROCMICROPHONEARR:    return "UATI_PROCMICROPHONEARR";
1145         /* output terminal types */
1146         case UATO_UNDEFINED:    return "UATO_UNDEFINED";
1147         case UATO_SPEAKER:      return "UATO_SPEAKER";
1148         case UATO_HEADPHONES:   return "UATO_HEADPHONES";
1149         case UATO_DISPLAYAUDIO: return "UATO_DISPLAYAUDIO";
1150         case UATO_DESKTOPSPEAKER:       return "UATO_DESKTOPSPEAKER";
1151         case UATO_ROOMSPEAKER:  return "UATO_ROOMSPEAKER";
1152         case UATO_COMMSPEAKER:  return "UATO_COMMSPEAKER";
1153         case UATO_SUBWOOFER:    return "UATO_SUBWOOFER";
1154         /* bidir terminal types */
1155         case UATB_UNDEFINED:    return "UATB_UNDEFINED";
1156         case UATB_HANDSET:      return "UATB_HANDSET";
1157         case UATB_HEADSET:      return "UATB_HEADSET";
1158         case UATB_SPEAKERPHONE: return "UATB_SPEAKERPHONE";
1159         case UATB_SPEAKERPHONEESUP:     return "UATB_SPEAKERPHONEESUP";
1160         case UATB_SPEAKERPHONEECANC:    return "UATB_SPEAKERPHONEECANC";
1161         /* telephony terminal types */
1162         case UATT_UNDEFINED:    return "UATT_UNDEFINED";
1163         case UATT_PHONELINE:    return "UATT_PHONELINE";
1164         case UATT_TELEPHONE:    return "UATT_TELEPHONE";
1165         case UATT_DOWNLINEPHONE:        return "UATT_DOWNLINEPHONE";
1166         /* external terminal types */
1167         case UATE_UNDEFINED:    return "UATE_UNDEFINED";
1168         case UATE_ANALOGCONN:   return "UATE_ANALOGCONN";
1169         case UATE_LINECONN:     return "UATE_LINECONN";
1170         case UATE_LEGACYCONN:   return "UATE_LEGACYCONN";
1171         case UATE_DIGITALAUIFC: return "UATE_DIGITALAUIFC";
1172         case UATE_SPDIF:        return "UATE_SPDIF";
1173         case UATE_1394DA:       return "UATE_1394DA";
1174         case UATE_1394DV:       return "UATE_1394DV";
1175         /* embedded function terminal types */
1176         case UATF_UNDEFINED:    return "UATF_UNDEFINED";
1177         case UATF_CALIBNOISE:   return "UATF_CALIBNOISE";
1178         case UATF_EQUNOISE:     return "UATF_EQUNOISE";
1179         case UATF_CDPLAYER:     return "UATF_CDPLAYER";
1180         case UATF_DAT:  return "UATF_DAT";
1181         case UATF_DCC:  return "UATF_DCC";
1182         case UATF_MINIDISK:     return "UATF_MINIDISK";
1183         case UATF_ANALOGTAPE:   return "UATF_ANALOGTAPE";
1184         case UATF_PHONOGRAPH:   return "UATF_PHONOGRAPH";
1185         case UATF_VCRAUDIO:     return "UATF_VCRAUDIO";
1186         case UATF_VIDEODISCAUDIO:       return "UATF_VIDEODISCAUDIO";
1187         case UATF_DVDAUDIO:     return "UATF_DVDAUDIO";
1188         case UATF_TVTUNERAUDIO: return "UATF_TVTUNERAUDIO";
1189         case UATF_SATELLITE:    return "UATF_SATELLITE";
1190         case UATF_CABLETUNER:   return "UATF_CABLETUNER";
1191         case UATF_DSS:  return "UATF_DSS";
1192         case UATF_RADIORECV:    return "UATF_RADIORECV";
1193         case UATF_RADIOXMIT:    return "UATF_RADIOXMIT";
1194         case UATF_MULTITRACK:   return "UATF_MULTITRACK";
1195         case UATF_SYNTHESIZER:  return "UATF_SYNTHESIZER";
1196         default:
1197                 snprintf(buf, sizeof(buf), "unknown type (0x%.4x)", terminal_type);
1198                 return buf;
1199         }
1200 }
1201 #endif
1202
1203 static int
1204 uaudio_determine_class(const struct io_terminal *iot, struct mixerctl *mix)
1205 {
1206         int terminal_type;
1207
1208         if (iot == NULL || iot->output == NULL) {
1209                 mix->class = UAC_OUTPUT;
1210                 return 0;
1211         }
1212         terminal_type = 0;
1213         if (iot->output->size == 1)
1214                 terminal_type = iot->output->terminals[0];
1215         /*
1216          * If the only output terminal is USB,
1217          * the class is UAC_RECORD.
1218          */
1219         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
1220                 mix->class = UAC_RECORD;
1221                 if (iot->inputs_size == 1
1222                     && iot->inputs[0] != NULL
1223                     && iot->inputs[0]->size == 1)
1224                         return iot->inputs[0]->terminals[0];
1225                 else
1226                         return 0;
1227         }
1228         /*
1229          * If the ultimate destination of the unit is just one output
1230          * terminal and the unit is connected to the output terminal
1231          * directly, the class is UAC_OUTPUT.
1232          */
1233         if (terminal_type != 0 && iot->direct) {
1234                 mix->class = UAC_OUTPUT;
1235                 return terminal_type;
1236         }
1237         /*
1238          * If the unit is connected to just one input terminal,
1239          * the class is UAC_INPUT.
1240          */
1241         if (iot->inputs_size == 1 && iot->inputs[0] != NULL
1242             && iot->inputs[0]->size == 1) {
1243                 mix->class = UAC_INPUT;
1244                 return iot->inputs[0]->terminals[0];
1245         }
1246         /*
1247          * Otherwise, the class is UAC_OUTPUT.
1248          */
1249         mix->class = UAC_OUTPUT;
1250         return terminal_type;
1251 }
1252
1253 #if defined(__FreeBSD__)
1254 static int
1255 uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
1256 {
1257         int terminal_type;
1258
1259         terminal_type = uaudio_determine_class(iot, mix);
1260         if (mix->class == UAC_RECORD && terminal_type == 0)
1261                 return SOUND_MIXER_IMIX;
1262         DPRINTF(("%s: terminal_type=%s\n", __func__,
1263                  uaudio_get_terminal_name(terminal_type)));
1264         switch (terminal_type) {
1265         case UAT_STREAM:
1266                 return SOUND_MIXER_PCM;
1267
1268         case UATI_MICROPHONE:
1269         case UATI_DESKMICROPHONE:
1270         case UATI_PERSONALMICROPHONE:
1271         case UATI_OMNIMICROPHONE:
1272         case UATI_MICROPHONEARRAY:
1273         case UATI_PROCMICROPHONEARR:
1274                 return SOUND_MIXER_MIC;
1275
1276         case UATO_SPEAKER:
1277         case UATO_DESKTOPSPEAKER:
1278         case UATO_ROOMSPEAKER:
1279         case UATO_COMMSPEAKER:
1280                 return SOUND_MIXER_SPEAKER;
1281
1282         case UATE_ANALOGCONN:
1283         case UATE_LINECONN:
1284         case UATE_LEGACYCONN:
1285                 return SOUND_MIXER_LINE;
1286
1287         case UATE_DIGITALAUIFC:
1288         case UATE_SPDIF:
1289         case UATE_1394DA:
1290         case UATE_1394DV:
1291                 return SOUND_MIXER_ALTPCM;
1292
1293         case UATF_CDPLAYER:
1294                 return SOUND_MIXER_CD;
1295
1296         case UATF_SYNTHESIZER:
1297                 return SOUND_MIXER_SYNTH;
1298
1299         case UATF_VIDEODISCAUDIO:
1300         case UATF_DVDAUDIO:
1301         case UATF_TVTUNERAUDIO:
1302                 return SOUND_MIXER_VIDEO;
1303
1304 /* telephony terminal types */
1305         case UATT_UNDEFINED:
1306         case UATT_PHONELINE:
1307         case UATT_TELEPHONE:
1308         case UATT_DOWNLINEPHONE:
1309                 return SOUND_MIXER_PHONEIN;
1310 /*              return SOUND_MIXER_PHONEOUT;*/
1311
1312         case UATF_RADIORECV:
1313         case UATF_RADIOXMIT:
1314                 return SOUND_MIXER_RADIO;
1315
1316         case UAT_UNDEFINED:
1317         case UAT_VENDOR:
1318         case UATI_UNDEFINED:
1319 /* output terminal types */
1320         case UATO_UNDEFINED:
1321         case UATO_DISPLAYAUDIO:
1322         case UATO_SUBWOOFER:
1323         case UATO_HEADPHONES:
1324 /* bidir terminal types */
1325         case UATB_UNDEFINED:
1326         case UATB_HANDSET:
1327         case UATB_HEADSET:
1328         case UATB_SPEAKERPHONE:
1329         case UATB_SPEAKERPHONEESUP:
1330         case UATB_SPEAKERPHONEECANC:
1331 /* external terminal types */
1332         case UATE_UNDEFINED:
1333 /* embedded function terminal types */
1334         case UATF_UNDEFINED:
1335         case UATF_CALIBNOISE:
1336         case UATF_EQUNOISE:
1337         case UATF_DAT:
1338         case UATF_DCC:
1339         case UATF_MINIDISK:
1340         case UATF_ANALOGTAPE:
1341         case UATF_PHONOGRAPH:
1342         case UATF_VCRAUDIO:
1343         case UATF_SATELLITE:
1344         case UATF_CABLETUNER:
1345         case UATF_DSS:
1346         case UATF_MULTITRACK:
1347         case 0xffff:
1348         default:
1349                 DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type));
1350                 return SOUND_MIXER_VOLUME;
1351         }
1352         return SOUND_MIXER_VOLUME;
1353 }
1354 #else
1355 static const char *
1356 uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
1357 {
1358         int terminal_type;
1359
1360         terminal_type = uaudio_determine_class(iot, mix);
1361         if (mix->class == UAC_RECORD && terminal_type == 0)
1362                 return AudioNmixerout;
1363         DPRINTF(("%s: terminal_type=%s\n", __func__,
1364                  uaudio_get_terminal_name(terminal_type)));
1365         switch (terminal_type) {
1366         case UAT_STREAM:
1367                 return AudioNdac;
1368
1369         case UATI_MICROPHONE:
1370         case UATI_DESKMICROPHONE:
1371         case UATI_PERSONALMICROPHONE:
1372         case UATI_OMNIMICROPHONE:
1373         case UATI_MICROPHONEARRAY:
1374         case UATI_PROCMICROPHONEARR:
1375                 return AudioNmicrophone;
1376
1377         case UATO_SPEAKER:
1378         case UATO_DESKTOPSPEAKER:
1379         case UATO_ROOMSPEAKER:
1380         case UATO_COMMSPEAKER:
1381                 return AudioNspeaker;
1382
1383         case UATO_HEADPHONES:
1384                 return AudioNheadphone;
1385
1386         case UATO_SUBWOOFER:
1387                 return AudioNlfe;
1388
1389         /* telephony terminal types */
1390         case UATT_UNDEFINED:
1391         case UATT_PHONELINE:
1392         case UATT_TELEPHONE:
1393         case UATT_DOWNLINEPHONE:
1394                 return "phone";
1395
1396         case UATE_ANALOGCONN:
1397         case UATE_LINECONN:
1398         case UATE_LEGACYCONN:
1399                 return AudioNline;
1400
1401         case UATE_DIGITALAUIFC:
1402         case UATE_SPDIF:
1403         case UATE_1394DA:
1404         case UATE_1394DV:
1405                 return AudioNaux;
1406
1407         case UATF_CDPLAYER:
1408                 return AudioNcd;
1409
1410         case UATF_SYNTHESIZER:
1411                 return AudioNfmsynth;
1412
1413         case UATF_VIDEODISCAUDIO:
1414         case UATF_DVDAUDIO:
1415         case UATF_TVTUNERAUDIO:
1416                 return AudioNvideo;
1417
1418         case UAT_UNDEFINED:
1419         case UAT_VENDOR:
1420         case UATI_UNDEFINED:
1421 /* output terminal types */
1422         case UATO_UNDEFINED:
1423         case UATO_DISPLAYAUDIO:
1424 /* bidir terminal types */
1425         case UATB_UNDEFINED:
1426         case UATB_HANDSET:
1427         case UATB_HEADSET:
1428         case UATB_SPEAKERPHONE:
1429         case UATB_SPEAKERPHONEESUP:
1430         case UATB_SPEAKERPHONEECANC:
1431 /* external terminal types */
1432         case UATE_UNDEFINED:
1433 /* embedded function terminal types */
1434         case UATF_UNDEFINED:
1435         case UATF_CALIBNOISE:
1436         case UATF_EQUNOISE:
1437         case UATF_DAT:
1438         case UATF_DCC:
1439         case UATF_MINIDISK:
1440         case UATF_ANALOGTAPE:
1441         case UATF_PHONOGRAPH:
1442         case UATF_VCRAUDIO:
1443         case UATF_SATELLITE:
1444         case UATF_CABLETUNER:
1445         case UATF_DSS:
1446         case UATF_RADIORECV:
1447         case UATF_RADIOXMIT:
1448         case UATF_MULTITRACK:
1449         case 0xffff:
1450         default:
1451                 DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type));
1452                 return AudioNmaster;
1453         }
1454         return AudioNmaster;
1455 }
1456 #endif
1457
1458 static void
1459 uaudio_add_feature(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1460 {
1461         const struct usb_audio_feature_unit *d;
1462         const uByte *ctls;
1463         int ctlsize;
1464         int nchan;
1465         u_int fumask, mmask, cmask;
1466         struct mixerctl mix;
1467         int chan, ctl, i, unit;
1468 #if defined(__FreeBSD__)
1469         int mixernumber;
1470 #else
1471         const char *mixername;
1472 #endif
1473
1474 #define GET(i) (ctls[(i)*ctlsize] | \
1475                 (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0))
1476         d = iot[id].d.fu;
1477         ctls = d->bmaControls;
1478         ctlsize = d->bControlSize;
1479         nchan = (d->bLength - 7) / ctlsize;
1480         mmask = GET(0);
1481         /* Figure out what we can control */
1482         for (cmask = 0, chan = 1; chan < nchan; chan++) {
1483                 DPRINTFN(9,("uaudio_add_feature: chan=%d mask=%x\n",
1484                             chan, GET(chan)));
1485                 cmask |= GET(chan);
1486         }
1487
1488 #if !defined(__FreeBSD__)
1489         DPRINTFN(1,("uaudio_add_feature: bUnitId=%d, "
1490                     "%d channels, mmask=0x%04x, cmask=0x%04x\n",
1491                     d->bUnitId, nchan, mmask, cmask));
1492 #endif
1493
1494         if (nchan > MIX_MAX_CHAN)
1495                 nchan = MIX_MAX_CHAN;
1496         unit = d->bUnitId;
1497         mix.wIndex = MAKE(unit, sc->sc_ac_iface);
1498         for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) {
1499                 fumask = FU_MASK(ctl);
1500                 DPRINTFN(4,("uaudio_add_feature: ctl=%d fumask=0x%04x\n",
1501                             ctl, fumask));
1502                 if (mmask & fumask) {
1503                         mix.nchan = 1;
1504                         mix.wValue[0] = MAKE(ctl, 0);
1505                 } else if (cmask & fumask) {
1506                         mix.nchan = nchan - 1;
1507                         for (i = 1; i < nchan; i++) {
1508                                 if (GET(i) & fumask)
1509                                         mix.wValue[i-1] = MAKE(ctl, i);
1510                                 else
1511                                         mix.wValue[i-1] = -1;
1512                         }
1513                 } else {
1514                         continue;
1515                 }
1516 #undef GET
1517
1518 #if defined(__FreeBSD__)
1519                 mixernumber = uaudio_feature_name(&iot[id], &mix);
1520 #else
1521                 mixername = uaudio_feature_name(&iot[id], &mix);
1522 #endif
1523                 switch (ctl) {
1524                 case MUTE_CONTROL:
1525                         mix.type = MIX_ON_OFF;
1526 #if defined(__FreeBSD__)
1527                         mix.ctl = SOUND_MIXER_NRDEVICES;
1528 #else
1529                         mix.ctlunit = "";
1530                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1531                                  "%s.%s", mixername, AudioNmute);
1532 #endif
1533                         break;
1534                 case VOLUME_CONTROL:
1535                         mix.type = MIX_SIGNED_16;
1536 #if defined(__FreeBSD__)
1537                         mix.ctl = mixernumber;
1538 #else
1539                         mix.ctlunit = AudioNvolume;
1540                         strlcpy(mix.ctlname, mixername, sizeof(mix.ctlname));
1541 #endif
1542                         break;
1543                 case BASS_CONTROL:
1544                         mix.type = MIX_SIGNED_8;
1545 #if defined(__FreeBSD__)
1546                         mix.ctl = SOUND_MIXER_BASS;
1547 #else
1548                         mix.ctlunit = AudioNbass;
1549                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1550                                  "%s.%s", mixername, AudioNbass);
1551 #endif
1552                         break;
1553                 case MID_CONTROL:
1554                         mix.type = MIX_SIGNED_8;
1555 #if defined(__FreeBSD__)
1556                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1557 #else
1558                         mix.ctlunit = AudioNmid;
1559                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1560                                  "%s.%s", mixername, AudioNmid);
1561 #endif
1562                         break;
1563                 case TREBLE_CONTROL:
1564                         mix.type = MIX_SIGNED_8;
1565 #if defined(__FreeBSD__)
1566                         mix.ctl = SOUND_MIXER_TREBLE;
1567 #else
1568                         mix.ctlunit = AudioNtreble;
1569                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1570                                  "%s.%s", mixername, AudioNtreble);
1571 #endif
1572                         break;
1573                 case GRAPHIC_EQUALIZER_CONTROL:
1574                         continue; /* XXX don't add anything */
1575                         break;
1576                 case AGC_CONTROL:
1577                         mix.type = MIX_ON_OFF;
1578 #if defined(__FreeBSD__)
1579                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1580 #else
1581                         mix.ctlunit = "";
1582                         snprintf(mix.ctlname, sizeof(mix.ctlname), "%s.%s",
1583                                  mixername, AudioNagc);
1584 #endif
1585                         break;
1586                 case DELAY_CONTROL:
1587                         mix.type = MIX_UNSIGNED_16;
1588 #if defined(__FreeBSD__)
1589                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1590 #else
1591                         mix.ctlunit = "4 ms";
1592                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1593                                  "%s.%s", mixername, AudioNdelay);
1594 #endif
1595                         break;
1596                 case BASS_BOOST_CONTROL:
1597                         mix.type = MIX_ON_OFF;
1598 #if defined(__FreeBSD__)
1599                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1600 #else
1601                         mix.ctlunit = "";
1602                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1603                                  "%s.%s", mixername, AudioNbassboost);
1604 #endif
1605                         break;
1606                 case LOUDNESS_CONTROL:
1607                         mix.type = MIX_ON_OFF;
1608 #if defined(__FreeBSD__)
1609                         mix.ctl = SOUND_MIXER_LOUD;     /* Is this correct ? */
1610 #else
1611                         mix.ctlunit = "";
1612                         snprintf(mix.ctlname, sizeof(mix.ctlname),
1613                                  "%s.%s", mixername, AudioNloudness);
1614 #endif
1615                         break;
1616                 }
1617                 uaudio_mixer_add_ctl(sc, &mix);
1618         }
1619 }
1620
1621 static void
1622 uaudio_add_processing_updown(struct uaudio_softc *sc,
1623                              const struct io_terminal *iot, int id)
1624 {
1625         const struct usb_audio_processing_unit *d;
1626         const struct usb_audio_processing_unit_1 *d1;
1627         const struct usb_audio_processing_unit_updown *ud;
1628         struct mixerctl mix;
1629         int i;
1630
1631         d = iot[id].d.pu;
1632         d1 = (const struct usb_audio_processing_unit_1 *)
1633                 &d->baSourceId[d->bNrInPins];
1634         ud = (const struct usb_audio_processing_unit_updown *)
1635                 &d1->bmControls[d1->bControlSize];
1636         DPRINTFN(2,("uaudio_add_processing_updown: bUnitId=%d bNrModes=%d\n",
1637                     d->bUnitId, ud->bNrModes));
1638
1639         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
1640                 DPRINTF(("uaudio_add_processing_updown: no mode select\n"));
1641                 return;
1642         }
1643
1644         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1645         mix.nchan = 1;
1646         mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0);
1647         uaudio_determine_class(&iot[id], &mix);
1648         mix.type = MIX_ON_OFF;  /* XXX */
1649 #if !defined(__FreeBSD__)
1650         mix.ctlunit = "";
1651         snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d-mode", d->bUnitId);
1652 #endif
1653
1654         for (i = 0; i < ud->bNrModes; i++) {
1655                 DPRINTFN(2,("uaudio_add_processing_updown: i=%d bm=0x%x\n",
1656                             i, UGETW(ud->waModes[i])));
1657                 /* XXX */
1658         }
1659         uaudio_mixer_add_ctl(sc, &mix);
1660 }
1661
1662 static void
1663 uaudio_add_processing(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1664 {
1665         const struct usb_audio_processing_unit *d;
1666         const struct usb_audio_processing_unit_1 *d1;
1667         int ptype;
1668         struct mixerctl mix;
1669
1670         d = iot[id].d.pu;
1671         d1 = (const struct usb_audio_processing_unit_1 *)
1672                 &d->baSourceId[d->bNrInPins];
1673         ptype = UGETW(d->wProcessType);
1674         DPRINTFN(2,("uaudio_add_processing: wProcessType=%d bUnitId=%d "
1675                     "bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins));
1676
1677         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
1678                 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1679                 mix.nchan = 1;
1680                 mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0);
1681                 uaudio_determine_class(&iot[id], &mix);
1682                 mix.type = MIX_ON_OFF;
1683 #if !defined(__FreeBSD__)
1684                 mix.ctlunit = "";
1685                 snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d.%d-enable",
1686                     d->bUnitId, ptype);
1687 #endif
1688                 uaudio_mixer_add_ctl(sc, &mix);
1689         }
1690
1691         switch(ptype) {
1692         case UPDOWNMIX_PROCESS:
1693                 uaudio_add_processing_updown(sc, iot, id);
1694                 break;
1695         case DOLBY_PROLOGIC_PROCESS:
1696         case P3D_STEREO_EXTENDER_PROCESS:
1697         case REVERBATION_PROCESS:
1698         case CHORUS_PROCESS:
1699         case DYN_RANGE_COMP_PROCESS:
1700         default:
1701 #ifdef USB_DEBUG
1702                 printf("uaudio_add_processing: unit %d, type=%d not impl.\n",
1703                        d->bUnitId, ptype);
1704 #endif
1705                 break;
1706         }
1707 }
1708
1709 static void
1710 uaudio_add_extension(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1711 {
1712         const struct usb_audio_extension_unit *d;
1713         const struct usb_audio_extension_unit_1 *d1;
1714         struct mixerctl mix;
1715
1716         d = iot[id].d.eu;
1717         d1 = (const struct usb_audio_extension_unit_1 *)
1718                 &d->baSourceId[d->bNrInPins];
1719         DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n",
1720                     d->bUnitId, d->bNrInPins));
1721
1722         if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_XU)
1723                 return;
1724
1725         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
1726                 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1727                 mix.nchan = 1;
1728                 mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0);
1729                 uaudio_determine_class(&iot[id], &mix);
1730                 mix.type = MIX_ON_OFF;
1731 #if !defined(__FreeBSD__)
1732                 mix.ctlunit = "";
1733                 snprintf(mix.ctlname, sizeof(mix.ctlname), "ext%d-enable",
1734                     d->bUnitId);
1735 #endif
1736                 uaudio_mixer_add_ctl(sc, &mix);
1737         }
1738 }
1739
1740 static struct terminal_list*
1741 uaudio_merge_terminal_list(const struct io_terminal *iot)
1742 {
1743         struct terminal_list *tml;
1744         uint16_t *ptm;
1745         int i, len;
1746
1747         len = 0;
1748         if (iot->inputs == NULL)
1749                 return NULL;
1750         for (i = 0; i < iot->inputs_size; i++) {
1751                 if (iot->inputs[i] != NULL)
1752                         len += iot->inputs[i]->size;
1753         }
1754         tml = malloc(TERMINAL_LIST_SIZE(len), M_TEMP, M_NOWAIT);
1755         if (tml == NULL) {
1756                 printf("uaudio_merge_terminal_list: no memory\n");
1757                 return NULL;
1758         }
1759         tml->size = 0;
1760         ptm = tml->terminals;
1761         for (i = 0; i < iot->inputs_size; i++) {
1762                 if (iot->inputs[i] == NULL)
1763                         continue;
1764                 if (iot->inputs[i]->size > len)
1765                         break;
1766                 memcpy(ptm, iot->inputs[i]->terminals,
1767                        iot->inputs[i]->size * sizeof(uint16_t));
1768                 tml->size += iot->inputs[i]->size;
1769                 ptm += iot->inputs[i]->size;
1770                 len -= iot->inputs[i]->size;
1771         }
1772         return tml;
1773 }
1774
1775 static struct terminal_list *
1776 uaudio_io_terminaltype(int outtype, struct io_terminal *iot, int id)
1777 {
1778         struct terminal_list *tml;
1779         struct io_terminal *it;
1780         int src_id, i;
1781
1782         it = &iot[id];
1783         if (it->output != NULL) {
1784                 /* already has outtype? */
1785                 for (i = 0; i < it->output->size; i++)
1786                         if (it->output->terminals[i] == outtype)
1787                                 return uaudio_merge_terminal_list(it);
1788                 tml = malloc(TERMINAL_LIST_SIZE(it->output->size + 1),
1789                              M_TEMP, M_NOWAIT);
1790                 if (tml == NULL) {
1791                         printf("uaudio_io_terminaltype: no memory\n");
1792                         return uaudio_merge_terminal_list(it);
1793                 }
1794                 memcpy(tml, it->output, TERMINAL_LIST_SIZE(it->output->size));
1795                 tml->terminals[it->output->size] = outtype;
1796                 tml->size++;
1797                 free(it->output, M_TEMP);
1798                 it->output = tml;
1799                 if (it->inputs != NULL) {
1800                         for (i = 0; i < it->inputs_size; i++)
1801                                 if (it->inputs[i] != NULL)
1802                                         free(it->inputs[i], M_TEMP);
1803                         free(it->inputs, M_TEMP);
1804                 }
1805                 it->inputs_size = 0;
1806                 it->inputs = NULL;
1807         } else {                /* end `iot[id] != NULL' */
1808                 it->inputs_size = 0;
1809                 it->inputs = NULL;
1810                 it->output = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
1811                 if (it->output == NULL) {
1812                         printf("uaudio_io_terminaltype: no memory\n");
1813                         return NULL;
1814                 }
1815                 it->output->terminals[0] = outtype;
1816                 it->output->size = 1;
1817                 it->direct = FALSE;
1818         }
1819
1820         switch (it->d.desc->bDescriptorSubtype) {
1821         case UDESCSUB_AC_INPUT:
1822                 it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1823                 if (it->inputs == NULL) {
1824                         printf("uaudio_io_terminaltype: no memory\n");
1825                         return NULL;
1826                 }
1827                 tml = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
1828                 if (tml == NULL) {
1829                         printf("uaudio_io_terminaltype: no memory\n");
1830                         free(it->inputs, M_TEMP);
1831                         it->inputs = NULL;
1832                         return NULL;
1833                 }
1834                 it->inputs[0] = tml;
1835                 tml->terminals[0] = UGETW(it->d.it->wTerminalType);
1836                 tml->size = 1;
1837                 it->inputs_size = 1;
1838                 return uaudio_merge_terminal_list(it);
1839         case UDESCSUB_AC_FEATURE:
1840                 src_id = it->d.fu->bSourceId;
1841                 it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1842                 if (it->inputs == NULL) {
1843                         printf("uaudio_io_terminaltype: no memory\n");
1844                         return uaudio_io_terminaltype(outtype, iot, src_id);
1845                 }
1846                 it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
1847                 it->inputs_size = 1;
1848                 return uaudio_merge_terminal_list(it);
1849         case UDESCSUB_AC_OUTPUT:
1850                 it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1851                 if (it->inputs == NULL) {
1852                         printf("uaudio_io_terminaltype: no memory\n");
1853                         return NULL;
1854                 }
1855                 src_id = it->d.ot->bSourceId;
1856                 it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
1857                 it->inputs_size = 1;
1858                 iot[src_id].direct = TRUE;
1859                 return NULL;
1860         case UDESCSUB_AC_MIXER:
1861                 it->inputs_size = 0;
1862                 it->inputs = malloc(sizeof(struct terminal_list *)
1863                                     * it->d.mu->bNrInPins, M_TEMP, M_NOWAIT);
1864                 if (it->inputs == NULL) {
1865                         printf("uaudio_io_terminaltype: no memory\n");
1866                         return NULL;
1867                 }
1868                 for (i = 0; i < it->d.mu->bNrInPins; i++) {
1869                         src_id = it->d.mu->baSourceId[i];
1870                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1871                                                                src_id);
1872                         it->inputs_size++;
1873                 }
1874                 return uaudio_merge_terminal_list(it);
1875         case UDESCSUB_AC_SELECTOR:
1876                 it->inputs_size = 0;
1877                 it->inputs = malloc(sizeof(struct terminal_list *)
1878                                     * it->d.su->bNrInPins, M_TEMP, M_NOWAIT);
1879                 if (it->inputs == NULL) {
1880                         printf("uaudio_io_terminaltype: no memory\n");
1881                         return NULL;
1882                 }
1883                 for (i = 0; i < it->d.su->bNrInPins; i++) {
1884                         src_id = it->d.su->baSourceId[i];
1885                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1886                                                                src_id);
1887                         it->inputs_size++;
1888                 }
1889                 return uaudio_merge_terminal_list(it);
1890         case UDESCSUB_AC_PROCESSING:
1891                 it->inputs_size = 0;
1892                 it->inputs = malloc(sizeof(struct terminal_list *)
1893                                     * it->d.pu->bNrInPins, M_TEMP, M_NOWAIT);
1894                 if (it->inputs == NULL) {
1895                         printf("uaudio_io_terminaltype: no memory\n");
1896                         return NULL;
1897                 }
1898                 for (i = 0; i < it->d.pu->bNrInPins; i++) {
1899                         src_id = it->d.pu->baSourceId[i];
1900                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1901                                                                src_id);
1902                         it->inputs_size++;
1903                 }
1904                 return uaudio_merge_terminal_list(it);
1905         case UDESCSUB_AC_EXTENSION:
1906                 it->inputs_size = 0;
1907                 it->inputs = malloc(sizeof(struct terminal_list *)
1908                                     * it->d.eu->bNrInPins, M_TEMP, M_NOWAIT);
1909                 if (it->inputs == NULL) {
1910                         printf("uaudio_io_terminaltype: no memory\n");
1911                         return NULL;
1912                 }
1913                 for (i = 0; i < it->d.eu->bNrInPins; i++) {
1914                         src_id = it->d.eu->baSourceId[i];
1915                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1916                                                                src_id);
1917                         it->inputs_size++;
1918                 }
1919                 return uaudio_merge_terminal_list(it);
1920         case UDESCSUB_AC_HEADER:
1921         default:
1922                 return NULL;
1923         }
1924 }
1925
1926 static usbd_status
1927 uaudio_identify(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
1928 {
1929         usbd_status err;
1930
1931         err = uaudio_identify_ac(sc, cdesc);
1932         if (err)
1933                 return err;
1934         return uaudio_identify_as(sc, cdesc);
1935 }
1936
1937 static void
1938 uaudio_add_alt(struct uaudio_softc *sc, const struct as_info *ai)
1939 {
1940         size_t len;
1941         struct as_info *nai;
1942
1943         len = sizeof(*ai) * (sc->sc_nalts + 1);
1944         nai = malloc(len, M_USBDEV, M_NOWAIT);
1945         if (nai == NULL) {
1946                 printf("uaudio_add_alt: no memory\n");
1947                 return;
1948         }
1949         /* Copy old data, if there was any */
1950         if (sc->sc_nalts != 0) {
1951                 memcpy(nai, sc->sc_alts, sizeof(*ai) * (sc->sc_nalts));
1952                 free(sc->sc_alts, M_USBDEV);
1953         }
1954         sc->sc_alts = nai;
1955         DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n",
1956                     ai->alt, ai->encoding));
1957         sc->sc_alts[sc->sc_nalts++] = *ai;
1958 }
1959
1960 static usbd_status
1961 uaudio_process_as(struct uaudio_softc *sc, const char *buf, int *offsp,
1962                   int size, const usb_interface_descriptor_t *id)
1963 #define offs (*offsp)
1964 {
1965         const struct usb_audio_streaming_interface_descriptor *asid;
1966         const struct usb_audio_streaming_type1_descriptor *asf1d;
1967         const usb_endpoint_descriptor_audio_t *ed;
1968         const usb_endpoint_descriptor_audio_t *epdesc1;
1969         const struct usb_audio_streaming_endpoint_descriptor *sed;
1970         int format, chan, prec, enc;
1971         int dir, type, sync;
1972         struct as_info ai;
1973         const char *format_str;
1974
1975         asid = (const void *)(buf + offs);
1976
1977         if (asid->bDescriptorType != UDESC_CS_INTERFACE ||
1978             asid->bDescriptorSubtype != AS_GENERAL)
1979                 return USBD_INVAL;
1980         DPRINTF(("uaudio_process_as: asid: bTerminakLink=%d wFormatTag=%d\n",
1981                  asid->bTerminalLink, UGETW(asid->wFormatTag)));
1982         offs += asid->bLength;
1983         if (offs > size)
1984                 return USBD_INVAL;
1985
1986         asf1d = (const void *)(buf + offs);
1987         if (asf1d->bDescriptorType != UDESC_CS_INTERFACE ||
1988             asf1d->bDescriptorSubtype != FORMAT_TYPE)
1989                 return USBD_INVAL;
1990         offs += asf1d->bLength;
1991         if (offs > size)
1992                 return USBD_INVAL;
1993
1994         if (asf1d->bFormatType != FORMAT_TYPE_I) {
1995                 printf("%s: ignored setting with type %d format\n",
1996                        device_get_nameunit(sc->sc_dev), UGETW(asid->wFormatTag));
1997                 return USBD_NORMAL_COMPLETION;
1998         }
1999
2000         ed = (const void *)(buf + offs);
2001         if (ed->bDescriptorType != UDESC_ENDPOINT)
2002                 return USBD_INVAL;
2003         DPRINTF(("uaudio_process_as: endpoint[0] bLength=%d bDescriptorType=%d "
2004                  "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d "
2005                  "bInterval=%d bRefresh=%d bSynchAddress=%d\n",
2006                  ed->bLength, ed->bDescriptorType, ed->bEndpointAddress,
2007                  ed->bmAttributes, UGETW(ed->wMaxPacketSize),
2008                  ed->bInterval, ed->bRefresh, ed->bSynchAddress));
2009         offs += ed->bLength;
2010         if (offs > size)
2011                 return USBD_INVAL;
2012         if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS)
2013                 return USBD_INVAL;
2014
2015         dir = UE_GET_DIR(ed->bEndpointAddress);
2016         type = UE_GET_ISO_TYPE(ed->bmAttributes);
2017         if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_INP_ASYNC) &&
2018             dir == UE_DIR_IN && type == UE_ISO_ADAPT)
2019                 type = UE_ISO_ASYNC;
2020
2021         /* We can't handle endpoints that need a sync pipe yet. */
2022         sync = FALSE;
2023         if (dir == UE_DIR_IN && type == UE_ISO_ADAPT) {
2024                 sync = TRUE;
2025 #ifndef UAUDIO_MULTIPLE_ENDPOINTS
2026                 printf("%s: ignored input endpoint of type adaptive\n",
2027                        device_get_nameunit(sc->sc_dev));
2028                 return USBD_NORMAL_COMPLETION;
2029 #endif
2030         }
2031         if (dir != UE_DIR_IN && type == UE_ISO_ASYNC) {
2032                 sync = TRUE;
2033 #ifndef UAUDIO_MULTIPLE_ENDPOINTS
2034                 printf("%s: ignored output endpoint of type async\n",
2035                        device_get_nameunit(sc->sc_dev));
2036                 return USBD_NORMAL_COMPLETION;
2037 #endif
2038         }
2039
2040         sed = (const void *)(buf + offs);
2041         if (sed->bDescriptorType != UDESC_CS_ENDPOINT ||
2042             sed->bDescriptorSubtype != AS_GENERAL)
2043                 return USBD_INVAL;
2044         DPRINTF((" streadming_endpoint: offset=%d bLength=%d\n", offs, sed->bLength));
2045         offs += sed->bLength;
2046         if (offs > size)
2047                 return USBD_INVAL;
2048
2049 #ifdef UAUDIO_MULTIPLE_ENDPOINTS
2050         if (sync && id->bNumEndpoints <= 1) {
2051                 printf("%s: a sync-pipe endpoint but no other endpoint\n",
2052                        device_get_nameunit(sc->sc_dev));
2053                 return USBD_INVAL;
2054         }
2055 #endif
2056         if (!sync && id->bNumEndpoints > 1) {
2057                 printf("%s: non sync-pipe endpoint but multiple endpoints\n",
2058                        device_get_nameunit(sc->sc_dev));
2059                 return USBD_INVAL;
2060         }
2061         epdesc1 = NULL;
2062         if (id->bNumEndpoints > 1) {
2063                 epdesc1 = (const void*)(buf + offs);
2064                 if (epdesc1->bDescriptorType != UDESC_ENDPOINT)
2065                         return USBD_INVAL;
2066                 DPRINTF(("uaudio_process_as: endpoint[1] bLength=%d "
2067                          "bDescriptorType=%d bEndpointAddress=%d "
2068                          "bmAttributes=0x%x wMaxPacketSize=%d bInterval=%d "
2069                          "bRefresh=%d bSynchAddress=%d\n",
2070                          epdesc1->bLength, epdesc1->bDescriptorType,
2071                          epdesc1->bEndpointAddress, epdesc1->bmAttributes,
2072                          UGETW(epdesc1->wMaxPacketSize), epdesc1->bInterval,
2073                          epdesc1->bRefresh, epdesc1->bSynchAddress));
2074                 offs += epdesc1->bLength;
2075                 if (offs > size)
2076                         return USBD_INVAL;
2077                 if (epdesc1->bSynchAddress != 0) {
2078                         printf("%s: invalid endpoint: bSynchAddress=0\n",
2079                                device_get_nameunit(sc->sc_dev));
2080                         return USBD_INVAL;
2081                 }
2082                 if (UE_GET_XFERTYPE(epdesc1->bmAttributes) != UE_ISOCHRONOUS) {
2083                         printf("%s: invalid endpoint: bmAttributes=0x%x\n",
2084                                device_get_nameunit(sc->sc_dev), epdesc1->bmAttributes);
2085                         return USBD_INVAL;
2086                 }
2087                 if (epdesc1->bEndpointAddress != ed->bSynchAddress) {
2088                         printf("%s: invalid endpoint addresses: "
2089                                "ep[0]->bSynchAddress=0x%x "
2090                                "ep[1]->bEndpointAddress=0x%x\n",
2091                                device_get_nameunit(sc->sc_dev), ed->bSynchAddress,
2092                                epdesc1->bEndpointAddress);
2093                         return USBD_INVAL;
2094                 }
2095                 /* UE_GET_ADDR(epdesc1->bEndpointAddress), and epdesc1->bRefresh */
2096         }
2097
2098         format = UGETW(asid->wFormatTag);
2099         chan = asf1d->bNrChannels;
2100         prec = asf1d->bBitResolution;
2101         if (prec != 8 && prec != 16 && prec != 24 && prec != 32) {
2102                 printf("%s: ignored setting with precision %d\n",
2103                        device_get_nameunit(sc->sc_dev), prec);
2104                 return USBD_NORMAL_COMPLETION;
2105         }
2106         switch (format) {
2107         case UA_FMT_PCM:
2108                 if (prec == 8) {
2109                         sc->sc_altflags |= HAS_8;
2110                 } else if (prec == 16) {
2111                         sc->sc_altflags |= HAS_16;
2112                 } else if (prec == 24) {
2113                         sc->sc_altflags |= HAS_24;
2114                 } else if (prec == 32) {
2115                         sc->sc_altflags |= HAS_32;
2116                 }
2117                 enc = AUDIO_ENCODING_SLINEAR_LE;
2118                 format_str = "pcm";
2119                 break;
2120         case UA_FMT_PCM8:
2121                 enc = AUDIO_ENCODING_ULINEAR_LE;
2122                 sc->sc_altflags |= HAS_8U;
2123                 format_str = "pcm8";
2124                 break;
2125         case UA_FMT_ALAW:
2126                 enc = AUDIO_ENCODING_ALAW;
2127                 sc->sc_altflags |= HAS_ALAW;
2128                 format_str = "alaw";
2129                 break;
2130         case UA_FMT_MULAW:
2131                 enc = AUDIO_ENCODING_ULAW;
2132                 sc->sc_altflags |= HAS_MULAW;
2133                 format_str = "mulaw";
2134                 break;
2135         case UA_FMT_IEEE_FLOAT:
2136         default:
2137                 printf("%s: ignored setting with format %d\n",
2138                        device_get_nameunit(sc->sc_dev), format);
2139                 return USBD_NORMAL_COMPLETION;
2140         }
2141 #ifdef USB_DEBUG
2142         printf("%s: %s: %dch, %d/%dbit, %s,", device_get_nameunit(sc->sc_dev),
2143                dir == UE_DIR_IN ? "recording" : "playback",
2144                chan, prec, asf1d->bSubFrameSize * 8, format_str);
2145         if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
2146                 printf(" %d-%dHz\n", UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
2147         } else {
2148                 int r;
2149                 printf(" %d", UA_GETSAMP(asf1d, 0));
2150                 for (r = 1; r < asf1d->bSamFreqType; r++)
2151                         printf(",%d", UA_GETSAMP(asf1d, r));
2152                 printf("Hz\n");
2153         }
2154 #endif
2155 #if defined(__FreeBSD__)
2156         if (sc->uaudio_sndstat_flag != 0) {
2157                 sbuf_printf(&(sc->uaudio_sndstat), "\n\t");
2158                 sbuf_printf(&(sc->uaudio_sndstat),
2159                     "mode %d:(%s) %dch, %d/%dbit, %s,",
2160                     id->bAlternateSetting,
2161                     dir == UE_DIR_IN ? "input" : "output",
2162                     chan, prec, asf1d->bSubFrameSize * 8, format_str);
2163                 if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
2164                         sbuf_printf(&(sc->uaudio_sndstat), " %d-%dHz",
2165                             UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
2166                 } else {
2167                         int r;
2168                         sbuf_printf(&(sc->uaudio_sndstat),
2169                             " %d", UA_GETSAMP(asf1d, 0));
2170                         for (r = 1; r < asf1d->bSamFreqType; r++)
2171                                 sbuf_printf(&(sc->uaudio_sndstat),
2172                                     ",%d", UA_GETSAMP(asf1d, r));
2173                         sbuf_printf(&(sc->uaudio_sndstat), "Hz");
2174                 }
2175         }
2176 #endif
2177         ai.alt = id->bAlternateSetting;
2178         ai.encoding = enc;
2179         ai.attributes = sed->bmAttributes;
2180         ai.idesc = id;
2181         ai.edesc = ed;
2182         ai.edesc1 = epdesc1;
2183         ai.asf1desc = asf1d;
2184         ai.sc_busy = 0;
2185         ai.ifaceh = NULL;
2186         uaudio_add_alt(sc, &ai);
2187 #ifdef USB_DEBUG
2188         if (ai.attributes & UA_SED_FREQ_CONTROL)
2189                 DPRINTFN(1, ("uaudio_process_as:  FREQ_CONTROL\n"));
2190         if (ai.attributes & UA_SED_PITCH_CONTROL)
2191                 DPRINTFN(1, ("uaudio_process_as:  PITCH_CONTROL\n"));
2192 #endif
2193         sc->sc_mode |= (dir == UE_DIR_OUT) ? AUMODE_PLAY : AUMODE_RECORD;
2194
2195         return USBD_NORMAL_COMPLETION;
2196 }
2197 #undef offs
2198
2199 static usbd_status
2200 uaudio_identify_as(struct uaudio_softc *sc,
2201                    const usb_config_descriptor_t *cdesc)
2202 {
2203         const usb_interface_descriptor_t *id;
2204         const char *buf;
2205         int size, offs;
2206
2207         size = UGETW(cdesc->wTotalLength);
2208         buf = (const char *)cdesc;
2209
2210         /* Locate the AudioStreaming interface descriptor. */
2211         offs = 0;
2212         id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOSTREAM);
2213         if (id == NULL)
2214                 return USBD_INVAL;
2215
2216 #if defined(__FreeBSD__)
2217         sc->uaudio_sndstat_flag = 0;
2218         if (sbuf_new(&(sc->uaudio_sndstat), NULL, 4096, SBUF_AUTOEXTEND) != NULL)
2219                 sc->uaudio_sndstat_flag = 1;
2220 #endif
2221         /* Loop through all the alternate settings. */
2222         while (offs <= size) {
2223                 DPRINTFN(2, ("uaudio_identify: interface=%d offset=%d\n",
2224                     id->bInterfaceNumber, offs));
2225                 switch (id->bNumEndpoints) {
2226                 case 0:
2227                         DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n",
2228                                      id->bAlternateSetting));
2229                         sc->sc_nullalt = id->bAlternateSetting;
2230                         break;
2231                 case 1:
2232 #ifdef UAUDIO_MULTIPLE_ENDPOINTS
2233                 case 2:
2234 #endif
2235                         uaudio_process_as(sc, buf, &offs, size, id);
2236                         break;
2237                 default:
2238                         printf("%s: ignored audio interface with %d "
2239                                "endpoints\n",
2240                                device_get_nameunit(sc->sc_dev), id->bNumEndpoints);
2241                         break;
2242                 }
2243                 id = uaudio_find_iface(buf, size, &offs,UISUBCLASS_AUDIOSTREAM);
2244                 if (id == NULL)
2245                         break;
2246         }
2247 #if defined(__FreeBSD__)
2248         sbuf_finish(&(sc->uaudio_sndstat));
2249 #endif
2250         if (offs > size)
2251                 return USBD_INVAL;
2252         DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts));
2253
2254         if (sc->sc_mode == 0) {
2255                 printf("%s: no usable endpoint found\n",
2256                        device_get_nameunit(sc->sc_dev));
2257                 return USBD_INVAL;
2258         }
2259
2260         return USBD_NORMAL_COMPLETION;
2261 }
2262
2263 static usbd_status
2264 uaudio_identify_ac(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
2265 {
2266         struct io_terminal* iot;
2267         const usb_interface_descriptor_t *id;
2268         const struct usb_audio_control_descriptor *acdp;
2269         const usb_descriptor_t *dp;
2270         const struct usb_audio_output_terminal *pot;
2271         struct terminal_list *tml;
2272         const char *buf, *ibuf, *ibufend;
2273         int size, offs, aclen, ndps, i, j;
2274
2275         size = UGETW(cdesc->wTotalLength);
2276         buf = (const char *)cdesc;
2277
2278         /* Locate the AudioControl interface descriptor. */
2279         offs = 0;
2280         id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOCONTROL);
2281         if (id == NULL)
2282                 return USBD_INVAL;
2283         if (offs + sizeof *acdp > size)
2284                 return USBD_INVAL;
2285         sc->sc_ac_iface = id->bInterfaceNumber;
2286         DPRINTFN(2,("uaudio_identify_ac: AC interface is %d\n", sc->sc_ac_iface));
2287
2288         /* A class-specific AC interface header should follow. */
2289         ibuf = buf + offs;
2290         acdp = (const struct usb_audio_control_descriptor *)ibuf;
2291         if (acdp->bDescriptorType != UDESC_CS_INTERFACE ||
2292             acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)
2293                 return USBD_INVAL;
2294         aclen = UGETW(acdp->wTotalLength);
2295         if (offs + aclen > size)
2296                 return USBD_INVAL;
2297
2298         if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) &&
2299              UGETW(acdp->bcdADC) != UAUDIO_VERSION)
2300                 return USBD_INVAL;
2301
2302         sc->sc_audio_rev = UGETW(acdp->bcdADC);
2303         DPRINTFN(2,("uaudio_identify_ac: found AC header, vers=%03x, len=%d\n",
2304                  sc->sc_audio_rev, aclen));
2305
2306         sc->sc_nullalt = -1;
2307
2308         /* Scan through all the AC specific descriptors */
2309         ibufend = ibuf + aclen;
2310         dp = (const usb_descriptor_t *)ibuf;
2311         ndps = 0;
2312         iot = malloc(sizeof(struct io_terminal) * 256, M_TEMP, M_NOWAIT | M_ZERO);
2313         if (iot == NULL) {
2314                 printf("%s: no memory\n", __func__);
2315                 return USBD_NOMEM;
2316         }
2317         for (;;) {
2318                 ibuf += dp->bLength;
2319                 if (ibuf >= ibufend)
2320                         break;
2321                 dp = (const usb_descriptor_t *)ibuf;
2322                 if (ibuf + dp->bLength > ibufend) {
2323                         free(iot, M_TEMP);
2324                         return USBD_INVAL;
2325                 }
2326                 if (dp->bDescriptorType != UDESC_CS_INTERFACE) {
2327                         printf("uaudio_identify_ac: skip desc type=0x%02x\n",
2328                                dp->bDescriptorType);
2329                         continue;
2330                 }
2331                 i = ((const struct usb_audio_input_terminal *)dp)->bTerminalId;
2332                 iot[i].d.desc = dp;
2333                 if (i > ndps)
2334                         ndps = i;
2335         }
2336         ndps++;
2337
2338         /* construct io_terminal */
2339         for (i = 0; i < ndps; i++) {
2340                 dp = iot[i].d.desc;
2341                 if (dp == NULL)
2342                         continue;
2343                 if (dp->bDescriptorSubtype != UDESCSUB_AC_OUTPUT)
2344                         continue;
2345                 pot = iot[i].d.ot;
2346                 tml = uaudio_io_terminaltype(UGETW(pot->wTerminalType), iot, i);
2347                 if (tml != NULL)
2348                         free(tml, M_TEMP);
2349         }
2350
2351 #ifdef USB_DEBUG
2352         for (i = 0; i < 256; i++) {
2353                 struct usb_audio_cluster cluster;
2354
2355                 if (iot[i].d.desc == NULL)
2356                         continue;
2357                 printf("id %d:\t", i);
2358                 switch (iot[i].d.desc->bDescriptorSubtype) {
2359                 case UDESCSUB_AC_INPUT:
2360                         printf("AC_INPUT type=%s\n", uaudio_get_terminal_name
2361                                   (UGETW(iot[i].d.it->wTerminalType)));
2362                         printf("\t");
2363                         cluster = uaudio_get_cluster(i, iot);
2364                         uaudio_dump_cluster(&cluster);
2365                         printf("\n");
2366                         break;
2367                 case UDESCSUB_AC_OUTPUT:
2368                         printf("AC_OUTPUT type=%s ", uaudio_get_terminal_name
2369                                   (UGETW(iot[i].d.ot->wTerminalType)));
2370                         printf("src=%d\n", iot[i].d.ot->bSourceId);
2371                         break;
2372                 case UDESCSUB_AC_MIXER:
2373                         printf("AC_MIXER src=");
2374                         for (j = 0; j < iot[i].d.mu->bNrInPins; j++)
2375                                 printf("%d ", iot[i].d.mu->baSourceId[j]);
2376                         printf("\n\t");
2377                         cluster = uaudio_get_cluster(i, iot);
2378                         uaudio_dump_cluster(&cluster);
2379                         printf("\n");
2380                         break;
2381                 case UDESCSUB_AC_SELECTOR:
2382                         printf("AC_SELECTOR src=");
2383                         for (j = 0; j < iot[i].d.su->bNrInPins; j++)
2384                                 printf("%d ", iot[i].d.su->baSourceId[j]);
2385                         printf("\n");
2386                         break;
2387                 case UDESCSUB_AC_FEATURE:
2388                         printf("AC_FEATURE src=%d\n", iot[i].d.fu->bSourceId);
2389                         break;
2390                 case UDESCSUB_AC_PROCESSING:
2391                         printf("AC_PROCESSING src=");
2392                         for (j = 0; j < iot[i].d.pu->bNrInPins; j++)
2393                                 printf("%d ", iot[i].d.pu->baSourceId[j]);
2394                         printf("\n\t");
2395                         cluster = uaudio_get_cluster(i, iot);
2396                         uaudio_dump_cluster(&cluster);
2397                         printf("\n");
2398                         break;
2399                 case UDESCSUB_AC_EXTENSION:
2400                         printf("AC_EXTENSION src=");
2401                         for (j = 0; j < iot[i].d.eu->bNrInPins; j++)
2402                                 printf("%d ", iot[i].d.eu->baSourceId[j]);
2403                         printf("\n\t");
2404                         cluster = uaudio_get_cluster(i, iot);
2405                         uaudio_dump_cluster(&cluster);
2406                         printf("\n");
2407                         break;
2408                 default:
2409                         printf("unknown audio control (subtype=%d)\n",
2410                                   iot[i].d.desc->bDescriptorSubtype);
2411                 }
2412                 for (j = 0; j < iot[i].inputs_size; j++) {
2413                         int k;
2414                         printf("\tinput%d: ", j);
2415                         tml = iot[i].inputs[j];
2416                         if (tml == NULL) {
2417                                 printf("NULL\n");
2418                                 continue;
2419                         }
2420                         for (k = 0; k < tml->size; k++)
2421                                 printf("%s ", uaudio_get_terminal_name
2422                                           (tml->terminals[k]));
2423                         printf("\n");
2424                 }
2425                 printf("\toutput: ");
2426                 tml = iot[i].output;
2427                 for (j = 0; j < tml->size; j++)
2428                         printf("%s ", uaudio_get_terminal_name(tml->terminals[j]));
2429                 printf("\n");
2430         }
2431 #endif
2432
2433         for (i = 0; i < ndps; i++) {
2434                 dp = iot[i].d.desc;
2435                 if (dp == NULL)
2436                         continue;
2437                 DPRINTF(("uaudio_identify_ac: id=%d subtype=%d\n",
2438                          i, dp->bDescriptorSubtype));
2439                 switch (dp->bDescriptorSubtype) {
2440                 case UDESCSUB_AC_HEADER:
2441                         printf("uaudio_identify_ac: unexpected AC header\n");
2442                         break;
2443                 case UDESCSUB_AC_INPUT:
2444                         uaudio_add_input(sc, iot, i);
2445                         break;
2446                 case UDESCSUB_AC_OUTPUT:
2447                         uaudio_add_output(sc, iot, i);
2448                         break;
2449                 case UDESCSUB_AC_MIXER:
2450                         uaudio_add_mixer(sc, iot, i);
2451                         break;
2452                 case UDESCSUB_AC_SELECTOR:
2453                         uaudio_add_selector(sc, iot, i);
2454                         break;
2455                 case UDESCSUB_AC_FEATURE:
2456                         uaudio_add_feature(sc, iot, i);
2457                         break;
2458                 case UDESCSUB_AC_PROCESSING:
2459                         uaudio_add_processing(sc, iot, i);
2460                         break;
2461                 case UDESCSUB_AC_EXTENSION:
2462                         uaudio_add_extension(sc, iot, i);
2463                         break;
2464                 default:
2465                         printf("uaudio_identify_ac: bad AC desc subtype=0x%02x\n",
2466                                dp->bDescriptorSubtype);
2467                         break;
2468                 }
2469         }
2470
2471         /* delete io_terminal */
2472         for (i = 0; i < 256; i++) {
2473                 if (iot[i].d.desc == NULL)
2474                         continue;
2475                 if (iot[i].inputs != NULL) {
2476                         for (j = 0; j < iot[i].inputs_size; j++) {
2477                                 if (iot[i].inputs[j] != NULL)
2478                                         free(iot[i].inputs[j], M_TEMP);
2479                         }
2480                         free(iot[i].inputs, M_TEMP);
2481                 }
2482                 if (iot[i].output != NULL)
2483                         free(iot[i].output, M_TEMP);
2484                 iot[i].d.desc = NULL;
2485         }
2486         free(iot, M_TEMP);
2487
2488         return USBD_NORMAL_COMPLETION;
2489 }
2490
2491 #if defined(__NetBSD__) || defined(__OpenBSD__)
2492 static int
2493 uaudio_query_devinfo(void *addr, mixer_devinfo_t *mi)
2494 {
2495         struct uaudio_softc *sc;
2496         struct mixerctl *mc;
2497         int n, nctls, i;
2498
2499         sc = addr;
2500         DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index));
2501         if (sc->sc_dying)
2502                 return EIO;
2503
2504         n = mi->index;
2505         nctls = sc->sc_nctls;
2506
2507         switch (n) {
2508         case UAC_OUTPUT:
2509                 mi->type = AUDIO_MIXER_CLASS;
2510                 mi->mixer_class = UAC_OUTPUT;
2511                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2512                 strlcpy(mi->label.name, AudioCoutputs, sizeof(mi->label.name));
2513                 return 0;
2514         case UAC_INPUT:
2515                 mi->type = AUDIO_MIXER_CLASS;
2516                 mi->mixer_class = UAC_INPUT;
2517                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2518                 strlcpy(mi->label.name, AudioCinputs, sizeof(mi->label.name));
2519                 return 0;
2520         case UAC_EQUAL:
2521                 mi->type = AUDIO_MIXER_CLASS;
2522                 mi->mixer_class = UAC_EQUAL;
2523                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2524                 strlcpy(mi->label.name, AudioCequalization,
2525                     sizeof(mi->label.name));
2526                 return 0;
2527         case UAC_RECORD:
2528                 mi->type = AUDIO_MIXER_CLASS;
2529                 mi->mixer_class = UAC_RECORD;
2530                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2531                 strlcpy(mi->label.name, AudioCrecord, sizeof(mi->label.name));
2532                 return 0;
2533         default:
2534                 break;
2535         }
2536
2537         n -= UAC_NCLASSES;
2538         if (n < 0 || n >= nctls)
2539                 return ENXIO;
2540
2541         mc = &sc->sc_ctls[n];
2542         strlcpy(mi->label.name, mc->ctlname, sizeof(mi->label.name));
2543         mi->mixer_class = mc->class;
2544         mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */
2545         switch (mc->type) {
2546         case MIX_ON_OFF:
2547                 mi->type = AUDIO_MIXER_ENUM;
2548                 mi->un.e.num_mem = 2;
2549                 strlcpy(mi->un.e.member[0].label.name, AudioNoff,
2550                     sizeof(mi->un.e.member[0].label.name));
2551                 mi->un.e.member[0].ord = 0;
2552                 strlcpy(mi->un.e.member[1].label.name, AudioNon,
2553                     sizeof(mi->un.e.member[1].label.name));
2554                 mi->un.e.member[1].ord = 1;
2555                 break;
2556         case MIX_SELECTOR:
2557                 mi->type = AUDIO_MIXER_ENUM;
2558                 mi->un.e.num_mem = mc->maxval - mc->minval + 1;
2559                 for (i = 0; i <= mc->maxval - mc->minval; i++) {
2560                         snprintf(mi->un.e.member[i].label.name,
2561                                  sizeof(mi->un.e.member[i].label.name),
2562                                  "%d", i + mc->minval);
2563                         mi->un.e.member[i].ord = i + mc->minval;
2564                 }
2565                 break;
2566         default:
2567                 mi->type = AUDIO_MIXER_VALUE;
2568                 strlcpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN);
2569                 mi->un.v.num_channels = mc->nchan;
2570                 mi->un.v.delta = mc->delta;
2571                 break;
2572         }
2573         return 0;
2574 }
2575
2576 static int
2577 uaudio_open(void *addr, int flags)
2578 {
2579         struct uaudio_softc *sc;
2580
2581         sc = addr;
2582         DPRINTF(("uaudio_open: sc=%p\n", sc));
2583         if (sc->sc_dying)
2584                 return EIO;
2585
2586         if ((flags & FWRITE) && !(sc->sc_mode & AUMODE_PLAY))
2587                 return EACCES;
2588         if ((flags & FREAD) && !(sc->sc_mode & AUMODE_RECORD))
2589                 return EACCES;
2590
2591         return 0;
2592 }
2593
2594 /*
2595  * Close function is called at splaudio().
2596  */
2597 static void
2598 uaudio_close(void *addr)
2599 {
2600 }
2601
2602 static int
2603 uaudio_drain(void *addr)
2604 {
2605         struct uaudio_softc *sc;
2606
2607         sc = addr;
2608         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
2609
2610         return 0;
2611 }
2612
2613 static int
2614 uaudio_halt_out_dma(void *addr)
2615 {
2616         struct uaudio_softc *sc;
2617
2618         sc = addr;
2619         if (sc->sc_dying)
2620                 return EIO;
2621
2622         DPRINTF(("uaudio_halt_out_dma: enter\n"));
2623         if (sc->sc_playchan.pipe != NULL) {
2624                 uaudio_chan_close(sc, &sc->sc_playchan);
2625                 sc->sc_playchan.pipe = NULL;
2626                 uaudio_chan_free_buffers(sc, &sc->sc_playchan);
2627                 sc->sc_playchan.intr = NULL;
2628         }
2629         return 0;
2630 }
2631
2632 static int
2633 uaudio_halt_in_dma(void *addr)
2634 {
2635         struct uaudio_softc *sc;
2636
2637         DPRINTF(("uaudio_halt_in_dma: enter\n"));
2638         sc = addr;
2639         if (sc->sc_recchan.pipe != NULL) {
2640                 uaudio_chan_close(sc, &sc->sc_recchan);
2641                 sc->sc_recchan.pipe = NULL;
2642                 uaudio_chan_free_buffers(sc, &sc->sc_recchan);
2643                 sc->sc_recchan.intr = NULL;
2644         }
2645         return 0;
2646 }
2647
2648 static int
2649 uaudio_getdev(void *addr, struct audio_device *retp)
2650 {
2651         struct uaudio_softc *sc;
2652
2653         DPRINTF(("uaudio_mixer_getdev:\n"));
2654         sc = addr;
2655         if (sc->sc_dying)
2656                 return EIO;
2657
2658         *retp = uaudio_device;
2659         return 0;
2660 }
2661
2662 /*
2663  * Make sure the block size is large enough to hold all outstanding transfers.
2664  */
2665 static int
2666 uaudio_round_blocksize(void *addr, int blk)
2667 {
2668         struct uaudio_softc *sc;
2669         int b;
2670
2671         sc = addr;
2672         DPRINTF(("uaudio_round_blocksize: blk=%d mode=%s\n", blk,
2673                 mode == AUMODE_PLAY ? "AUMODE_PLAY" : "AUMODE_RECORD"));
2674
2675         /* chan.bytes_per_frame can be 0. */
2676         if (mode == AUMODE_PLAY || sc->sc_recchan.bytes_per_frame <= 0) {
2677                 b = param->sample_rate * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
2678
2679                 /*
2680                  * This does not make accurate value in the case
2681                  * of b % USB_FRAMES_PER_SECOND != 0
2682                  */
2683                 b /= USB_FRAMES_PER_SECOND;
2684
2685                 b *= param->precision / 8 * param->channels;
2686         } else {
2687                 /*
2688                  * use wMaxPacketSize in bytes_per_frame.
2689                  * See uaudio_set_params() and uaudio_chan_init()
2690                  */
2691                 b = sc->sc_recchan.bytes_per_frame
2692                         * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
2693         }
2694
2695         if (b <= 0)
2696                 b = 1;
2697         blk = blk <= b ? b : blk / b * b;
2698
2699 #ifdef DIAGNOSTIC
2700         if (blk <= 0) {
2701                 printf("uaudio_round_blocksize: blk=%d\n", blk);
2702                 blk = 512;
2703         }
2704 #endif
2705
2706         DPRINTF(("uaudio_round_blocksize: resultant blk=%d\n", blk));
2707         return blk;
2708 }
2709
2710 static int
2711 uaudio_get_props(void *addr)
2712 {
2713         return AUDIO_PROP_FULLDUPLEX | AUDIO_PROP_INDEPENDENT;
2714
2715 }
2716 #endif  /* NetBSD or OpenBSD */
2717
2718 static int
2719 uaudio_get(struct uaudio_softc *sc, int which, int type, int wValue,
2720            int wIndex, int len)
2721 {
2722         usb_device_request_t req;
2723         uint8_t data[4];
2724         usbd_status err;
2725         int val;
2726
2727 #if defined(__FreeBSD__)
2728         if (sc->sc_dying)
2729                 return EIO;
2730 #endif
2731
2732         if (wValue == -1)
2733                 return 0;
2734
2735         req.bmRequestType = type;
2736         req.bRequest = which;
2737         USETW(req.wValue, wValue);
2738         USETW(req.wIndex, wIndex);
2739         USETW(req.wLength, len);
2740         DPRINTFN(2,("uaudio_get: type=0x%02x req=0x%02x wValue=0x%04x "
2741                     "wIndex=0x%04x len=%d\n",
2742                     type, which, wValue, wIndex, len));
2743 #if defined(__FreeBSD__)
2744         if (sc->async != 0)
2745                 err = usbd_do_request_async(sc->sc_udev, &req, data);
2746         else
2747 #endif
2748                 err = usbd_do_request(sc->sc_udev, &req, data);
2749         if (err) {
2750                 DPRINTF(("uaudio_get: err=%s\n", usbd_errstr(err)));
2751                 return -1;
2752         }
2753         switch (len) {
2754         case 1:
2755                 val = data[0];
2756                 break;
2757         case 2:
2758                 val = data[0] | (data[1] << 8);
2759                 break;
2760         default:
2761                 DPRINTF(("uaudio_get: bad length=%d\n", len));
2762                 return -1;
2763         }
2764         DPRINTFN(2,("uaudio_get: val=%d\n", val));
2765         return val;
2766 }
2767
2768 static void
2769 uaudio_set(struct uaudio_softc *sc, int which, int type, int wValue,
2770            int wIndex, int len, int val)
2771 {
2772         usb_device_request_t req;
2773         uint8_t data[4];
2774         usbd_status err;
2775
2776 #if defined(__FreeBSD__)
2777         if (sc->sc_dying)
2778                 return;
2779 #endif
2780
2781         if (wValue == -1)
2782                 return;
2783
2784         req.bmRequestType = type;
2785         req.bRequest = which;
2786         USETW(req.wValue, wValue);
2787         USETW(req.wIndex, wIndex);
2788         USETW(req.wLength, len);
2789         switch (len) {
2790         case 1:
2791                 data[0] = val;
2792                 break;
2793         case 2:
2794                 data[0] = val;
2795                 data[1] = val >> 8;
2796                 break;
2797         default:
2798                 return;
2799         }
2800         DPRINTFN(2,("uaudio_set: type=0x%02x req=0x%02x wValue=0x%04x "
2801                     "wIndex=0x%04x len=%d, val=%d\n",
2802                     type, which, wValue, wIndex, len, val & 0xffff));
2803 #if defined(__FreeBSD__)
2804         if (sc->async != 0)
2805                 err = usbd_do_request_async(sc->sc_udev, &req, data);
2806         else
2807 #endif
2808                 err = usbd_do_request(sc->sc_udev, &req, data);
2809 #ifdef USB_DEBUG
2810         if (err)
2811                 DPRINTF(("uaudio_set: err=%d\n", err));
2812 #endif
2813 }
2814
2815 static int
2816 uaudio_signext(int type, int val)
2817 {
2818         if (!MIX_UNSIGNED(type)) {
2819                 if (MIX_SIZE(type) == 2)
2820                         val = (int16_t)val;
2821                 else
2822                         val = (int8_t)val;
2823         }
2824         return val;
2825 }
2826
2827 #if defined(__NetBSD__) || defined(__OpenBSD__)
2828 static int
2829 uaudio_value2bsd(struct mixerctl *mc, int val)
2830 {
2831         DPRINTFN(5, ("uaudio_value2bsd: type=%03x val=%d min=%d max=%d ",
2832                      mc->type, val, mc->minval, mc->maxval));
2833         if (mc->type == MIX_ON_OFF) {
2834                 val = (val != 0);
2835         } else if (mc->type == MIX_SELECTOR) {
2836                 if (val < mc->minval || val > mc->maxval)
2837                         val = mc->minval;
2838         } else
2839                 val = ((uaudio_signext(mc->type, val) - mc->minval) * 255
2840                         + mc->mul/2) / mc->mul;
2841         DPRINTFN(5, ("val'=%d\n", val));
2842         return val;
2843 }
2844 #endif
2845
2846 int
2847 uaudio_bsd2value(struct mixerctl *mc, int val)
2848 {
2849         DPRINTFN(5,("uaudio_bsd2value: type=%03x val=%d min=%d max=%d ",
2850                     mc->type, val, mc->minval, mc->maxval));
2851         if (mc->type == MIX_ON_OFF) {
2852                 val = (val != 0);
2853         } else if (mc->type == MIX_SELECTOR) {
2854                 if (val < mc->minval || val > mc->maxval)
2855                         val = mc->minval;
2856         } else
2857                 val = (val + mc->delta/2) * mc->mul / 255 + mc->minval;
2858         DPRINTFN(5, ("val'=%d\n", val));
2859         return val;
2860 }
2861
2862 #if defined(__NetBSD__) || defined(__OpenBSD__)
2863 static int
2864 uaudio_ctl_get(struct uaudio_softc *sc, int which, struct mixerctl *mc,
2865                int chan)
2866 {
2867         int val;
2868
2869         DPRINTFN(5,("uaudio_ctl_get: which=%d chan=%d\n", which, chan));
2870         val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan],
2871                          mc->wIndex, MIX_SIZE(mc->type));
2872         return uaudio_value2bsd(mc, val);
2873 }
2874 #endif
2875
2876 static void
2877 uaudio_ctl_set(struct uaudio_softc *sc, int which, struct mixerctl *mc,
2878                int chan, int val)
2879 {
2880         val = uaudio_bsd2value(mc, val);
2881         uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan],
2882                    mc->wIndex, MIX_SIZE(mc->type), val);
2883 }
2884
2885 #if defined(__NetBSD__) || defined(__OpenBSD__)
2886 static int
2887 uaudio_mixer_get_port(void *addr, mixer_ctrl_t *cp)
2888 {
2889         struct uaudio_softc *sc;
2890         struct mixerctl *mc;
2891         int i, n, vals[MIX_MAX_CHAN], val;
2892
2893         DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev));
2894         sc = addr;
2895         if (sc->sc_dying)
2896                 return EIO;
2897
2898         n = cp->dev - UAC_NCLASSES;
2899         if (n < 0 || n >= sc->sc_nctls)
2900                 return ENXIO;
2901         mc = &sc->sc_ctls[n];
2902
2903         if (mc->type == MIX_ON_OFF) {
2904                 if (cp->type != AUDIO_MIXER_ENUM)
2905                         return EINVAL;
2906                 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
2907         } else if (mc->type == MIX_SELECTOR) {
2908                 if (cp->type != AUDIO_MIXER_ENUM)
2909                         return EINVAL;
2910                 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
2911         } else {
2912                 if (cp->type != AUDIO_MIXER_VALUE)
2913                         return (EINVAL);
2914                 if (cp->un.value.num_channels != 1 &&
2915                     cp->un.value.num_channels != mc->nchan)
2916                         return EINVAL;
2917                 for (i = 0; i < mc->nchan; i++)
2918                         vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i);
2919                 if (cp->un.value.num_channels == 1 && mc->nchan != 1) {
2920                         for (val = 0, i = 0; i < mc->nchan; i++)
2921                                 val += vals[i];
2922                         vals[0] = val / mc->nchan;
2923                 }
2924                 for (i = 0; i < cp->un.value.num_channels; i++)
2925                         cp->un.value.level[i] = vals[i];
2926         }
2927
2928         return 0;
2929 }
2930
2931 static int
2932 uaudio_mixer_set_port(void *addr, mixer_ctrl_t *cp)
2933 {
2934         struct uaudio_softc *sc;
2935         struct mixerctl *mc;
2936         int i, n, vals[MIX_MAX_CHAN];
2937
2938         DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev));
2939         sc = addr;
2940         if (sc->sc_dying)
2941                 return EIO;
2942
2943         n = cp->dev - UAC_NCLASSES;
2944         if (n < 0 || n >= sc->sc_nctls)
2945                 return ENXIO;
2946         mc = &sc->sc_ctls[n];
2947
2948         if (mc->type == MIX_ON_OFF) {
2949                 if (cp->type != AUDIO_MIXER_ENUM)
2950                         return EINVAL;
2951                 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
2952         } else if (mc->type == MIX_SELECTOR) {
2953                 if (cp->type != AUDIO_MIXER_ENUM)
2954                         return EINVAL;
2955                 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
2956         } else {
2957                 if (cp->type != AUDIO_MIXER_VALUE)
2958                         return EINVAL;
2959                 if (cp->un.value.num_channels == 1)
2960                         for (i = 0; i < mc->nchan; i++)
2961                                 vals[i] = cp->un.value.level[0];
2962                 else if (cp->un.value.num_channels == mc->nchan)
2963                         for (i = 0; i < mc->nchan; i++)
2964                                 vals[i] = cp->un.value.level[i];
2965                 else
2966                         return EINVAL;
2967                 for (i = 0; i < mc->nchan; i++)
2968                         uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]);
2969         }
2970         return 0;
2971 }
2972
2973 static int
2974 uaudio_trigger_input(void *addr, void *start, void *end, int blksize,
2975                      void (*intr)(void *), void *arg,
2976                      struct audio_params *param)
2977 {
2978         struct uaudio_softc *sc;
2979         struct chan *ch;
2980         usbd_status err;
2981         int i, s;
2982
2983         sc = addr;
2984         if (sc->sc_dying)
2985                 return EIO;
2986
2987         DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p "
2988                     "blksize=%d\n", sc, start, end, blksize));
2989         ch = &sc->sc_recchan;
2990         uaudio_chan_set_param(ch, start, end, blksize);
2991         DPRINTFN(3,("uaudio_trigger_input: sample_size=%d bytes/frame=%d "
2992                     "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
2993                     ch->fraction));
2994
2995         err = uaudio_chan_alloc_buffers(sc, ch);
2996         if (err)
2997                 return EIO;
2998
2999         err = uaudio_chan_open(sc, ch);
3000         if (err) {
3001                 uaudio_chan_free_buffers(sc, ch);
3002                 return EIO;
3003         }
3004
3005         ch->intr = intr;
3006         ch->arg = arg;
3007
3008         s = splusb();
3009         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
3010                 uaudio_chan_rtransfer(ch);
3011         splx(s);
3012
3013         return 0;
3014 }
3015
3016 static int
3017 uaudio_trigger_output(void *addr, void *start, void *end, int blksize,
3018                       void (*intr)(void *), void *arg,
3019                       struct audio_params *param)
3020 {
3021         struct uaudio_softc *sc;
3022         struct chan *ch;
3023         usbd_status err;
3024         int i, s;
3025
3026         sc = addr;
3027         if (sc->sc_dying)
3028                 return EIO;
3029
3030         DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p "
3031                     "blksize=%d\n", sc, start, end, blksize));
3032         ch = &sc->sc_playchan;
3033         uaudio_chan_set_param(ch, start, end, blksize);
3034         DPRINTFN(3,("uaudio_trigger_output: sample_size=%d bytes/frame=%d "
3035                     "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
3036                     ch->fraction));
3037
3038         err = uaudio_chan_alloc_buffers(sc, ch);
3039         if (err)
3040                 return EIO;
3041
3042         err = uaudio_chan_open(sc, ch);
3043         if (err) {
3044                 uaudio_chan_free_buffers(sc, ch);
3045                 return EIO;
3046         }
3047
3048         ch->intr = intr;
3049         ch->arg = arg;
3050
3051         s = splusb();
3052         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
3053                 uaudio_chan_ptransfer(ch);
3054         splx(s);
3055
3056         return 0;
3057 }
3058 #endif  /* NetBSD or OpenBSD */
3059
3060 /* Set up a pipe for a channel. */
3061 static usbd_status
3062 uaudio_chan_open(struct uaudio_softc *sc, struct chan *ch)
3063 {
3064         struct as_info *as;
3065         int endpt;
3066 #if defined(__FreeBSD__)
3067         int locked;
3068 #endif
3069         usbd_status err;
3070
3071 #if defined(__FreeBSD__)
3072         if (sc->sc_dying)
3073                 return EIO;
3074 #endif
3075
3076         as = &sc->sc_alts[ch->altidx];
3077         endpt = as->edesc->bEndpointAddress;
3078         DPRINTF(("uaudio_chan_open: endpt=0x%02x, speed=%d, alt=%d\n",
3079                  endpt, ch->sample_rate, as->alt));
3080
3081 #if defined(__FreeBSD__)
3082         locked = (ch->pcm_ch != NULL && mtx_owned(ch->pcm_ch->lock)) ? 1 : 0;
3083         if (locked)
3084                 CHN_UNLOCK(ch->pcm_ch);
3085 #endif
3086         /* Set alternate interface corresponding to the mode. */
3087         err = usbd_set_interface(as->ifaceh, as->alt);
3088 #if defined(__FreeBSD__)
3089         if (locked)
3090                 CHN_LOCK(ch->pcm_ch);
3091 #endif
3092         if (err)
3093                 return err;
3094
3095         /*
3096          * If just one sampling rate is supported,
3097          * no need to call uaudio_set_speed().
3098          * Roland SD-90 freezes by a SAMPLING_FREQ_CONTROL request.
3099          */
3100         if (as->asf1desc->bSamFreqType != 1) {
3101                 err = uaudio_set_speed(sc, endpt, ch->sample_rate);
3102                 if (err) {
3103                         DPRINTF(("uaudio_chan_open: set_speed failed err=%s\n",
3104                                  usbd_errstr(err)));
3105                 }
3106         }
3107
3108         ch->pipe = 0;
3109         ch->sync_pipe = 0;
3110         DPRINTF(("uaudio_chan_open: create pipe to 0x%02x\n", endpt));
3111         err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->pipe);
3112         if (err)
3113                 return err;
3114         if (as->edesc1 != NULL) {
3115                 endpt = as->edesc1->bEndpointAddress;
3116                 DPRINTF(("uaudio_chan_open: create sync-pipe to 0x%02x\n", endpt));
3117                 err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->sync_pipe);
3118         }
3119         return err;
3120 }
3121
3122 static void
3123 uaudio_chan_close(struct uaudio_softc *sc, struct chan *ch)
3124 {
3125         struct as_info *as;
3126 #if defined(__FreeBSD__)
3127         int locked;
3128
3129         if (sc->sc_dying)
3130                 return ;
3131 #endif
3132
3133         as = &sc->sc_alts[ch->altidx];
3134         as->sc_busy = 0;
3135 #if defined(__FreeBSD__)
3136         locked = (ch->pcm_ch != NULL && mtx_owned(ch->pcm_ch->lock)) ? 1 : 0;
3137         if (locked)
3138                 CHN_UNLOCK(ch->pcm_ch);
3139 #endif
3140         if (sc->sc_nullalt >= 0) {
3141                 DPRINTF(("uaudio_chan_close: set null alt=%d\n",
3142                          sc->sc_nullalt));
3143                 /*
3144                  * The interface will be initialized later again, so an
3145                  * error does not hurt.
3146                  */
3147                 (void)usbd_set_interface(as->ifaceh, sc->sc_nullalt);
3148         }
3149         if (ch->pipe) {
3150                 usbd_abort_pipe(ch->pipe);
3151                 usbd_close_pipe(ch->pipe);
3152         }
3153         if (ch->sync_pipe) {
3154                 usbd_abort_pipe(ch->sync_pipe);
3155                 usbd_close_pipe(ch->sync_pipe);
3156         }
3157 #if defined(__FreeBSD__)
3158         if (locked)
3159                 CHN_LOCK(ch->pcm_ch);
3160 #endif
3161 }
3162
3163 static usbd_status
3164 uaudio_chan_alloc_buffers(struct uaudio_softc *sc, struct chan *ch)
3165 {
3166         usbd_xfer_handle xfer;
3167         void *buf;
3168         int i, size;
3169
3170         size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES;
3171         for (i = 0; i < UAUDIO_NCHANBUFS; i++) {
3172                 xfer = usbd_alloc_xfer(sc->sc_udev);
3173                 if (xfer == 0)
3174                         goto bad;
3175                 ch->chanbufs[i].xfer = xfer;
3176                 buf = usbd_alloc_buffer(xfer, size);
3177                 if (buf == 0) {
3178                         i++;
3179                         goto bad;
3180                 }
3181                 ch->chanbufs[i].buffer = buf;
3182                 ch->chanbufs[i].chan = ch;
3183         }
3184
3185         return USBD_NORMAL_COMPLETION;
3186
3187 bad:
3188         while (--i >= 0)
3189                 /* implicit buffer free */
3190                 usbd_free_xfer(ch->chanbufs[i].xfer);
3191         return USBD_NOMEM;
3192 }
3193
3194 static void
3195 uaudio_chan_free_buffers(struct uaudio_softc *sc, struct chan *ch)
3196 {
3197         int i;
3198
3199         for (i = 0; i < UAUDIO_NCHANBUFS; i++)
3200                 usbd_free_xfer(ch->chanbufs[i].xfer);
3201 }
3202
3203 /* Called at splusb() */
3204 static void
3205 uaudio_chan_ptransfer(struct chan *ch)
3206 {
3207         struct chanbuf *cb;
3208         int i, n, size, residue, total;
3209
3210         if (ch->sc->sc_dying)
3211                 return;
3212
3213         /* Pick the next channel buffer. */
3214         cb = &ch->chanbufs[ch->curchanbuf];
3215         if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
3216                 ch->curchanbuf = 0;
3217
3218         /* Compute the size of each frame in the next transfer. */
3219         residue = ch->residue;
3220         total = 0;
3221         for (i = 0; i < UAUDIO_NFRAMES; i++) {
3222                 size = ch->bytes_per_frame;
3223                 residue += ch->fraction;
3224                 if (residue >= USB_FRAMES_PER_SECOND) {
3225                         if ((ch->sc->sc_altflags & UA_NOFRAC) == 0)
3226                                 size += ch->sample_size;
3227                         residue -= USB_FRAMES_PER_SECOND;
3228                 }
3229                 cb->sizes[i] = size;
3230                 total += size;
3231         }
3232         ch->residue = residue;
3233         cb->size = total;
3234
3235         /*
3236          * Transfer data from upper layer buffer to channel buffer, taking
3237          * care of wrapping the upper layer buffer.
3238          */
3239         n = min(total, ch->end - ch->cur);
3240         memcpy(cb->buffer, ch->cur, n);
3241         ch->cur += n;
3242         if (ch->cur >= ch->end)
3243                 ch->cur = ch->start;
3244         if (total > n) {
3245                 total -= n;
3246                 memcpy(cb->buffer + n, ch->cur, total);
3247                 ch->cur += total;
3248         }
3249
3250 #ifdef USB_DEBUG
3251         if (uaudiodebug > 8) {
3252                 DPRINTF(("uaudio_chan_ptransfer: buffer=%p, residue=0.%03d\n",
3253                          cb->buffer, ch->residue));
3254                 for (i = 0; i < UAUDIO_NFRAMES; i++) {
3255                         DPRINTF(("   [%d] length %d\n", i, cb->sizes[i]));
3256                 }
3257         }
3258 #endif
3259
3260         DPRINTFN(5,("uaudio_chan_transfer: ptransfer xfer=%p\n", cb->xfer));
3261         /* Fill the request */
3262         usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
3263                              UAUDIO_NFRAMES, USBD_NO_COPY,
3264                              uaudio_chan_pintr);
3265
3266         (void)usbd_transfer(cb->xfer);
3267 }
3268
3269 static void
3270 uaudio_chan_pintr(usbd_xfer_handle xfer, usbd_private_handle priv,
3271                   usbd_status status)
3272 {
3273         struct chanbuf *cb;
3274         struct chan *ch;
3275         u_int32_t count;
3276         int s;
3277
3278         cb = priv;
3279         ch = cb->chan;
3280         /* Return if we are aborting. */
3281         if (status == USBD_CANCELLED)
3282                 return;
3283
3284         usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
3285         DPRINTFN(5,("uaudio_chan_pintr: count=%d, transferred=%d\n",
3286                     count, ch->transferred));
3287 #ifdef DIAGNOSTIC
3288         if (count != cb->size) {
3289                 printf("uaudio_chan_pintr: count(%d) != size(%d)\n",
3290                        count, cb->size);
3291         }
3292 #endif
3293
3294         ch->transferred += cb->size;
3295 #if defined(__FreeBSD__)
3296         /* s = spltty(); */
3297         s = splhigh();
3298         chn_intr(ch->pcm_ch);
3299         splx(s);
3300 #else
3301         s = splaudio();
3302         /* Call back to upper layer */
3303         while (ch->transferred >= ch->blksize) {
3304                 ch->transferred -= ch->blksize;
3305                 DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n",
3306                             ch->intr, ch->arg));
3307                 ch->intr(ch->arg);
3308         }
3309         splx(s);
3310 #endif
3311
3312         /* start next transfer */
3313         uaudio_chan_ptransfer(ch);
3314 }
3315
3316 /* Called at splusb() */
3317 static void
3318 uaudio_chan_rtransfer(struct chan *ch)
3319 {
3320         struct chanbuf *cb;
3321         int i, size, residue, total;
3322
3323         if (ch->sc->sc_dying)
3324                 return;
3325
3326         /* Pick the next channel buffer. */
3327         cb = &ch->chanbufs[ch->curchanbuf];
3328         if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
3329                 ch->curchanbuf = 0;
3330
3331         /* Compute the size of each frame in the next transfer. */
3332         residue = ch->residue;
3333         total = 0;
3334         for (i = 0; i < UAUDIO_NFRAMES; i++) {
3335                 size = ch->bytes_per_frame;
3336                 cb->sizes[i] = size;
3337                 cb->offsets[i] = total;
3338                 total += size;
3339         }
3340         ch->residue = residue;
3341         cb->size = total;
3342
3343 #ifdef USB_DEBUG
3344         if (uaudiodebug > 8) {
3345                 DPRINTF(("uaudio_chan_rtransfer: buffer=%p, residue=0.%03d\n",
3346                          cb->buffer, ch->residue));
3347                 for (i = 0; i < UAUDIO_NFRAMES; i++) {
3348                         DPRINTF(("   [%d] length %d\n", i, cb->sizes[i]));
3349                 }
3350         }
3351 #endif
3352
3353         DPRINTFN(5,("uaudio_chan_rtransfer: transfer xfer=%p\n", cb->xfer));
3354         /* Fill the request */
3355         usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
3356                              UAUDIO_NFRAMES, USBD_NO_COPY,
3357                              uaudio_chan_rintr);
3358
3359         (void)usbd_transfer(cb->xfer);
3360 }
3361
3362 static void
3363 uaudio_chan_rintr(usbd_xfer_handle xfer, usbd_private_handle priv,
3364                   usbd_status status)
3365 {
3366         struct chanbuf *cb = priv;
3367         struct chan *ch = cb->chan;
3368         u_int32_t count;
3369         int s, i, n, frsize;
3370
3371         /* Return if we are aborting. */
3372         if (status == USBD_CANCELLED)
3373                 return;
3374
3375         usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
3376         DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n",
3377                     count, ch->transferred));
3378
3379         /* count < cb->size is normal for asynchronous source */
3380 #ifdef DIAGNOSTIC
3381         if (count > cb->size) {
3382                 printf("uaudio_chan_rintr: count(%d) > size(%d)\n",
3383                        count, cb->size);
3384         }
3385 #endif
3386
3387         /*
3388          * Transfer data from channel buffer to upper layer buffer, taking
3389          * care of wrapping the upper layer buffer.
3390          */
3391         for(i = 0; i < UAUDIO_NFRAMES; i++) {
3392                 frsize = cb->sizes[i];
3393                 n = min(frsize, ch->end - ch->cur);
3394                 memcpy(ch->cur, cb->buffer + cb->offsets[i], n);
3395                 ch->cur += n;
3396                 if (ch->cur >= ch->end)
3397                         ch->cur = ch->start;
3398                 if (frsize > n) {
3399                         memcpy(ch->cur, cb->buffer + cb->offsets[i] + n,
3400                             frsize - n);
3401                         ch->cur += frsize - n;
3402                 }
3403         }
3404
3405         /* Call back to upper layer */
3406         ch->transferred += count;
3407 #if defined(__FreeBSD__)
3408         s = spltty();
3409         chn_intr(ch->pcm_ch);
3410         splx(s);
3411 #else
3412         s = splaudio();
3413         while (ch->transferred >= ch->blksize) {
3414                 ch->transferred -= ch->blksize;
3415                 DPRINTFN(5,("uaudio_chan_rintr: call %p(%p)\n",
3416                             ch->intr, ch->arg));
3417                 ch->intr(ch->arg);
3418         }
3419         splx(s);
3420 #endif
3421
3422         /* start next transfer */
3423         uaudio_chan_rtransfer(ch);
3424 }
3425
3426 #if defined(__NetBSD__) || defined(__OpenBSD__)
3427 static void
3428 uaudio_chan_init(struct chan *ch, int altidx, const struct audio_params *param,
3429     int maxpktsize)
3430 {
3431         int samples_per_frame, sample_size;
3432
3433         ch->altidx = altidx;
3434         sample_size = param->precision * param->factor * param->hw_channels / 8;
3435         samples_per_frame = param->hw_sample_rate / USB_FRAMES_PER_SECOND;
3436         ch->sample_size = sample_size;
3437         ch->sample_rate = param->hw_sample_rate;
3438         if (maxpktsize == 0) {
3439                 ch->fraction = param->hw_sample_rate % USB_FRAMES_PER_SECOND;
3440                 ch->bytes_per_frame = samples_per_frame * sample_size;
3441         } else {
3442                 ch->fraction = 0;
3443                 ch->bytes_per_frame = maxpktsize;
3444         }
3445         ch->residue = 0;
3446 }
3447
3448 static void
3449 uaudio_chan_set_param(struct chan *ch, u_char *start, u_char *end, int blksize)
3450 {
3451         ch->start = start;
3452         ch->end = end;
3453         ch->cur = start;
3454         ch->blksize = blksize;
3455         ch->transferred = 0;
3456         ch->curchanbuf = 0;
3457 }
3458
3459 static void
3460 uaudio_get_minmax_rates(int nalts, const struct as_info *alts,
3461                         const struct audio_params *p, int mode,
3462                         u_long *min, u_long *max)
3463 {
3464         const struct usb_audio_streaming_type1_descriptor *a1d;
3465         int i, j;
3466
3467         *min = ULONG_MAX;
3468         *max = 0;
3469         for (i = 0; i < nalts; i++) {
3470                 a1d = alts[i].asf1desc;
3471                 if (alts[i].sc_busy)
3472                         continue;
3473                 if (p->hw_channels != a1d->bNrChannels)
3474                         continue;
3475                 if (p->hw_precision != a1d->bBitResolution)
3476                         continue;
3477                 if (p->hw_encoding != alts[i].encoding)
3478                         continue;
3479                 if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress))
3480                         continue;
3481                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
3482                         DPRINTFN(2,("uaudio_get_minmax_rates: cont %d-%d\n",
3483                                     UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
3484                         if (UA_SAMP_LO(a1d) < *min)
3485                                 *min = UA_SAMP_LO(a1d);
3486                         if (UA_SAMP_HI(a1d) > *max)
3487                                 *max = UA_SAMP_HI(a1d);
3488                 } else {
3489                         for (j = 0; j < a1d->bSamFreqType; j++) {
3490                                 DPRINTFN(2,("uaudio_get_minmax_rates: disc #%d: %d\n",
3491                                             j, UA_GETSAMP(a1d, j)));
3492                                 if (UA_GETSAMP(a1d, j) < *min)
3493                                         *min = UA_GETSAMP(a1d, j);
3494                                 if (UA_GETSAMP(a1d, j) > *max)
3495                                         *max = UA_GETSAMP(a1d, j);
3496                         }
3497                 }
3498         }
3499 }
3500
3501 static int
3502 uaudio_match_alt_sub(int nalts, const struct as_info *alts,
3503                      const struct audio_params *p, int mode, u_long rate)
3504 {
3505         const struct usb_audio_streaming_type1_descriptor *a1d;
3506         int i, j;
3507
3508         DPRINTF(("uaudio_match_alt_sub: search for %luHz %dch\n",
3509                  rate, p->hw_channels));
3510         for (i = 0; i < nalts; i++) {
3511                 a1d = alts[i].asf1desc;
3512                 if (alts[i].sc_busy)
3513                         continue;
3514                 if (p->hw_channels != a1d->bNrChannels)
3515                         continue;
3516                 if (p->hw_precision != a1d->bBitResolution)
3517                         continue;
3518                 if (p->hw_encoding != alts[i].encoding)
3519                         continue;
3520                 if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress))
3521                         continue;
3522                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
3523                         DPRINTFN(3,("uaudio_match_alt_sub: cont %d-%d\n",
3524                                     UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
3525                         if (UA_SAMP_LO(a1d) <= rate && rate <= UA_SAMP_HI(a1d))
3526                                 return i;
3527                 } else {
3528                         for (j = 0; j < a1d->bSamFreqType; j++) {
3529                                 DPRINTFN(3,("uaudio_match_alt_sub: disc #%d: %d\n",
3530                                             j, UA_GETSAMP(a1d, j)));
3531                                 /* XXX allow for some slack */
3532                                 if (UA_GETSAMP(a1d, j) == rate)
3533                                         return i;
3534                         }
3535                 }
3536         }
3537         return -1;
3538 }
3539
3540 static int
3541 uaudio_match_alt_chan(int nalts, const struct as_info *alts,
3542                       struct audio_params *p, int mode)
3543 {
3544         int i, n;
3545         u_long min, max;
3546         u_long rate;
3547
3548         /* Exact match */
3549         DPRINTF(("uaudio_match_alt_chan: examine %ldHz %dch %dbit.\n",
3550                  p->sample_rate, p->hw_channels, p->hw_precision));
3551         i = uaudio_match_alt_sub(nalts, alts, p, mode, p->sample_rate);
3552         if (i >= 0)
3553                 return i;
3554
3555         uaudio_get_minmax_rates(nalts, alts, p, mode, &min, &max);
3556         DPRINTF(("uaudio_match_alt_chan: min=%lu max=%lu\n", min, max));
3557         if (max <= 0)
3558                 return -1;
3559         /* Search for biggers */
3560         n = 2;
3561         while ((rate = p->sample_rate * n++) <= max) {
3562                 i = uaudio_match_alt_sub(nalts, alts, p, mode, rate);
3563                 if (i >= 0) {
3564                         p->hw_sample_rate = rate;
3565                         return i;
3566                 }
3567         }
3568         if (p->sample_rate >= min) {
3569                 i = uaudio_match_alt_sub(nalts, alts, p, mode, max);
3570                 if (i >= 0) {
3571                         p->hw_sample_rate = max;
3572                         return i;
3573                 }
3574         } else {
3575                 i = uaudio_match_alt_sub(nalts, alts, p, mode, min);
3576                 if (i >= 0) {
3577                         p->hw_sample_rate = min;
3578                         return i;
3579                 }
3580         }
3581         return -1;
3582 }
3583
3584 static int
3585 uaudio_match_alt(int nalts, const struct as_info *alts,
3586                  struct audio_params *p, int mode)
3587 {
3588         int i, n;
3589
3590         mode = mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN;
3591         i = uaudio_match_alt_chan(nalts, alts, p, mode);
3592         if (i >= 0)
3593                 return i;
3594
3595         for (n = p->channels + 1; n <= AUDIO_MAX_CHANNELS; n++) {
3596                 p->hw_channels = n;
3597                 i = uaudio_match_alt_chan(nalts, alts, p, mode);
3598                 if (i >= 0)
3599                         return i;
3600         }
3601
3602         if (p->channels != 2)
3603                 return -1;
3604         p->hw_channels = 1;
3605         return uaudio_match_alt_chan(nalts, alts, p, mode);
3606 }
3607
3608 static int
3609 uaudio_set_params(void *addr, int setmode, int usemode,
3610                   struct audio_params *play, struct audio_params *rec)
3611 {
3612         struct uaudio_softc *sc;
3613         int flags;
3614         int factor;
3615         int enc, i;
3616         int paltidx, raltidx;
3617         void (*swcode)(void *, u_char *buf, int cnt);
3618         struct audio_params *p;
3619         int mode;
3620
3621         sc = addr;
3622         flags = sc->sc_altflags;
3623         paltidx = -1;
3624         raltidx = -1;
3625         if (sc->sc_dying)
3626                 return EIO;
3627
3628         if (((usemode & AUMODE_PLAY) && sc->sc_playchan.pipe != NULL) ||
3629             ((usemode & AUMODE_RECORD) && sc->sc_recchan.pipe != NULL))
3630                 return EBUSY;
3631
3632         if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1)
3633                 sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 0;
3634         if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1)
3635                 sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 0;
3636
3637         /* Some uaudio devices are unidirectional.  Don't try to find a
3638            matching mode for the unsupported direction. */
3639         setmode &= sc->sc_mode;
3640
3641         for (mode = AUMODE_RECORD; mode != -1;
3642              mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
3643                 if ((setmode & mode) == 0)
3644                         continue;
3645
3646                 p = (mode == AUMODE_PLAY) ? play : rec;
3647
3648                 factor = 1;
3649                 swcode = 0;
3650                 enc = p->encoding;
3651                 switch (enc) {
3652                 case AUDIO_ENCODING_SLINEAR_BE:
3653                         /* FALLTHROUGH */
3654                 case AUDIO_ENCODING_SLINEAR_LE:
3655                         if (enc == AUDIO_ENCODING_SLINEAR_BE
3656                             && p->precision == 16 && (flags & HAS_16)) {
3657                                 swcode = swap_bytes;
3658                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3659                         } else if (p->precision == 8) {
3660                                 if (flags & HAS_8) {
3661                                         /* No conversion */
3662                                 } else if (flags & HAS_8U) {
3663                                         swcode = change_sign8;
3664                                         enc = AUDIO_ENCODING_ULINEAR_LE;
3665                                 } else if (flags & HAS_16) {
3666                                         factor = 2;
3667                                         p->hw_precision = 16;
3668                                         if (mode == AUMODE_PLAY)
3669                                                 swcode = linear8_to_linear16_le;
3670                                         else
3671                                                 swcode = linear16_to_linear8_le;
3672                                 }
3673                         }
3674                         break;
3675                 case AUDIO_ENCODING_ULINEAR_BE:
3676                         /* FALLTHROUGH */
3677                 case AUDIO_ENCODING_ULINEAR_LE:
3678                         if (p->precision == 16) {
3679                                 if (enc == AUDIO_ENCODING_ULINEAR_LE)
3680                                         swcode = change_sign16_le;
3681                                 else if (mode == AUMODE_PLAY)
3682                                         swcode = swap_bytes_change_sign16_le;
3683                                 else
3684                                         swcode = change_sign16_swap_bytes_le;
3685                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3686                         } else if (p->precision == 8) {
3687                                 if (flags & HAS_8U) {
3688                                         /* No conversion */
3689                                 } else if (flags & HAS_8) {
3690                                         swcode = change_sign8;
3691                                         enc = AUDIO_ENCODING_SLINEAR_LE;
3692                                 } else if (flags & HAS_16) {
3693                                         factor = 2;
3694                                         p->hw_precision = 16;
3695                                         enc = AUDIO_ENCODING_SLINEAR_LE;
3696                                         if (mode == AUMODE_PLAY)
3697                                                 swcode = ulinear8_to_slinear16_le;
3698                                         else
3699                                                 swcode = slinear16_to_ulinear8_le;
3700                                 }
3701                         }
3702                         break;
3703                 case AUDIO_ENCODING_ULAW:
3704                         if (flags & HAS_MULAW)
3705                                 break;
3706                         if (flags & HAS_16) {
3707                                 if (mode == AUMODE_PLAY)
3708                                         swcode = mulaw_to_slinear16_le;
3709                                 else
3710                                         swcode = slinear16_to_mulaw_le;
3711                                 factor = 2;
3712                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3713                                 p->hw_precision = 16;
3714                         } else if (flags & HAS_8U) {
3715                                 if (mode == AUMODE_PLAY)
3716                                         swcode = mulaw_to_ulinear8;
3717                                 else
3718                                         swcode = ulinear8_to_mulaw;
3719                                 enc = AUDIO_ENCODING_ULINEAR_LE;
3720                         } else if (flags & HAS_8) {
3721                                 if (mode == AUMODE_PLAY)
3722                                         swcode = mulaw_to_slinear8;
3723                                 else
3724                                         swcode = slinear8_to_mulaw;
3725                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3726                         } else
3727                                 return (EINVAL);
3728                         break;
3729                 case AUDIO_ENCODING_ALAW:
3730                         if (flags & HAS_ALAW)
3731                                 break;
3732                         if (mode == AUMODE_PLAY && (flags & HAS_16)) {
3733                                 swcode = alaw_to_slinear16_le;
3734                                 factor = 2;
3735                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3736                                 p->hw_precision = 16;
3737                         } else if (flags & HAS_8U) {
3738                                 if (mode == AUMODE_PLAY)
3739                                         swcode = alaw_to_ulinear8;
3740                                 else
3741                                         swcode = ulinear8_to_alaw;
3742                                 enc = AUDIO_ENCODING_ULINEAR_LE;
3743                         } else if (flags & HAS_8) {
3744                                 if (mode == AUMODE_PLAY)
3745                                         swcode = alaw_to_slinear8;
3746                                 else
3747                                         swcode = slinear8_to_alaw;
3748                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3749                         } else
3750                                 return (EINVAL);
3751                         break;
3752                 default:
3753                         return (EINVAL);
3754                 }
3755                 /* XXX do some other conversions... */
3756
3757                 DPRINTF(("uaudio_set_params: chan=%d prec=%d enc=%d rate=%ld\n",
3758                          p->channels, p->hw_precision, enc, p->sample_rate));
3759
3760                 p->hw_encoding = enc;
3761                 i = uaudio_match_alt(sc->sc_nalts, sc->sc_alts, p, mode);
3762                 if (i < 0)
3763                         return (EINVAL);
3764
3765                 p->sw_code = swcode;
3766                 p->factor  = factor;
3767
3768                 if (mode == AUMODE_PLAY)
3769                         paltidx = i;
3770                 else
3771                         raltidx = i;
3772         }
3773
3774         if ((setmode & AUMODE_PLAY)) {
3775                 /* XXX abort transfer if currently happening? */
3776                 uaudio_chan_init(&sc->sc_playchan, paltidx, play, 0);
3777         }
3778         if ((setmode & AUMODE_RECORD)) {
3779                 /* XXX abort transfer if currently happening? */
3780                 uaudio_chan_init(&sc->sc_recchan, raltidx, rec,
3781                     UGETW(sc->sc_alts[raltidx].edesc->wMaxPacketSize));
3782         }
3783
3784         if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1)
3785                 sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 1;
3786         if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1)
3787                 sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 1;
3788
3789         DPRINTF(("uaudio_set_params: use altidx=p%d/r%d, altno=p%d/r%d\n",
3790                  sc->sc_playchan.altidx, sc->sc_recchan.altidx,
3791                  (sc->sc_playchan.altidx >= 0)
3792                    ?sc->sc_alts[sc->sc_playchan.altidx].idesc->bAlternateSetting
3793                    : -1,
3794                  (sc->sc_recchan.altidx >= 0)
3795                    ? sc->sc_alts[sc->sc_recchan.altidx].idesc->bAlternateSetting
3796                    : -1));
3797
3798         return 0;
3799 }
3800 #endif /* NetBSD or OpenBSD */
3801
3802 static usbd_status
3803 uaudio_set_speed(struct uaudio_softc *sc, int endpt, u_int speed)
3804 {
3805         usb_device_request_t req;
3806         uint8_t data[3];
3807
3808         DPRINTFN(5,("uaudio_set_speed: endpt=%d speed=%u\n", endpt, speed));
3809         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
3810         req.bRequest = SET_CUR;
3811         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
3812         USETW(req.wIndex, endpt);
3813         USETW(req.wLength, 3);
3814         data[0] = speed;
3815         data[1] = speed >> 8;
3816         data[2] = speed >> 16;
3817
3818 #if defined(__FreeBSD__)
3819         if (sc->async != 0)
3820                 return usbd_do_request_async(sc->sc_udev, &req, data);
3821 #endif
3822         return usbd_do_request(sc->sc_udev, &req, data);
3823 }
3824
3825
3826 #if defined(__FreeBSD__)
3827 /************************************************************/
3828 int
3829 uaudio_init_params(struct uaudio_softc *sc, struct chan *ch, int mode)
3830 {
3831         int i, j, enc;
3832         int samples_per_frame, sample_size;
3833
3834         if ((sc->sc_playchan.pipe != NULL) || (sc->sc_recchan.pipe != NULL))
3835                 return (-1);
3836
3837         switch(ch->format & 0x000FFFFF) {
3838         case AFMT_U8:
3839                 enc = AUDIO_ENCODING_ULINEAR_LE;
3840                 ch->precision = 8;
3841                 break;
3842         case AFMT_S8:
3843                 enc = AUDIO_ENCODING_SLINEAR_LE;
3844                 ch->precision = 8;
3845                 break;
3846         case AFMT_A_LAW:        /* ? */
3847                 enc = AUDIO_ENCODING_ALAW;
3848                 ch->precision = 8;
3849                 break;
3850         case AFMT_MU_LAW:       /* ? */
3851                 enc = AUDIO_ENCODING_ULAW;
3852                 ch->precision = 8;
3853                 break;
3854         case AFMT_S16_LE:
3855                 enc = AUDIO_ENCODING_SLINEAR_LE;
3856                 ch->precision = 16;
3857                 break;
3858         case AFMT_S16_BE:
3859                 enc = AUDIO_ENCODING_SLINEAR_BE;
3860                 ch->precision = 16;
3861                 break;
3862         case AFMT_U16_LE:
3863                 enc = AUDIO_ENCODING_ULINEAR_LE;
3864                 ch->precision = 16;
3865                 break;
3866         case AFMT_U16_BE:
3867                 enc = AUDIO_ENCODING_ULINEAR_BE;
3868                 ch->precision = 16;
3869                 break;
3870         case AFMT_S24_LE:
3871                 enc = AUDIO_ENCODING_SLINEAR_LE;
3872                 ch->precision = 24;
3873                 break;
3874         case AFMT_S24_BE:
3875                 enc = AUDIO_ENCODING_SLINEAR_BE;
3876                 ch->precision = 24;
3877                 break;
3878         case AFMT_U24_LE:
3879                 enc = AUDIO_ENCODING_ULINEAR_LE;
3880                 ch->precision = 24;
3881                 break;
3882         case AFMT_U24_BE:
3883                 enc = AUDIO_ENCODING_ULINEAR_BE;
3884                 ch->precision = 24;
3885                 break;
3886         case AFMT_S32_LE:
3887                 enc = AUDIO_ENCODING_SLINEAR_LE;
3888                 ch->precision = 32;
3889                 break;
3890         case AFMT_S32_BE:
3891                 enc = AUDIO_ENCODING_SLINEAR_BE;
3892                 ch->precision = 32;
3893                 break;
3894         case AFMT_U32_LE:
3895                 enc = AUDIO_ENCODING_ULINEAR_LE;
3896                 ch->precision = 32;
3897                 break;
3898         case AFMT_U32_BE:
3899                 enc = AUDIO_ENCODING_ULINEAR_BE;
3900                 ch->precision = 32;
3901                 break;
3902         default:
3903                 enc = 0;
3904                 ch->precision = 16;
3905                 printf("Unknown format %x\n", ch->format);
3906         }
3907
3908         if (ch->format & AFMT_STEREO) {
3909                 ch->channels = 2;
3910         } else {
3911                 ch->channels = 1;
3912         }
3913
3914 /*      for (mode =  ......      */
3915                 for (i = 0; i < sc->sc_nalts; i++) {
3916                         const struct usb_audio_streaming_type1_descriptor *a1d =
3917                                 sc->sc_alts[i].asf1desc;
3918                         if (ch->channels == a1d->bNrChannels &&
3919                             ch->precision == a1d->bBitResolution &&
3920 #if 0
3921                             enc == sc->sc_alts[i].encoding) {
3922 #else
3923                             enc == sc->sc_alts[i].encoding &&
3924                             (mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN) ==
3925                             UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress)) {
3926 #endif
3927                                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
3928                                         DPRINTFN(2,("uaudio_set_params: cont %d-%d\n",
3929                                             UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
3930                                         if (UA_SAMP_LO(a1d) <= ch->sample_rate &&
3931                                             ch->sample_rate <= UA_SAMP_HI(a1d)) {
3932                                                 if (mode == AUMODE_PLAY)
3933                                                         sc->sc_playchan.altidx = i;
3934                                                 else
3935                                                         sc->sc_recchan.altidx = i;
3936                                                 goto found;
3937                                         }
3938                                 } else {
3939                                         for (j = 0; j < a1d->bSamFreqType; j++) {
3940                                                 DPRINTFN(2,("uaudio_set_params: disc #"
3941                                                     "%d: %d\n", j, UA_GETSAMP(a1d, j)));
3942                                                 /* XXX allow for some slack */
3943                                                 if (UA_GETSAMP(a1d, j) ==
3944                                                     ch->sample_rate) {
3945                                                         if (mode == AUMODE_PLAY)
3946                                                                 sc->sc_playchan.altidx = i;
3947                                                         else
3948                                                                 sc->sc_recchan.altidx = i;
3949                                                         goto found;
3950                                                 }
3951                                         }
3952                                 }
3953                         }
3954                 }
3955                 /* return (EINVAL); */
3956                 if (mode == AUMODE_PLAY)
3957                         printf("uaudio: This device can't play in rate=%d.\n", ch->sample_rate);
3958                 else
3959                         printf("uaudio: This device can't record in rate=%d.\n", ch->sample_rate);
3960                 return (-1);
3961
3962         found:
3963 #if 0 /* XXX */
3964                 p->sw_code = swcode;
3965                 p->factor  = factor;
3966                 if (usemode == mode)
3967                         sc->sc_curaltidx = i;
3968 #endif
3969 /*      } */
3970
3971         sample_size = ch->precision * ch->channels / 8;
3972         samples_per_frame = ch->sample_rate / USB_FRAMES_PER_SECOND;
3973         ch->fraction = ch->sample_rate % USB_FRAMES_PER_SECOND;
3974         ch->sample_size = sample_size;
3975         ch->bytes_per_frame = samples_per_frame * sample_size;
3976         ch->residue = 0;
3977
3978         ch->cur = ch->start;
3979         ch->transferred = 0;
3980         ch->curchanbuf = 0;
3981         return (0);
3982 }
3983
3984 struct uaudio_conversion {
3985         uint8_t uaudio_fmt;
3986         uint8_t uaudio_prec;
3987         uint32_t freebsd_fmt;
3988 };
3989
3990 const struct uaudio_conversion const accepted_conversion[] = {
3991         {AUDIO_ENCODING_ULINEAR_LE, 8, AFMT_U8},
3992         {AUDIO_ENCODING_ULINEAR_LE, 16, AFMT_U16_LE},
3993         {AUDIO_ENCODING_ULINEAR_LE, 24, AFMT_U24_LE},
3994         {AUDIO_ENCODING_ULINEAR_LE, 32, AFMT_U32_LE},
3995         {AUDIO_ENCODING_ULINEAR_BE, 16, AFMT_U16_BE},
3996         {AUDIO_ENCODING_ULINEAR_BE, 24, AFMT_U24_BE},
3997         {AUDIO_ENCODING_ULINEAR_BE, 32, AFMT_U32_BE},
3998         {AUDIO_ENCODING_SLINEAR_LE, 8, AFMT_S8},
3999         {AUDIO_ENCODING_SLINEAR_LE, 16, AFMT_S16_LE},
4000         {AUDIO_ENCODING_SLINEAR_LE, 24, AFMT_S24_LE},
4001         {AUDIO_ENCODING_SLINEAR_LE, 32, AFMT_S32_LE},
4002         {AUDIO_ENCODING_SLINEAR_BE, 16, AFMT_S16_BE},
4003         {AUDIO_ENCODING_SLINEAR_BE, 24, AFMT_S24_BE},
4004         {AUDIO_ENCODING_SLINEAR_BE, 32, AFMT_S32_BE},
4005         {AUDIO_ENCODING_ALAW, 8, AFMT_A_LAW},
4006         {AUDIO_ENCODING_ULAW, 8, AFMT_MU_LAW},
4007         {0,0,0}
4008 };
4009
4010 unsigned
4011 uaudio_query_formats(device_t dev, int reqdir, unsigned maxfmt, struct pcmchan_caps *cap)
4012 {
4013         struct uaudio_softc *sc;
4014         const struct usb_audio_streaming_type1_descriptor *asf1d;
4015         const struct uaudio_conversion *iterator;
4016         unsigned fmtcount, foundcount;
4017         u_int32_t fmt;
4018         uint8_t format, numchan, subframesize, prec, dir, iscontinuous;
4019         int freq, freq_min, freq_max;
4020         char *numchannel_descr;
4021         char freq_descr[64];
4022         int i,r;
4023
4024         sc = device_get_softc(dev);
4025         if (sc == NULL)
4026                 return 0;
4027
4028         cap->minspeed = cap->maxspeed = 0;
4029         foundcount = fmtcount = 0;
4030
4031         for (i = 0; i < sc->sc_nalts; i++) {
4032                 dir = UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress);
4033
4034                 if ((dir == UE_DIR_OUT) != (reqdir == PCMDIR_PLAY))
4035                         continue;
4036
4037                 asf1d = sc->sc_alts[i].asf1desc;
4038                 format = sc->sc_alts[i].encoding;
4039
4040                 numchan = asf1d->bNrChannels;
4041                 subframesize = asf1d->bSubFrameSize;
4042                 prec = asf1d->bBitResolution;   /* precision */
4043                 iscontinuous = asf1d->bSamFreqType == UA_SAMP_CONTNUOUS;
4044
4045                 if (iscontinuous)
4046                         snprintf(freq_descr, sizeof(freq_descr), "continous min %d max %d", UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
4047                 else
4048                         snprintf(freq_descr, sizeof(freq_descr), "fixed frequency (%d listed formats)", asf1d->bSamFreqType);
4049
4050                 if (numchan == 1)
4051                         numchannel_descr = " (mono)";
4052                 else if (numchan == 2)
4053                         numchannel_descr = " (stereo)";
4054                 else
4055                         numchannel_descr = "";
4056
4057                 if (bootverbose) {
4058                         device_printf(dev, "uaudio_query_formats: found a native %s channel%s %s %dbit %dbytes/subframe X %d channels = %d bytes per sample\n",
4059                                         (dir==UE_DIR_OUT)?"playback":"record",
4060                                         numchannel_descr, freq_descr,
4061                                         prec, subframesize, numchan, subframesize*numchan);
4062                 }
4063                 /*
4064                  * Now start rejecting the ones that don't map to FreeBSD
4065                  */
4066
4067                 if (numchan != 1 && numchan != 2)
4068                         continue;
4069
4070                 for (iterator = accepted_conversion ; iterator->uaudio_fmt != 0 ; iterator++)
4071                         if (iterator->uaudio_fmt == format && iterator->uaudio_prec == prec)
4072                                 break;
4073
4074                 if (iterator->uaudio_fmt == 0)
4075                         continue;
4076
4077                 fmt = iterator->freebsd_fmt;
4078
4079                 if (numchan == 2)
4080                         fmt |= AFMT_STEREO;
4081
4082                 foundcount++;
4083
4084                 if (fmtcount >= maxfmt)
4085                         continue;
4086
4087                 cap->fmtlist[fmtcount++] = fmt;
4088
4089                 if (iscontinuous) {
4090                         freq_min = UA_SAMP_LO(asf1d);
4091                         freq_max = UA_SAMP_HI(asf1d);
4092
4093                         if (cap->minspeed == 0 || freq_min < cap->minspeed)
4094                                 cap->minspeed = freq_min;
4095                         if (cap->maxspeed == 0)
4096                                 cap->maxspeed = cap->minspeed;
4097                         if (freq_max > cap->maxspeed)
4098                                 cap->maxspeed = freq_max;
4099                 } else {
4100                         for (r = 0; r < asf1d->bSamFreqType; r++) {
4101                                 freq = UA_GETSAMP(asf1d, r);
4102                                 if (cap->minspeed == 0 || freq < cap->minspeed)
4103                                         cap->minspeed = freq;
4104                                 if (cap->maxspeed == 0)
4105                                         cap->maxspeed = cap->minspeed;
4106                                 if (freq > cap->maxspeed)
4107                                         cap->maxspeed = freq;
4108                         }
4109                 }
4110         }
4111         cap->fmtlist[fmtcount] = 0;
4112         return foundcount;
4113 }
4114
4115 void
4116 uaudio_chan_set_param_pcm_dma_buff(device_t dev, u_char *start, u_char *end,
4117                 struct pcm_channel *pc, int dir)
4118 {
4119         struct uaudio_softc *sc;
4120         struct chan *ch;
4121
4122         sc = device_get_softc(dev);
4123 #ifndef NO_RECORDING
4124         if (dir == PCMDIR_PLAY)
4125                 ch = &sc->sc_playchan;
4126         else
4127                 ch = &sc->sc_recchan;
4128 #else
4129         ch = &sc->sc_playchan;
4130 #endif
4131
4132         ch->start = start;
4133         ch->end = end;
4134
4135         ch->pcm_ch = pc;
4136
4137         return;
4138 }
4139
4140 void
4141 uaudio_chan_set_param_blocksize(device_t dev, u_int32_t blocksize, int dir)
4142 {
4143         struct uaudio_softc *sc;
4144         struct chan *ch;
4145
4146         sc = device_get_softc(dev);
4147 #ifndef NO_RECORDING
4148         if (dir == PCMDIR_PLAY)
4149                 ch = &sc->sc_playchan;
4150         else
4151                 ch = &sc->sc_recchan;
4152 #else
4153         ch = &sc->sc_playchan;
4154 #endif
4155
4156         ch->blksize = blocksize;
4157
4158         return;
4159 }
4160
4161 int
4162 uaudio_chan_set_param_speed(device_t dev, u_int32_t speed, int reqdir)
4163 {
4164         const struct uaudio_conversion *iterator;
4165         struct uaudio_softc *sc;
4166         struct chan *ch;
4167         int i, r, score, hiscore, bestspeed;
4168
4169         sc = device_get_softc(dev);
4170 #ifndef NO_RECORDING
4171         if (reqdir == PCMDIR_PLAY)
4172                 ch = &sc->sc_playchan;
4173         else
4174                 ch = &sc->sc_recchan;
4175 #else
4176         ch = &sc->sc_playchan;
4177 #endif
4178         /*
4179          * We are successful if we find an endpoint that matches our selected format and it
4180          * supports the requested speed.
4181          */
4182         hiscore = 0;
4183         bestspeed = 1;
4184         for (i = 0; i < sc->sc_nalts; i++) {
4185                 int dir = UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress);
4186                 int format = sc->sc_alts[i].encoding;
4187                 const struct usb_audio_streaming_type1_descriptor *asf1d = sc->sc_alts[i].asf1desc;
4188                 int iscontinuous = asf1d->bSamFreqType == UA_SAMP_CONTNUOUS;
4189
4190                 if ((dir == UE_DIR_OUT) != (reqdir == PCMDIR_PLAY))
4191                         continue;
4192
4193                 for (iterator = accepted_conversion ; iterator->uaudio_fmt != 0 ; iterator++)
4194                         if (iterator->uaudio_fmt != format || iterator->freebsd_fmt != (ch->format&0xfffffff))
4195                                 continue;
4196                         if (iscontinuous) {
4197                                 if (speed >= UA_SAMP_LO(asf1d) && speed <= UA_SAMP_HI(asf1d)) {
4198                                         ch->sample_rate = speed;
4199                                         return speed;
4200                                 } else if (speed < UA_SAMP_LO(asf1d)) {
4201                                         score = 0xfff * speed / UA_SAMP_LO(asf1d);
4202                                         if (score > hiscore) {
4203                                                 bestspeed = UA_SAMP_LO(asf1d);
4204                                                 hiscore = score;
4205                                         }
4206                                 } else if (speed > UA_SAMP_HI(asf1d)) {
4207                                         score = 0xfff * UA_SAMP_HI(asf1d) / speed;
4208                                         if (score > hiscore) {
4209                                                 bestspeed = UA_SAMP_HI(asf1d);
4210                                                 hiscore = score;
4211                                         }
4212                                 }
4213                                 continue;
4214                         }
4215                         for (r = 0; r < asf1d->bSamFreqType; r++) {
4216                                 if (speed == UA_GETSAMP(asf1d, r)) {
4217                                         ch->sample_rate = speed;
4218                                         return speed;
4219                                 }
4220                                 if (speed > UA_GETSAMP(asf1d, r))
4221                                         score = 0xfff * UA_GETSAMP(asf1d, r) / speed;
4222                                 else
4223                                         score = 0xfff * speed / UA_GETSAMP(asf1d, r);
4224                                 if (score > hiscore) {
4225                                         bestspeed = UA_GETSAMP(asf1d, r);
4226                                         hiscore = score;
4227                                 }
4228                         }
4229         }
4230         if (bestspeed != 1) {
4231                 ch->sample_rate = bestspeed;
4232                 return bestspeed;
4233         }
4234
4235         return 0;
4236 }
4237
4238 int
4239 uaudio_chan_getptr(device_t dev, int dir)
4240 {
4241         struct uaudio_softc *sc;
4242         struct chan *ch;
4243         int ptr;
4244
4245         sc = device_get_softc(dev);
4246 #ifndef NO_RECORDING
4247         if (dir == PCMDIR_PLAY)
4248                 ch = &sc->sc_playchan;
4249         else
4250                 ch = &sc->sc_recchan;
4251 #else
4252         ch = &sc->sc_playchan;
4253 #endif
4254
4255         ptr = ch->cur - ch->start;
4256
4257         return ptr;
4258 }
4259
4260 void
4261 uaudio_chan_set_param_format(device_t dev, u_int32_t format, int dir)
4262 {
4263         struct uaudio_softc *sc;
4264         struct chan *ch;
4265
4266         sc = device_get_softc(dev);
4267 #ifndef NO_RECORDING
4268         if (dir == PCMDIR_PLAY)
4269                 ch = &sc->sc_playchan;
4270         else
4271                 ch = &sc->sc_recchan;
4272 #else
4273         ch = &sc->sc_playchan;
4274 #endif
4275
4276         ch->format = format;
4277
4278         return;
4279 }
4280
4281 int
4282 uaudio_halt_out_dma(device_t dev)
4283 {
4284         struct uaudio_softc *sc;
4285
4286         sc = device_get_softc(dev);
4287
4288         DPRINTF(("uaudio_halt_out_dma: enter\n"));
4289         if (sc->sc_playchan.pipe != NULL) {
4290                 uaudio_chan_close(sc, &sc->sc_playchan);
4291                 sc->sc_playchan.pipe = 0;
4292                 uaudio_chan_free_buffers(sc, &sc->sc_playchan);
4293         }
4294         return (0);
4295 }
4296
4297 int
4298 uaudio_halt_in_dma(device_t dev)
4299 {
4300         struct uaudio_softc *sc;
4301
4302         sc = device_get_softc(dev);
4303
4304         if (sc->sc_dying)
4305                 return (EIO);
4306
4307         DPRINTF(("uaudio_halt_in_dma: enter\n"));
4308         if (sc->sc_recchan.pipe != NULL) {
4309                 uaudio_chan_close(sc, &sc->sc_recchan);
4310                 sc->sc_recchan.pipe = NULL;
4311                 uaudio_chan_free_buffers(sc, &sc->sc_recchan);
4312 /*              sc->sc_recchan.intr = NULL; */
4313         }
4314         return (0);
4315 }
4316
4317 int
4318 uaudio_trigger_input(device_t dev)
4319 {
4320         struct uaudio_softc *sc;
4321         struct chan *ch;
4322         usbd_status err;
4323         int i, s;
4324
4325         sc = device_get_softc(dev);
4326         ch = &sc->sc_recchan;
4327
4328         if (sc->sc_dying)
4329                 return (EIO);
4330
4331 /*      uaudio_chan_set_param(ch, start, end, blksize) */
4332         if (uaudio_init_params(sc, ch, AUMODE_RECORD))
4333                 return (EIO);
4334
4335         err = uaudio_chan_alloc_buffers(sc, ch);
4336         if (err)
4337                 return (EIO);
4338
4339         err = uaudio_chan_open(sc, ch);
4340         if (err) {
4341                 uaudio_chan_free_buffers(sc, ch);
4342                 return (EIO);
4343         }
4344
4345 /*      ch->intr = intr;
4346         ch->arg = arg; */
4347
4348         s = splusb();
4349         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
4350                 uaudio_chan_rtransfer(ch);
4351         splx(s);
4352
4353         return (0);
4354 }
4355
4356 int
4357 uaudio_trigger_output(device_t dev)
4358 {
4359         struct uaudio_softc *sc;
4360         struct chan *ch;
4361         usbd_status err;
4362         int i, s;
4363
4364         sc = device_get_softc(dev);
4365         ch = &sc->sc_playchan;
4366
4367         if (sc->sc_dying)
4368                 return (EIO);
4369
4370         if (uaudio_init_params(sc, ch, AUMODE_PLAY))
4371                 return (EIO);
4372
4373         err = uaudio_chan_alloc_buffers(sc, ch);
4374         if (err)
4375                 return (EIO);
4376
4377         err = uaudio_chan_open(sc, ch);
4378         if (err) {
4379                 uaudio_chan_free_buffers(sc, ch);
4380                 return (EIO);
4381         }
4382
4383         s = splusb();
4384         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
4385                 uaudio_chan_ptransfer(ch);
4386         splx(s);
4387
4388         return (0);
4389 }
4390
4391 u_int32_t
4392 uaudio_query_mix_info(device_t dev)
4393 {
4394         int i;
4395         u_int32_t mask = 0;
4396         struct uaudio_softc *sc;
4397         struct mixerctl *mc;
4398
4399         sc = device_get_softc(dev);
4400         for (i=0; i < sc->sc_nctls; i++) {
4401                 mc = &sc->sc_ctls[i];
4402                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
4403                         /* Set device mask bits.
4404                            See /usr/include/machine/soundcard.h */
4405                         mask |= (1 << mc->ctl);
4406                 }
4407         }
4408         return mask;
4409 }
4410
4411 u_int32_t
4412 uaudio_query_recsrc_info(device_t dev)
4413 {
4414         int i, rec_selector_id;
4415         u_int32_t mask = 0;
4416         struct uaudio_softc *sc;
4417         struct mixerctl *mc;
4418
4419         sc = device_get_softc(dev);
4420         rec_selector_id = -1;
4421         for (i=0; i < sc->sc_nctls; i++) {
4422                 mc = &sc->sc_ctls[i];
4423                 if (mc->ctl == SOUND_MIXER_NRDEVICES &&
4424                     mc->type == MIX_SELECTOR && mc->class == UAC_RECORD) {
4425                         if (rec_selector_id == -1) {
4426                                 rec_selector_id = i;
4427                         } else {
4428                                 printf("There are many selectors.  Can't recognize which selector is a record source selector.\n");
4429                                 return mask;
4430                         }
4431                 }
4432         }
4433         if (rec_selector_id == -1)
4434                 return mask;
4435         mc = &sc->sc_ctls[rec_selector_id];
4436         for (i = mc->minval; i <= mc->maxval; i++) {
4437                 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
4438                         continue;
4439                 mask |= 1 << mc->slctrtype[i - 1];
4440         }
4441         return mask;
4442 }
4443
4444 void
4445 uaudio_mixer_set(device_t dev, unsigned type, unsigned left, unsigned right)
4446 {
4447         int i;
4448         struct uaudio_softc *sc;
4449         struct mixerctl *mc;
4450
4451         sc = device_get_softc(dev);
4452         for (i=0; i < sc->sc_nctls; i++) {
4453                 mc = &sc->sc_ctls[i];
4454                 if (mc->ctl == type) {
4455                         if (mc->nchan == 2) {
4456                                 /* set Right */
4457                                 uaudio_ctl_set(sc, SET_CUR, mc, 1, (int)(right*255)/100);
4458                         }
4459                         /* set Left or Mono */
4460                         uaudio_ctl_set(sc, SET_CUR, mc, 0, (int)(left*255)/100);
4461                 }
4462         }
4463         return;
4464 }
4465
4466 u_int32_t
4467 uaudio_mixer_setrecsrc(device_t dev, u_int32_t src)
4468 {
4469         int i, rec_selector_id;
4470         struct uaudio_softc *sc;
4471         struct mixerctl *mc;
4472
4473         sc = device_get_softc(dev);
4474         rec_selector_id = -1;
4475         for (i=0; i < sc->sc_nctls; i++) {
4476                 mc = &sc->sc_ctls[i];
4477                 if (mc->ctl == SOUND_MIXER_NRDEVICES &&
4478                     mc->type == MIX_SELECTOR && mc->class == UAC_RECORD) {
4479                         if (rec_selector_id == -1) {
4480                                 rec_selector_id = i;
4481                         } else {
4482                                 return src; /* Can't recognize which selector is record source selector */
4483                         }
4484                 }
4485         }
4486         if (rec_selector_id == -1)
4487                 return src;
4488         mc = &sc->sc_ctls[rec_selector_id];
4489         for (i = mc->minval; i <= mc->maxval; i++) {
4490                 if (src != (1 << mc->slctrtype[i - 1]))
4491                         continue;
4492                 uaudio_ctl_set(sc, SET_CUR, mc, 0, i);
4493                 return (1 << mc->slctrtype[i - 1]);
4494         }
4495         uaudio_ctl_set(sc, SET_CUR, mc, 0, mc->minval);
4496         return (1 << mc->slctrtype[mc->minval - 1]);
4497 }
4498
4499 static int
4500 uaudio_sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
4501 {
4502         struct snddev_info *d;
4503         struct pcm_channel *c;
4504         struct pcm_feeder *f;
4505         device_t pa_dev = device_get_parent(dev);
4506         struct uaudio_softc *sc = device_get_softc(pa_dev);
4507
4508         if (verbose < 1)
4509                 return 0;
4510
4511         d = device_get_softc(dev);
4512         if (!d)
4513                 return ENXIO;
4514
4515         PCM_BUSYASSERT(d);
4516
4517         if (CHN_EMPTY(d, channels.pcm)) {
4518                 sbuf_printf(s, " (mixer only)");
4519                 return 0;
4520         }
4521
4522         sbuf_printf(s, " (%dp:%dv/%dr:%dv channels%s%s)",
4523                         d->playcount, d->pvchancount,
4524                         d->reccount, d->rvchancount,
4525                         (d->flags & SD_F_SIMPLEX)? "" : " duplex",
4526 #ifdef USING_DEVFS
4527                         (device_get_unit(dev) == snd_unit)? " default" : ""
4528 #else
4529                         ""
4530 #endif
4531                         );
4532
4533         if (sc->uaudio_sndstat_flag != 0) {
4534                 sbuf_cat(s, sbuf_data(&(sc->uaudio_sndstat)));
4535         }
4536
4537         if (verbose <= 1)
4538                 return 0;
4539
4540         CHN_FOREACH(c, d, channels.pcm) {
4541
4542                 KASSERT(c->bufhard != NULL && c->bufsoft != NULL,
4543                         ("hosed pcm channel setup"));
4544
4545                 sbuf_printf(s, "\n\t");
4546
4547                 /* it would be better to indent child channels */
4548                 sbuf_printf(s, "%s[%s]: ", c->parentchannel? c->parentchannel->name : "", c->name);
4549                 sbuf_printf(s, "spd %d", c->speed);
4550                 if (c->speed != sndbuf_getspd(c->bufhard))
4551                         sbuf_printf(s, "/%d", sndbuf_getspd(c->bufhard));
4552                 sbuf_printf(s, ", fmt 0x%08x", c->format);
4553                 if (c->format != sndbuf_getfmt(c->bufhard))
4554                         sbuf_printf(s, "/0x%08x", sndbuf_getfmt(c->bufhard));
4555                 sbuf_printf(s, ", flags 0x%08x, 0x%08x", c->flags, c->feederflags);
4556                 if (c->pid != -1)
4557                         sbuf_printf(s, ", pid %d", c->pid);
4558                 sbuf_printf(s, "\n\t");
4559
4560                 sbuf_printf(s, "interrupts %d, ", c->interrupts);
4561                 if (c->direction == PCMDIR_REC)
4562                         sbuf_printf(s, "overruns %d, feed %u, hfree %d, sfree %d [b:%d/%d/%d|bs:%d/%d/%d]",
4563                             c->xruns, c->feedcount, sndbuf_getfree(c->bufhard), sndbuf_getfree(c->bufsoft),
4564                             sndbuf_getsize(c->bufhard), sndbuf_getblksz(c->bufhard),
4565                             sndbuf_getblkcnt(c->bufhard),
4566                             sndbuf_getsize(c->bufsoft), sndbuf_getblksz(c->bufsoft),
4567                             sndbuf_getblkcnt(c->bufsoft));
4568                 else
4569                         sbuf_printf(s, "underruns %d, feed %u, ready %d [b:%d/%d/%d|bs:%d/%d/%d]",
4570                             c->xruns, c->feedcount, sndbuf_getready(c->bufsoft),
4571                             sndbuf_getsize(c->bufhard), sndbuf_getblksz(c->bufhard),
4572                             sndbuf_getblkcnt(c->bufhard),
4573                             sndbuf_getsize(c->bufsoft), sndbuf_getblksz(c->bufsoft),
4574                             sndbuf_getblkcnt(c->bufsoft));
4575                 sbuf_printf(s, "\n\t");
4576
4577                 sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "hardware" : "userland");
4578                 sbuf_printf(s, " -> ");
4579                 f = c->feeder;
4580                 while (f->source != NULL)
4581                         f = f->source;
4582                 while (f != NULL) {
4583                         sbuf_printf(s, "%s", f->class->name);
4584                         if (f->desc->type == FEEDER_FMT)
4585                                 sbuf_printf(s, "(0x%08x -> 0x%08x)", f->desc->in, f->desc->out);
4586                         if (f->desc->type == FEEDER_RATE)
4587                                 sbuf_printf(s, "(%d -> %d)", FEEDER_GET(f, FEEDRATE_SRC), FEEDER_GET(f, FEEDRATE_DST));
4588                         if (f->desc->type == FEEDER_ROOT || f->desc->type == FEEDER_MIXER ||
4589                                         f->desc->type == FEEDER_VOLUME)
4590                                 sbuf_printf(s, "(0x%08x)", f->desc->out);
4591                         sbuf_printf(s, " -> ");
4592                         f = f->parent;
4593                 }
4594                 sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "userland" : "hardware");
4595         }
4596
4597         return 0;
4598 }
4599
4600 void
4601 uaudio_sndstat_register(device_t dev)
4602 {
4603         struct snddev_info *d = device_get_softc(dev);
4604         sndstat_register(dev, d->status, uaudio_sndstat_prepare_pcm);
4605 }
4606
4607 int
4608 uaudio_get_vendor(device_t dev)
4609 {
4610         struct uaudio_softc *sc = device_get_softc(dev);
4611
4612         if (sc == NULL)
4613                 return 0;
4614
4615         return sc->sc_vendor;
4616 }
4617
4618 int
4619 uaudio_get_product(device_t dev)
4620 {
4621         struct uaudio_softc *sc = device_get_softc(dev);
4622
4623         if (sc == NULL)
4624                 return 0;
4625
4626         return sc->sc_product;
4627 }
4628
4629 int
4630 uaudio_get_release(device_t dev)
4631 {
4632         struct uaudio_softc *sc = device_get_softc(dev);
4633
4634         if (sc == NULL)
4635                 return 0;
4636
4637         return sc->sc_release;
4638 }
4639
4640 static int
4641 audio_attach_mi(device_t dev)
4642 {
4643         device_t child;
4644         struct sndcard_func *func;
4645
4646         /* Attach the children. */
4647         /* PCM Audio */
4648         func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
4649         if (func == NULL)
4650                 return (ENOMEM);
4651         func->func = SCF_PCM;
4652         child = device_add_child(dev, "pcm", -1);
4653         device_set_ivars(child, func);
4654
4655         bus_generic_attach(dev);
4656
4657         return 0; /* XXXXX */
4658 }
4659
4660 DRIVER_MODULE(uaudio, uhub, uaudio_driver, uaudio_devclass, usbd_driver_load, 0);
4661 MODULE_VERSION(uaudio, 1);
4662
4663 #endif