summaryrefslogtreecommitdiff
path: root/sys/dev/usb
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev/usb')
-rw-r--r--sys/dev/usb/uaudio.c2239
-rw-r--r--sys/dev/usb/uaudioreg.h278
2 files changed, 2517 insertions, 0 deletions
diff --git a/sys/dev/usb/uaudio.c b/sys/dev/usb/uaudio.c
new file mode 100644
index 00000000000..2c186819ca1
--- /dev/null
+++ b/sys/dev/usb/uaudio.c
@@ -0,0 +1,2239 @@
+/* $OpenBSD: uaudio.c,v 1.1 1999/11/11 15:54:59 ho Exp $ */
+/* $NetBSD: uaudio.c,v 1.5 1999/10/25 10:16:49 augustss Exp $ */
+
+/*
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Lennart Augustsson (augustss@carlstedt.se) at
+ * Carlstedt Research & Technology.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * USB audio specs: http://www.teleport.com/~usb/data/Audio10.pdf
+ * http://www.teleport.com/~usb/data/Frmts10.pdf
+ * http://www.teleport.com/~usb/data/Termt10.pdf
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/device.h>
+#include <sys/ioctl.h>
+#include <sys/tty.h>
+#include <sys/file.h>
+#include <sys/select.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+#include <sys/device.h>
+#include <sys/poll.h>
+
+#include <sys/audioio.h>
+#include <dev/audio_if.h>
+#include <dev/mulaw.h>
+#include <dev/auconv.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include <dev/usb/usb_quirks.h>
+
+#include <dev/usb/uaudioreg.h>
+
+#ifdef UAUDIO_DEBUG
+#define DPRINTF(x) if (uaudiodebug) printf x
+#define DPRINTFN(n,x) if (uaudiodebug>(n)) printf x
+int uaudiodebug = 0;
+#else
+#define DPRINTF(x)
+#define DPRINTFN(n,x)
+#endif
+
+#define UAUDIO_NCHANBUFS 5 /* number of outstanding request */
+#define UAUDIO_NFRAMES 20 /* ms of sound in each request */
+
+
+#define MIX_MAX_CHAN 8
+struct mixerctl {
+ u_int16_t wValue[MIX_MAX_CHAN]; /* using nchan */
+ u_int16_t wIndex;
+ u_int8_t nchan;
+ u_int8_t type;
+#define MIX_ON_OFF 1
+#define MIX_SIGNED_16 2
+#define MIX_UNSIGNED_16 3
+#define MIX_SIGNED_8 4
+#define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1)
+#define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
+ int minval, maxval;
+ u_int8_t class;
+ char ctlname[MAX_AUDIO_DEV_LEN];
+ char *ctlunit;
+};
+#define MAKE(h,l) (((h) << 8) | (l))
+
+struct as_info {
+ u_int8_t alt;
+ u_int8_t encoding;
+ usb_interface_descriptor_t *idesc;
+ usb_endpoint_descriptor_audio_t *edesc;
+ struct usb_audio_streaming_type1_descriptor *asf1desc;
+};
+
+struct chan {
+ int terminal; /* terminal id */
+ void (*intr) __P((void *)); /* dma completion intr handler */
+ void *arg; /* arg for intr() */
+ usbd_pipe_handle pipe;
+ int dir; /* direction, UE_DIR_XXX */
+
+ u_int sample_size;
+ u_int sample_rate;
+ u_int bytes_per_frame;
+ u_int fraction; /* fraction/1000 is the extra samples/frame */
+ u_int residue; /* accumulates the fractional samples */
+
+ u_char *start; /* upper layer buffer start */
+ u_char *end; /* upper layer buffer end */
+ u_char *cur; /* current position in upper layer buffer */
+ int blksize; /* chunk size to report up */
+ int transferred; /* transferred bytes not reported up */
+
+ int curchanbuf;
+ struct chanbuf {
+ struct chan *chan;
+ usbd_request_handle reqh;
+ u_char *buffer;
+ u_int16_t sizes[UAUDIO_NFRAMES];
+ u_int16_t size;
+ } chanbufs[UAUDIO_NCHANBUFS];
+};
+
+struct uaudio_softc {
+ USBBASEDEVICE sc_dev; /* base device */
+ usbd_device_handle sc_udev; /* USB device */
+
+ int sc_ac_iface; /* Audio Control interface */
+ int sc_as_iface; /* Audio Streaming interface */
+ usbd_interface_handle sc_ac_ifaceh;
+ usbd_interface_handle sc_as_ifaceh;
+
+ struct chan sc_chan;
+
+ int sc_curaltidx;
+
+ int sc_nullalt;
+
+ struct as_info *sc_alts;
+ int sc_nalts;
+ int sc_props;
+
+ int sc_altflags;
+#define HAS_8 0x01
+#define HAS_16 0x02
+#define HAS_8U 0x04
+#define HAS_ALAW 0x08
+#define HAS_MULAW 0x10
+
+ struct mixerctl *sc_ctls;
+ int sc_nctls;
+
+ device_ptr_t sc_audiodev;
+ char sc_dying;
+};
+
+#define UAC_OUTPUT 0
+#define UAC_INPUT 1
+#define UAC_EQUAL 2
+
+usbd_status uaudio_identify_ac __P((struct uaudio_softc *sc,
+ usb_config_descriptor_t *cdesc));
+usbd_status uaudio_identify_as __P((struct uaudio_softc *sc,
+ usb_config_descriptor_t *cdesc));
+usbd_status uaudio_process_as __P((struct uaudio_softc *sc, char *buf,
+ int *offsp, int size,
+ usb_interface_descriptor_t *id));
+
+void uaudio_add_alt __P((struct uaudio_softc *sc, struct as_info *ai));
+
+usb_interface_descriptor_t *uaudio_find_iface
+ __P((char *buf, int size, int *offsp, int subtype));
+
+void uaudio_mixer_add_ctl __P((struct uaudio_softc *sc, struct mixerctl *mp));
+char *uaudio_id_name __P((struct uaudio_softc *sc, usb_descriptor_t **dps,
+ int id));
+struct usb_audio_cluster uaudio_get_cluster __P((int id,
+ usb_descriptor_t **dps));
+void uaudio_add_input __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+void uaudio_add_output __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+void uaudio_add_mixer __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+void uaudio_add_selector __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+void uaudio_add_feature __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+void uaudio_add_processing __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+void uaudio_add_extension __P((struct uaudio_softc *sc, usb_descriptor_t *v,
+ usb_descriptor_t **dps));
+usbd_status uaudio_identify __P((struct uaudio_softc *sc,
+ usb_config_descriptor_t *cdesc));
+
+int uaudio_signext __P((int type, int val));
+int uaudio_value2bsd __P((struct mixerctl *mc, int val));
+int uaudio_bsd2value __P((struct mixerctl *mc, int val));
+int uaudio_get __P((struct uaudio_softc *sc, int type, int which, int wValue,
+ int wIndex, int len));
+int uaudio_ctl_get __P((struct uaudio_softc *sc, int which,
+ struct mixerctl *mc, int chan));
+void uaudio_set __P((struct uaudio_softc *sc, int type, int which, int wValue,
+ int wIndex, int len, int val));
+void uaudio_ctl_set __P((struct uaudio_softc *sc, int which,
+ struct mixerctl *mc, int chan, int val));
+
+usbd_status uaudio_set_speed __P((struct uaudio_softc *, int, u_int));
+
+usbd_status uaudio_chan_open __P((struct uaudio_softc *sc, struct chan *ch));
+void uaudio_chan_close __P((struct uaudio_softc *sc, struct chan *ch));
+usbd_status uaudio_chan_alloc_buffers __P((struct uaudio_softc *, struct chan *));
+void uaudio_chan_free_buffers __P((struct uaudio_softc *, struct chan *));
+void uaudio_chan_set_param __P((struct chan *ch, struct audio_params *param,
+ u_char *start, u_char *end, int blksize));
+void uaudio_chan_ptransfer __P((struct chan *ch));
+void uaudio_chan_pintr __P((usbd_request_handle reqh,
+ usbd_private_handle priv, usbd_status status));
+
+void uaudio_chan_rtransfer __P((struct chan *ch));
+void uaudio_chan_rintr __P((usbd_request_handle reqh,
+ usbd_private_handle priv, usbd_status status));
+
+
+
+int uaudio_open __P((void *, int));
+void uaudio_close __P((void *));
+int uaudio_drain __P((void *));
+int uaudio_query_encoding __P((void *, struct audio_encoding *));
+int uaudio_set_params __P((void *, int, int,
+ struct audio_params *, struct audio_params *));
+int uaudio_round_blocksize __P((void *, int));
+int uaudio_trigger_output __P((void *, void *, void *, int,
+ void (*)(void *), void *,
+ struct audio_params *));
+int uaudio_trigger_input __P((void *, void *, void *, int,
+ void (*)(void *), void *,
+ struct audio_params *));
+int uaudio_halt_in_dma __P((void *));
+int uaudio_halt_out_dma __P((void *));
+int uaudio_getdev __P((void *, struct audio_device *));
+int uaudio_mixer_set_port __P((void *, mixer_ctrl_t *));
+int uaudio_mixer_get_port __P((void *, mixer_ctrl_t *));
+int uaudio_query_devinfo __P((void *, mixer_devinfo_t *));
+int uaudio_get_props __P((void *));
+
+struct audio_hw_if uaudio_hw_if = {
+ uaudio_open,
+ uaudio_close,
+ uaudio_drain,
+ uaudio_query_encoding,
+ uaudio_set_params,
+ uaudio_round_blocksize,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ uaudio_halt_out_dma,
+ uaudio_halt_in_dma,
+ NULL,
+ uaudio_getdev,
+ NULL,
+ uaudio_mixer_set_port,
+ uaudio_mixer_get_port,
+ uaudio_query_devinfo,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ uaudio_get_props,
+ uaudio_trigger_output,
+ uaudio_trigger_input,
+};
+
+struct audio_device uaudio_device = {
+ "USB audio",
+ "",
+ "uaudio"
+};
+
+USB_DECLARE_DRIVER(uaudio);
+
+USB_MATCH(uaudio)
+{
+ USB_MATCH_START(uaudio, uaa);
+ usb_interface_descriptor_t *id;
+
+ if (!uaa->iface)
+ return (UMATCH_NONE);
+
+ id = usbd_get_interface_descriptor(uaa->iface);
+ /* Trigger on the control interface. */
+ if (!id ||
+ id->bInterfaceClass != UCLASS_AUDIO ||
+ id->bInterfaceSubClass != USUBCLASS_AUDIOCONTROL)
+ return (UMATCH_NONE);
+
+ return (UMATCH_IFACECLASS_IFACESUBCLASS);
+}
+
+USB_ATTACH(uaudio)
+{
+ USB_ATTACH_START(uaudio, sc, uaa);
+ usb_interface_descriptor_t *id;
+ usb_config_descriptor_t *cdesc;
+ char devinfo[1024];
+ usbd_status r;
+ int i;
+
+ usbd_devinfo(uaa->device, 0, devinfo);
+ printf(": %s\n", devinfo);
+
+ sc->sc_udev = uaa->device;
+
+ cdesc = usbd_get_config_descriptor(sc->sc_udev);
+ if (!cdesc)
+ USB_ATTACH_ERROR_RETURN;
+
+ r = uaudio_identify(sc, cdesc);
+ if (r != USBD_NORMAL_COMPLETION) {
+ printf("%s: audio descriptors make no sense, error=%d\n",
+ USBDEVNAME(sc->sc_dev), r);
+ USB_ATTACH_ERROR_RETURN;
+ }
+
+ sc->sc_ac_ifaceh = uaa->iface;
+ /* Pick up the AS interface. */
+ for (i = 0; i < uaa->nifaces; i++) {
+ if (uaa->ifaces[i]) {
+ id = usbd_get_interface_descriptor(uaa->ifaces[i]);
+ if (id->bInterfaceNumber == sc->sc_as_iface) {
+ sc->sc_as_ifaceh = uaa->ifaces[i];
+ uaa->ifaces[i] = 0;
+ }
+ }
+ }
+
+ if (!sc->sc_as_ifaceh) {
+ printf("%s: missing AS interface(s)\n",USBDEVNAME(sc->sc_dev));
+ USB_ATTACH_ERROR_RETURN;
+ }
+
+ DPRINTF(("uaudio_attach: doing audio_attach_mi\n"));
+ /* sc->sc_audiodev = */ audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
+
+ USB_ATTACH_SUCCESS_RETURN;
+}
+
+int
+uaudio_activate(self, act)
+ device_ptr_t self;
+ enum devact act;
+{
+ struct uaudio_softc *sc = (struct uaudio_softc *)self;
+ int rv = 0;
+
+ switch (act) {
+ case DVACT_ACTIVATE:
+ return (EOPNOTSUPP);
+ break;
+
+ case DVACT_DEACTIVATE:
+ if (sc->sc_audiodev)
+ rv = config_deactivate(sc->sc_audiodev);
+ sc->sc_dying = 1;
+ break;
+ }
+ return (rv);
+}
+
+int
+uaudio_detach(self, flags)
+ device_ptr_t self;
+ int flags;
+{
+ struct uaudio_softc *sc = (struct uaudio_softc *)self;
+ int rv = 0;
+
+ if (sc->sc_audiodev)
+ rv = config_detach(sc->sc_audiodev, flags);
+
+ return (rv);
+}
+
+int
+uaudio_query_encoding(addr, fp)
+ void *addr;
+ struct audio_encoding *fp;
+{
+ struct uaudio_softc *sc = addr;
+ int flags = sc->sc_altflags;
+ int idx;
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ if (sc->sc_nalts == 0 || flags == 0)
+ return (ENXIO);
+
+ idx = fp->index;
+ switch (idx) {
+ case 0:
+ strcpy(fp->name, AudioEulinear);
+ fp->encoding = AUDIO_ENCODING_ULINEAR;
+ fp->precision = 8;
+ fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 1:
+ strcpy(fp->name, AudioEmulaw);
+ fp->encoding = AUDIO_ENCODING_ULAW;
+ fp->precision = 8;
+ fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 2:
+ strcpy(fp->name, AudioEalaw);
+ fp->encoding = AUDIO_ENCODING_ALAW;
+ fp->precision = 8;
+ fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 3:
+ strcpy(fp->name, AudioEslinear);
+ fp->encoding = AUDIO_ENCODING_SLINEAR;
+ fp->precision = 8;
+ fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 4:
+ strcpy(fp->name, AudioEslinear_le);
+ fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
+ fp->precision = 16;
+ fp->flags = 0;
+ return (0);
+ case 5:
+ strcpy(fp->name, AudioEulinear_le);
+ fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
+ fp->precision = 16;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 6:
+ strcpy(fp->name, AudioEslinear_be);
+ fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
+ fp->precision = 16;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 7:
+ strcpy(fp->name, AudioEulinear_be);
+ fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
+ fp->precision = 16;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ default:
+ return (EINVAL);
+ }
+}
+
+usb_interface_descriptor_t *
+uaudio_find_iface(buf, size, offsp, subtype)
+ char *buf;
+ int size;
+ int *offsp;
+ int subtype;
+{
+ usb_interface_descriptor_t *d;
+
+ while (*offsp < size) {
+ d = (void *)(buf + *offsp);
+ *offsp += d->bLength;
+ if (d->bDescriptorType == UDESC_INTERFACE &&
+ d->bInterfaceClass == UCLASS_AUDIO &&
+ d->bInterfaceSubClass == subtype)
+ return (d);
+ }
+ return (0);
+}
+
+void
+uaudio_mixer_add_ctl(sc, mc)
+ struct uaudio_softc *sc;
+ struct mixerctl *mc;
+{
+ if (sc->sc_nctls == 0)
+ sc->sc_ctls = malloc(sizeof *mc, M_USBDEV, M_NOWAIT);
+ else
+#ifdef __OpenBSD__
+ {
+ void *p;
+
+ p = malloc((sc->sc_nctls+1) * sizeof *mc, M_USBDEV, M_NOWAIT);
+ if (p != NULL)
+ bcopy(sc->sc_ctls, p, sc->sc_nctls * sizeof *mc);
+ free(sc->sc_ctls, M_USBDEV);
+ sc->sc_ctls = p;
+ }
+#else
+ sc->sc_ctls = realloc(sc->sc_ctls,
+ (sc->sc_nctls+1) * sizeof *mc,
+ M_USBDEV, M_NOWAIT);
+#endif
+ if (sc->sc_ctls == 0) {
+ printf("uaudio_mixer_add_ctl: no memory\n");
+ return;
+ }
+
+ if (mc->type != MIX_ON_OFF) {
+ /* Determine min and max values. */
+ mc->minval = uaudio_signext(mc->type,
+ uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE,
+ mc->wValue[0], mc->wIndex,
+ MIX_SIZE(mc->type)));
+ mc->maxval = 1 + uaudio_signext(mc->type,
+ uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE,
+ mc->wValue[0], mc->wIndex,
+ MIX_SIZE(mc->type)));
+ } else {
+ mc->minval = 0;
+ mc->maxval = 1;
+ }
+
+ sc->sc_ctls[sc->sc_nctls++] = *mc;
+
+#ifdef UAUDIO_DEBUG
+ if (uaudiodebug > 2) {
+ int i;
+ DPRINTF(("uaudio_mixer_add_ctl: wValue=%04x",mc->wValue[0]));
+ for (i = 1; i < mc->nchan; i++)
+ DPRINTF((",%04x", mc->wValue[i]));
+ DPRINTF((" wIndex=%04x type=%d name='%s' unit='%s' "
+ "min=%d max=%d\n",
+ mc->wIndex, mc->type, mc->ctlname, mc->ctlunit,
+ mc->minval, mc->maxval));
+ }
+#endif
+}
+
+char *
+uaudio_id_name(sc, dps, id)
+ struct uaudio_softc *sc;
+ usb_descriptor_t **dps;
+ int id;
+{
+ static char buf[32];
+ sprintf(buf, "i%d", id);
+ return (buf);
+}
+
+struct usb_audio_cluster
+uaudio_get_cluster(id, dps)
+ int id;
+ usb_descriptor_t **dps;
+{
+ struct usb_audio_cluster r;
+ usb_descriptor_t *dp;
+ int i;
+
+ for (i = 0; i < 25; i++) { /* avoid infinite loops */
+ dp = dps[id];
+ if (dp == 0)
+ goto bad;
+ switch (dp->bDescriptorSubtype) {
+ case UDESCSUB_AC_INPUT:
+#define p ((struct usb_audio_input_terminal *)dp)
+ r.bNrChannels = p->bNrChannels;
+ USETW(r.wChannelConfig, UGETW(p->wChannelConfig));
+ r.iChannelNames = p->iChannelNames;
+#undef p
+ return (r);
+ case UDESCSUB_AC_OUTPUT:
+#define p ((struct usb_audio_output_terminal *)dp)
+ id = p->bSourceId;
+#undef p
+ break;
+ case UDESCSUB_AC_MIXER:
+#define p ((struct usb_audio_mixer_unit *)dp)
+ r = *(struct usb_audio_cluster *)
+ &p->baSourceId[p->bNrInPins];
+#undef p
+ return (r);
+ case UDESCSUB_AC_SELECTOR:
+ /* XXX This is not really right */
+#define p ((struct usb_audio_selector_unit *)dp)
+ id = p->baSourceId[0];
+#undef p
+ break;
+ case UDESCSUB_AC_FEATURE:
+#define p ((struct usb_audio_feature_unit *)dp)
+ id = p->bSourceId;
+#undef p
+ break;
+ case UDESCSUB_AC_PROCESSING:
+#define p ((struct usb_audio_processing_unit *)dp)
+ r = *(struct usb_audio_cluster *)
+ &p->baSourceId[p->bNrInPins];
+#undef p
+ return (r);
+ case UDESCSUB_AC_EXTENSION:
+#define p ((struct usb_audio_extension_unit *)dp)
+ r = *(struct usb_audio_cluster *)
+ &p->baSourceId[p->bNrInPins];
+#undef p
+ return (r);
+ default:
+ goto bad;
+ }
+ }
+ bad:
+ printf("uaudio_get_cluster: bad data\n");
+ memset(&r, 0, sizeof r);
+ return r;
+
+}
+
+void
+uaudio_add_input(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+#ifdef UAUDIO_DEBUG
+ struct usb_audio_input_terminal *d =
+ (struct usb_audio_input_terminal *)v;
+
+ DPRINTFN(2,("uaudio_add_input: bTerminalId=%d wTerminalType=0x%04x "
+ "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d "
+ "iChannelNames=%d iTerminal=%d\n",
+ d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
+ d->bNrChannels, UGETW(d->wChannelConfig),
+ d->iChannelNames, d->iTerminal));
+#endif
+ printf("uaudio_add_input: not implemented\n");
+}
+
+void
+uaudio_add_output(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+#ifdef UAUDIO_DEBUG
+ struct usb_audio_output_terminal *d =
+ (struct usb_audio_output_terminal *)v;
+
+ DPRINTFN(2,("uaudio_add_output: bTerminalId=%d wTerminalType=0x%04x "
+ "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n",
+ d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
+ d->bSourceId, d->iTerminal));
+#endif
+}
+
+void
+uaudio_add_mixer(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+ struct usb_audio_mixer_unit *d = (struct usb_audio_mixer_unit *)v;
+ struct usb_audio_mixer_unit_1 *d1;
+ int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k;
+ uByte *bm;
+ struct mixerctl mix;
+
+ DPRINTFN(2,("uaudio_add_mixer: bUnitId=%d bNrInPins=%d\n",
+ d->bUnitId, d->bNrInPins));
+
+ /* Compute the number of input channels */
+ ichs = 0;
+ for (i = 0; i < d->bNrInPins; i++)
+ ichs += uaudio_get_cluster(d->baSourceId[i], dps).bNrChannels;
+
+ /* and the number of output channels */
+ d1 = (struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins];
+ ochs = d1->bNrChannels;
+ DPRINTFN(2,("uaudio_add_mixer: ichs=%d ochs=%d\n", ichs, ochs));
+
+ bm = d1->bmControls;
+ mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
+ mix.class = -1;
+ mix.type = MIX_SIGNED_16;
+ mix.ctlunit = AudioNvolume;
+#define BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1)
+ for (p = i = 0; i < d->bNrInPins; i++) {
+ chs = uaudio_get_cluster(d->baSourceId[i], dps).bNrChannels;
+ mc = 0;
+ for (c = 0; c < chs; c++) {
+ mo = 0;
+ for (o = 0; o < ochs; o++) {
+ bno = (p + c) * ochs + o;
+ if (BIT(bno))
+ mo++;
+ }
+ if (mo == 1)
+ mc++;
+ }
+ if (mc == chs && chs <= MIX_MAX_CHAN) {
+ k = 0;
+ for (c = 0; c < chs; c++)
+ for (o = 0; o < ochs; o++) {
+ bno = (p + c) * ochs + o;
+ if (BIT(bno))
+ mix.wValue[k++] =
+ MAKE(p+c+1, o+1);
+ }
+ sprintf(mix.ctlname, "mix%d-%s", d->bUnitId,
+ uaudio_id_name(sc, dps, d->baSourceId[i]));
+ mix.nchan = chs;
+ uaudio_mixer_add_ctl(sc, &mix);
+ } else {
+ /* XXX */
+ }
+#undef BIT
+ p += chs;
+ }
+
+}
+
+void
+uaudio_add_selector(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+#ifdef UAUDIO_DEBUG
+ struct usb_audio_selector_unit *d =
+ (struct usb_audio_selector_unit *)v;
+
+ DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n",
+ d->bUnitId, d->bNrInPins));
+#endif
+ printf("uaudio_add_selector: NOT IMPLEMENTED\n");
+}
+
+void
+uaudio_add_feature(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+ struct usb_audio_feature_unit *d = (struct usb_audio_feature_unit *)v;
+ uByte *ctls = d->bmaControls;
+ int ctlsize = d->bControlSize;
+ int nchan = (d->bLength - 7) / ctlsize;
+ int srcId = d->bSourceId;
+ u_int fumask, mmask, cmask;
+ struct mixerctl mix;
+ int chan, ctl, i, unit;
+
+#define GET(i) (ctls[(i)*ctlsize] | \
+ (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0))
+
+ mmask = GET(0);
+ /* Figure out what we can control */
+ for (cmask = 0, chan = 1; chan < nchan; chan++) {
+ DPRINTFN(9,("uaudio_add_feature: chan=%d mask=%x\n",
+ chan, GET(chan)));
+ cmask |= GET(chan);
+ }
+
+ DPRINTFN(1,("uaudio_add_feature: bUnitId=%d bSourceId=%d, "
+ "%d channels, mmask=0x%04x, cmask=0x%04x\n",
+ d->bUnitId, srcId, nchan, mmask, cmask));
+
+ if (nchan > MIX_MAX_CHAN)
+ nchan = MIX_MAX_CHAN;
+ unit = d->bUnitId;
+ mix.wIndex = MAKE(unit, sc->sc_ac_iface);
+ for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) {
+ fumask = FU_MASK(ctl);
+ DPRINTFN(4,("uaudio_add_feature: ctl=%d fumask=0x%04x\n",
+ ctl, fumask));
+ if (mmask & fumask) {
+ mix.nchan = 1;
+ mix.wValue[0] = MAKE(ctl, 0);
+ } else if (cmask & fumask) {
+ mix.nchan = nchan - 1;
+ for (i = 1; i < nchan; i++) {
+ if (GET(i) & fumask)
+ mix.wValue[i-1] = MAKE(ctl, i);
+ else
+ mix.wValue[i-1] = -1;
+ }
+ } else {
+ continue;
+ }
+#undef GET
+ mix.class = -1; /* XXX */
+ switch (ctl) {
+ case MUTE_CONTROL:
+ mix.type = MIX_ON_OFF;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNmute);
+ mix.ctlunit = "";
+ break;
+ case VOLUME_CONTROL:
+ mix.type = MIX_SIGNED_16;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNmaster);
+ mix.ctlunit = AudioNvolume;
+ break;
+ case BASS_CONTROL:
+ mix.type = MIX_SIGNED_8;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNbass);
+ mix.ctlunit = AudioNbass;
+ break;
+ case MID_CONTROL:
+ mix.type = MIX_SIGNED_8;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNmid);
+ mix.ctlunit = AudioNmid;
+ break;
+ case TREBLE_CONTROL:
+ mix.type = MIX_SIGNED_8;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNtreble);
+ mix.ctlunit = AudioNtreble;
+ break;
+ case GRAPHIC_EQUALIZER_CONTROL:
+ continue; /* don't add anything */
+ break;
+ case AGC_CONTROL:
+ mix.type = MIX_ON_OFF;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNagc);
+ mix.ctlunit = "";
+ break;
+ case DELAY_CONTROL:
+ mix.type = MIX_UNSIGNED_16;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNdelay);
+ mix.ctlunit = "4 ms";
+ break;
+ case BASS_BOOST_CONTROL:
+ mix.type = MIX_ON_OFF;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNbassboost);
+ mix.ctlunit = "";
+ break;
+ case LOUDNESS_CONTROL:
+ mix.type = MIX_ON_OFF;
+ sprintf(mix.ctlname, "fea%d-%s-%s", unit,
+ uaudio_id_name(sc, dps, srcId),
+ AudioNloudness);
+ mix.ctlunit = "";
+ break;
+ }
+ uaudio_mixer_add_ctl(sc, &mix);
+ }
+}
+
+void
+uaudio_add_processing(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+#ifdef UAUDIO_DEBUG
+ struct usb_audio_processing_unit *d =
+ (struct usb_audio_processing_unit *)v;
+
+ DPRINTFN(2,("uaudio_add_processing: bUnitId=%d bNrInPins=%d\n",
+ d->bUnitId, d->bNrInPins));
+ printf("uaudio_add_processing: NOT IMPLEMENTED\n");
+#endif
+}
+
+void
+uaudio_add_extension(sc, v, dps)
+ struct uaudio_softc *sc;
+ usb_descriptor_t *v;
+ usb_descriptor_t **dps;
+{
+ struct usb_audio_extension_unit *d =
+ (struct usb_audio_extension_unit *)v;
+ struct usb_audio_extension_unit_1 *d1 =
+ (struct usb_audio_extension_unit_1 *)&d->baSourceId[d->bNrInPins];
+ struct mixerctl mix;
+
+ DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n",
+ d->bUnitId, d->bNrInPins));
+
+ if (d1->bmControls[0] & (1 << UA_EXT_ENABLE)) {
+ mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
+ mix.nchan = 1;
+ mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0);
+ mix.class = -1;
+ mix.type = MIX_ON_OFF;
+ mix.ctlunit = "";
+ sprintf(mix.ctlname, "ext%d-enable", d->bUnitId);
+ uaudio_mixer_add_ctl(sc, &mix);
+ }
+}
+
+usbd_status
+uaudio_identify(sc, cdesc)
+ struct uaudio_softc *sc;
+ usb_config_descriptor_t *cdesc;
+{
+ usbd_status r;
+
+ r = uaudio_identify_ac(sc, cdesc);
+ if (r != USBD_NORMAL_COMPLETION)
+ return (r);
+ return (uaudio_identify_as(sc, cdesc));
+}
+
+void
+uaudio_add_alt(sc, ai)
+ struct uaudio_softc *sc;
+ struct as_info *ai;
+{
+ if (sc->sc_nalts == 0)
+ sc->sc_alts = malloc(sizeof *ai, M_USBDEV, M_NOWAIT);
+ else
+#ifdef __OpenBSD__
+ {
+ void *p;
+
+ p = malloc((sc->sc_nalts+1) * sizeof *ai, M_USBDEV, M_NOWAIT);
+ if (p != NULL)
+ bcopy(sc->sc_alts, p, sc->sc_nalts * sizeof *ai);
+ free(sc->sc_alts, M_USBDEV);
+ sc->sc_alts = p;
+ }
+#else
+ sc->sc_alts = realloc(sc->sc_alts,
+ (sc->sc_nalts+1) * sizeof *ai,
+ M_USBDEV, M_NOWAIT);
+#endif
+ if (sc->sc_alts == 0) {
+ printf("uaudio_add_alt: no memory\n");
+ return;
+ }
+ DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n",
+ ai->alt, ai->encoding));
+ sc->sc_alts[sc->sc_nalts++] = *ai;
+}
+
+usbd_status
+uaudio_process_as(sc, buf, offsp, size, id)
+ struct uaudio_softc *sc;
+ char *buf;
+ int *offsp;
+#define offs (*offsp)
+ int size;
+ usb_interface_descriptor_t *id;
+{
+ struct usb_audio_streaming_interface_descriptor *asid;
+ struct usb_audio_streaming_type1_descriptor *asf1d;
+ usb_endpoint_descriptor_audio_t *ed;
+ struct usb_audio_streaming_endpoint_descriptor *sed;
+ int format, chan, prec, enc;
+ int dir, type;
+ struct as_info ai;
+
+ asid = (void *)(buf + offs);
+ if (asid->bDescriptorType != UDESC_CS_INTERFACE ||
+ asid->bDescriptorSubtype != AS_GENERAL)
+ return (USBD_INVAL);
+ offs += asid->bLength;
+ if (offs > size)
+ return (USBD_INVAL);
+ asf1d = (void *)(buf + offs);
+ if (asf1d->bDescriptorType != UDESC_CS_INTERFACE ||
+ asf1d->bDescriptorSubtype != FORMAT_TYPE)
+ return (USBD_INVAL);
+ offs += asf1d->bLength;
+ if (offs > size)
+ return (USBD_INVAL);
+
+ if (asf1d->bFormatType != FORMAT_TYPE_I) {
+ printf("%s: ignored setting with type %d format\n",
+ USBDEVNAME(sc->sc_dev), UGETW(asid->wFormatTag));
+ return (USBD_NORMAL_COMPLETION);
+ }
+
+ ed = (void *)(buf + offs);
+ if (ed->bDescriptorType != UDESC_ENDPOINT)
+ return (USBD_INVAL);
+ DPRINTF(("uaudio_process_as: endpoint bLength=%d bDescriptorType=%d "
+ "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d "
+ "bInterval=%d bRefresh=%d bSynchAddress=%d\n",
+ ed->bLength, ed->bDescriptorType, ed->bEndpointAddress,
+ ed->bmAttributes, UGETW(ed->wMaxPacketSize),
+ ed->bInterval, ed->bRefresh, ed->bSynchAddress));
+ offs += ed->bLength;
+ if (offs > size)
+ return (USBD_INVAL);
+ if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS)
+ return (USBD_INVAL);
+
+ dir = UE_GET_DIR(ed->bEndpointAddress);
+ type = UE_GET_ISO_TYPE(ed->bmAttributes);
+ /* We can't handle endpoints that need a sync pipe. */
+ if (dir == UE_DIR_IN ? type == UE_ISO_ADAPT : type == UE_ISO_ASYNC) {
+ printf("%s: ignored %sput endpoint of type 0x%x\n",
+ USBDEVNAME(sc->sc_dev),
+ dir == UE_DIR_IN ? "in" : "out",
+ ed->bmAttributes & UE_ISO_TYPE);
+ return (USBD_NORMAL_COMPLETION);
+ }
+
+ sed = (void *)(buf + offs);
+ if (sed->bDescriptorType != UDESC_CS_ENDPOINT ||
+ sed->bDescriptorSubtype != AS_GENERAL)
+ return (USBD_INVAL);
+ offs += sed->bLength;
+ if (offs > size)
+ return (USBD_INVAL);
+
+ format = UGETW(asid->wFormatTag);
+ chan = asf1d->bNrChannels;
+ prec = asf1d->bBitResolution;
+ if (prec != 8 && prec != 16) {
+#ifdef AUDIO_DEBUG
+ printf("%s: ignored setting with precision %d\n",
+ USBDEVNAME(sc->sc_dev), prec);
+#endif
+ return (USBD_NORMAL_COMPLETION);
+ }
+ switch (format) {
+ case UA_FMT_PCM:
+ sc->sc_altflags |= prec == 8 ? HAS_8 : HAS_16;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ break;
+ case UA_FMT_PCM8:
+ enc = AUDIO_ENCODING_ULINEAR_LE;
+ sc->sc_altflags |= HAS_8U;
+ break;
+ case UA_FMT_ALAW:
+ enc = AUDIO_ENCODING_ALAW;
+ sc->sc_altflags |= HAS_ALAW;
+ break;
+ case UA_FMT_MULAW:
+ enc = AUDIO_ENCODING_ULAW;
+ sc->sc_altflags |= HAS_MULAW;
+ break;
+ default:
+ printf("%s: ignored setting with format %d\n",
+ USBDEVNAME(sc->sc_dev), format);
+ return (USBD_NORMAL_COMPLETION);
+ }
+ DPRINTFN(1,("uaudio_identify: alt=%d enc=%d chan=%d prec=%d\n",
+ id->bAlternateSetting, enc, chan, prec));
+ ai.alt = id->bAlternateSetting;
+ ai.encoding = enc;
+ ai.idesc = id;
+ ai.edesc = ed;
+ ai.asf1desc = asf1d;
+ uaudio_add_alt(sc, &ai);
+ sc->sc_chan.terminal = asid->bTerminalLink; /* XXX */
+ sc->sc_chan.dir = dir;
+ return (USBD_NORMAL_COMPLETION);
+}
+#undef offs
+
+usbd_status
+uaudio_identify_as(sc, cdesc)
+ struct uaudio_softc *sc;
+ usb_config_descriptor_t *cdesc;
+{
+ usb_interface_descriptor_t *id;
+ usbd_status r;
+ char *buf;
+ int size, offs;
+
+ size = UGETW(cdesc->wTotalLength);
+ buf = (char *)cdesc;
+
+ /* Locate the AudioStreaming interface descriptor. */
+ offs = 0;
+ id = uaudio_find_iface(buf, size, &offs, USUBCLASS_AUDIOSTREAM);
+ if (!id)
+ return (USBD_INVAL);
+ sc->sc_as_iface = id->bInterfaceNumber;
+ DPRINTF(("uaudio_identify_as: AS interface is %d\n", sc->sc_as_iface));
+
+ sc->sc_chan.terminal = -1;
+
+ /* Loop through all the alternate settings. */
+ while (offs <= size) {
+ switch (id->bNumEndpoints) {
+ case 0:
+ DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n",
+ id->bAlternateSetting));
+ sc->sc_nullalt = id->bAlternateSetting;
+ break;
+ case 1:
+ r = uaudio_process_as(sc, buf, &offs, size, id);
+ break;
+ default:
+#ifdef AUDIO_DEBUG
+ printf("%s: ignored audio interface with %d "
+ "endpoints\n",
+ USBDEVNAME(sc->sc_dev), id->bNumEndpoints);
+#endif
+ break;
+ }
+ id = uaudio_find_iface(buf, size, &offs,USUBCLASS_AUDIOSTREAM);
+ if (!id)
+ break;
+ }
+ if (offs > size)
+ return (USBD_INVAL);
+ DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts));
+ if (sc->sc_chan.terminal < 0) {
+ printf("%s: no useable endpoint found\n",
+ USBDEVNAME(sc->sc_dev));
+ return (USBD_INVAL);
+ }
+ return (USBD_NORMAL_COMPLETION);
+}
+
+usbd_status
+uaudio_identify_ac(sc, cdesc)
+ struct uaudio_softc *sc;
+ usb_config_descriptor_t *cdesc;
+{
+ usb_interface_descriptor_t *id;
+ struct usb_audio_control_descriptor *acdp;
+ usb_descriptor_t *dp, *dps[256];
+ char *buf, *ibuf, *ibufend;
+ int size, offs, aclen, ndps, i;
+
+ size = UGETW(cdesc->wTotalLength);
+ buf = (char *)cdesc;
+
+ /* Locate the AudioControl interface descriptor. */
+ offs = 0;
+ id = uaudio_find_iface(buf, size, &offs, USUBCLASS_AUDIOCONTROL);
+ if (!id)
+ return (USBD_INVAL);
+ if (offs + sizeof *acdp > size)
+ return (USBD_INVAL);
+ sc->sc_ac_iface = id->bInterfaceNumber;
+ DPRINTFN(2,("uaudio_identify: AC interface is %d\n", sc->sc_ac_iface));
+
+ /* A class-specific AC interface header should follow. */
+ ibuf = buf + offs;
+ acdp = (struct usb_audio_control_descriptor *)ibuf;
+ if (acdp->bDescriptorType != UDESC_CS_INTERFACE ||
+ acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)
+ return (USBD_INVAL);
+ aclen = UGETW(acdp->wTotalLength);
+ if (offs + aclen > size)
+ return (USBD_INVAL);
+
+ if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) &&
+ UGETW(acdp->bcdADC) != UAUDIO_VERSION)
+ return (USBD_INVAL);
+
+ DPRINTFN(2,("uaudio_identify: found AC header, vers=%03x, len=%d\n",
+ UGETW(acdp->bcdADC), aclen));
+
+ sc->sc_nullalt = -1;
+
+ /* Scan through all the AC specific descriptors */
+ ibufend = ibuf + aclen;
+ dp = (usb_descriptor_t *)ibuf;
+ ndps = 0;
+ memset(dps, 0, sizeof dps);
+ for (;;) {
+ ibuf += dp->bLength;
+ if (ibuf >= ibufend)
+ break;
+ dp = (usb_descriptor_t *)ibuf;
+ if (ibuf + dp->bLength > ibufend)
+ return (USBD_INVAL);
+ if (dp->bDescriptorType != UDESC_CS_INTERFACE) {
+ printf("uaudio_identify: skip desc type=0x%02x\n",
+ dp->bDescriptorType);
+ continue;
+ }
+ i = ((struct usb_audio_input_terminal *)dp)->bTerminalId;
+ dps[i] = dp;
+ if (i > ndps)
+ ndps = i;
+ }
+ ndps++;
+
+ for (i = 0; i < ndps; i++) {
+ dp = dps[i];
+ if (dp == 0)
+ continue;
+ DPRINTF(("uaudio_identify: subtype=%d\n",
+ dp->bDescriptorSubtype));
+ switch (dp->bDescriptorSubtype) {
+ case UDESCSUB_AC_HEADER:
+ printf("uaudio_identify: unexpected AC header\n");
+ break;
+ case UDESCSUB_AC_INPUT:
+ uaudio_add_input(sc, dp, dps);
+ break;
+ case UDESCSUB_AC_OUTPUT:
+ uaudio_add_output(sc, dp, dps);
+ break;
+ case UDESCSUB_AC_MIXER:
+ uaudio_add_mixer(sc, dp, dps);
+ break;
+ case UDESCSUB_AC_SELECTOR:
+ uaudio_add_selector(sc, dp, dps);
+ break;
+ case UDESCSUB_AC_FEATURE:
+ uaudio_add_feature(sc, dp, dps);
+ break;
+ case UDESCSUB_AC_PROCESSING:
+ uaudio_add_processing(sc, dp, dps);
+ break;
+ case UDESCSUB_AC_EXTENSION:
+ uaudio_add_extension(sc, dp, dps);
+ break;
+ default:
+ printf("uaudio_identify: bad AC desc subtype=0x%02x\n",
+ dp->bDescriptorSubtype);
+ break;
+ }
+ }
+ return (USBD_NORMAL_COMPLETION);
+}
+
+int
+uaudio_query_devinfo(addr, mi)
+ void *addr;
+ mixer_devinfo_t *mi;
+{
+ struct uaudio_softc *sc = addr;
+ struct mixerctl *mc;
+ int n, nctls;
+
+ DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index));
+ if (sc->sc_dying)
+ return (EIO);
+
+ n = mi->index;
+ nctls = sc->sc_nctls;
+
+ if (n < 0 || n >= nctls) {
+ switch (n - nctls) {
+ case UAC_OUTPUT:
+ mi->type = AUDIO_MIXER_CLASS;
+ mi->mixer_class = nctls + UAC_OUTPUT;
+ mi->next = mi->prev = AUDIO_MIXER_LAST;
+ strcpy(mi->label.name, AudioCoutputs);
+ return (0);
+ case UAC_INPUT:
+ mi->type = AUDIO_MIXER_CLASS;
+ mi->mixer_class = nctls + UAC_INPUT;
+ mi->next = mi->prev = AUDIO_MIXER_LAST;
+ strcpy(mi->label.name, AudioCinputs);
+ return (0);
+ case UAC_EQUAL:
+ mi->type = AUDIO_MIXER_CLASS;
+ mi->mixer_class = nctls + UAC_EQUAL;
+ mi->next = mi->prev = AUDIO_MIXER_LAST;
+ strcpy(mi->label.name, AudioCequalization);
+ return (0);
+ default:
+ return (ENXIO);
+ }
+ }
+ mc = &sc->sc_ctls[n];
+ strncpy(mi->label.name, mc->ctlname, MAX_AUDIO_DEV_LEN);
+ mi->mixer_class = mc->class;
+ mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */
+ switch (mc->type) {
+ case MIX_ON_OFF:
+ mi->type = AUDIO_MIXER_ENUM;
+ mi->un.e.num_mem = 2;
+ strcpy(mi->un.e.member[0].label.name, AudioNoff);
+ mi->un.e.member[0].ord = 0;
+ strcpy(mi->un.e.member[1].label.name, AudioNon);
+ mi->un.e.member[1].ord = 1;
+ break;
+ default:
+ mi->type = AUDIO_MIXER_VALUE;
+ strncpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN);
+ mi->un.v.num_channels = mc->nchan;
+ break;
+ }
+ return (0);
+}
+
+int
+uaudio_open(addr, flags)
+ void *addr;
+ int flags;
+{
+ struct uaudio_softc *sc = addr;
+
+ DPRINTF(("uaudio_open: sc=%p\n", sc));
+ if (sc->sc_dying)
+ return (EIO);
+
+ if (sc->sc_chan.terminal < 0)
+ return (ENXIO);
+
+ if ((flags & FREAD) && sc->sc_chan.dir != UE_DIR_IN)
+ return (EACCES);
+ if ((flags & FWRITE) && sc->sc_chan.dir != UE_DIR_OUT)
+ return (EACCES);
+
+ sc->sc_chan.intr = 0;
+
+ return (0);
+}
+
+/*
+ * Close function is called at splaudio().
+ */
+void
+uaudio_close(addr)
+ void *addr;
+{
+ struct uaudio_softc *sc = addr;
+
+ DPRINTF(("uaudio_close: sc=%p\n", sc));
+ uaudio_halt_in_dma(sc);
+ uaudio_halt_out_dma(sc);
+
+ sc->sc_chan.intr = 0;
+}
+
+int
+uaudio_drain(addr)
+ void *addr;
+{
+ struct uaudio_softc *sc = addr;
+
+ usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
+
+ return (0);
+}
+
+int
+uaudio_halt_out_dma(addr)
+ void *addr;
+{
+ struct uaudio_softc *sc = addr;
+
+ DPRINTF(("uaudio_halt_out_dma: enter\n"));
+ if (sc->sc_chan.pipe) {
+ uaudio_chan_close(sc, &sc->sc_chan);
+ sc->sc_chan.pipe = 0;
+ uaudio_chan_free_buffers(sc, &sc->sc_chan);
+ }
+ return (0);
+}
+
+int
+uaudio_halt_in_dma(addr)
+ void *addr;
+{
+ struct uaudio_softc *sc = addr;
+
+ DPRINTF(("uaudio_halt_in_dma: enter\n"));
+ if (sc->sc_chan.pipe) {
+ uaudio_chan_close(sc, &sc->sc_chan);
+ sc->sc_chan.pipe = 0;
+ uaudio_chan_free_buffers(sc, &sc->sc_chan);
+ }
+ return (0);
+}
+
+int
+uaudio_getdev(addr, retp)
+ void *addr;
+ struct audio_device *retp;
+{
+ struct uaudio_softc *sc = addr;
+
+ DPRINTF(("uaudio_mixer_getdev:\n"));
+ if (sc->sc_dying)
+ return (EIO);
+
+ *retp = uaudio_device;
+ return (0);
+}
+
+/*
+ * Make sure the block size is large enough to hold all outstanding transfers.
+ */
+int
+uaudio_round_blocksize(addr, blk)
+ void *addr;
+ int blk;
+{
+ struct uaudio_softc *sc = addr;
+ int bpf;
+
+ bpf = sc->sc_chan.bytes_per_frame + sc->sc_chan.sample_size;
+ /* XXX */
+ bpf *= UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
+
+ bpf = (bpf + 15) &~ 15;
+
+ if (blk < bpf)
+ blk = bpf;
+
+#ifdef DIAGNOSTIC
+ if (blk <= 0) {
+ printf("uaudio_round_blocksize: blk=%d\n", blk);
+ blk = 512;
+ }
+#endif
+
+ DPRINTFN(1,("uaudio_round_blocksize: blk=%d\n", blk));
+ return (blk);
+}
+
+int
+uaudio_get_props(addr)
+ void *addr;
+{
+ struct uaudio_softc *sc = addr;
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ return (sc->sc_props);
+}
+
+int
+uaudio_get(sc, which, type, wValue, wIndex, len)
+ struct uaudio_softc *sc;
+ int type, which, wValue, wIndex, len;
+{
+ usb_device_request_t req;
+ u_int8_t data[4];
+ usbd_status r;
+ int val;
+
+ if (wValue == -1)
+ return (0);
+
+ req.bmRequestType = type;
+ req.bRequest = which;
+ USETW(req.wValue, wValue);
+ USETW(req.wIndex, wIndex);
+ USETW(req.wLength, len);
+ DPRINTFN(2,("uaudio_get: type=0x%02x req=0x%02x wValue=0x%04x "
+ "wIndex=0x%04x len=%d\n",
+ type, which, wValue, wIndex, len));
+ r = usbd_do_request(sc->sc_udev, &req, &data);
+ if (r != USBD_NORMAL_COMPLETION) {
+ DPRINTF(("uaudio_get: r=%d\n", r));
+ return (-1);
+ }
+ switch (len) {
+ case 1:
+ val = data[0];
+ break;
+ case 2:
+ val = data[0] | (data[1] << 8);
+ break;
+ default:
+ DPRINTF(("uaudio_get: bad length=%d\n", len));
+ return (-1);
+ }
+ DPRINTFN(2,("uaudio_get: val=%d\n", val));
+ return (val);
+}
+
+void
+uaudio_set(sc, which, type, wValue, wIndex, len, val)
+ struct uaudio_softc *sc;
+ int type, which, wValue, wIndex, len, val;
+{
+ usb_device_request_t req;
+ u_int8_t data[4];
+ usbd_status r;
+
+ if (wValue == -1)
+ return;
+
+ req.bmRequestType = type;
+ req.bRequest = which;
+ USETW(req.wValue, wValue);
+ USETW(req.wIndex, wIndex);
+ USETW(req.wLength, len);
+ switch (len) {
+ case 1:
+ data[0] = val;
+ break;
+ case 2:
+ data[0] = val;
+ data[1] = val >> 8;
+ break;
+ default:
+ return;
+ }
+ DPRINTFN(2,("uaudio_set: type=0x%02x req=0x%02x wValue=0x%04x "
+ "wIndex=0x%04x len=%d, val=%d\n",
+ type, which, wValue, wIndex, len, val & 0xffff));
+ r = usbd_do_request(sc->sc_udev, &req, &data);
+#ifdef UAUDIO_DEBUG
+ if (r != USBD_NORMAL_COMPLETION)
+ DPRINTF(("uaudio_set: r=%d\n", r));
+#endif
+}
+
+int
+uaudio_signext(type, val)
+ int type, val;
+{
+ if (!MIX_UNSIGNED(type)) {
+ if (MIX_SIZE(type) == 2)
+ val = (int16_t)val;
+ else
+ val = (int8_t)val;
+ }
+ return (val);
+}
+
+int
+uaudio_value2bsd(mc, val)
+ struct mixerctl *mc;
+ int val;
+{
+ DPRINTFN(5, ("uaudio_value2bsd: type=%03x val=%d min=%d max=%d ",
+ mc->type, val, mc->minval, mc->maxval));
+ if (mc->type == MIX_ON_OFF)
+ val = val != 0;
+ else
+ val = (uaudio_signext(mc->type, val) - mc->minval) * 256
+ / (mc->maxval - mc->minval);
+ DPRINTFN(5, ("val'=%d\n", val));
+ return (val);
+}
+
+int
+uaudio_bsd2value(mc, val)
+ struct mixerctl *mc;
+ int val;
+{
+ DPRINTFN(5,("uaudio_bsd2value: type=%03x val=%d min=%d max=%d ",
+ mc->type, val, mc->minval, mc->maxval));
+ if (mc->type == MIX_ON_OFF)
+ val = val != 0;
+ else
+ val = val * (mc->maxval - mc->minval) / 256 + mc->minval;
+ DPRINTFN(5, ("val'=%d\n", val));
+ return (val);
+}
+
+int
+uaudio_ctl_get(sc, which, mc, chan)
+ struct uaudio_softc *sc;
+ int which;
+ struct mixerctl *mc;
+ int chan;
+{
+ int val;
+
+ DPRINTFN(5,("uaudio_ctl_get: which=%d chan=%d\n", which, chan));
+ val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan],
+ mc->wIndex, MIX_SIZE(mc->type));
+ return (uaudio_value2bsd(mc, val));
+}
+
+void
+uaudio_ctl_set(sc, which, mc, chan, val)
+ struct uaudio_softc *sc;
+ int which;
+ struct mixerctl *mc;
+ int chan;
+ int val;
+{
+ val = uaudio_bsd2value(mc, val);
+ uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan],
+ mc->wIndex, MIX_SIZE(mc->type), val);
+}
+
+int
+uaudio_mixer_get_port(addr, cp)
+ void *addr;
+ mixer_ctrl_t *cp;
+{
+ struct uaudio_softc *sc = addr;
+ struct mixerctl *mc;
+ int i, n, vals[MIX_MAX_CHAN], val;
+
+ DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev));
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ n = cp->dev;
+ if (n < 0 || n >= sc->sc_nctls)
+ return (ENXIO);
+ mc = &sc->sc_ctls[n];
+
+ if (mc->type == MIX_ON_OFF) {
+ if (cp->type != AUDIO_MIXER_ENUM)
+ return (EINVAL);
+ cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
+ } else {
+ if (cp->type != AUDIO_MIXER_VALUE)
+ return (EINVAL);
+ if (cp->un.value.num_channels != 1 &&
+ cp->un.value.num_channels != mc->nchan)
+ return (EINVAL);
+ for (i = 0; i < mc->nchan; i++)
+ vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i);
+ if (cp->un.value.num_channels == 1 && mc->nchan != 1) {
+ for (val = 0, i = 0; i < mc->nchan; i++)
+ val += vals[i];
+ vals[0] = val / mc->nchan;
+ }
+ for (i = 0; i < cp->un.value.num_channels; i++)
+ cp->un.value.level[i] = vals[i];
+ }
+
+ return (0);
+}
+
+int
+uaudio_mixer_set_port(addr, cp)
+ void *addr;
+ mixer_ctrl_t *cp;
+{
+ struct uaudio_softc *sc = addr;
+ struct mixerctl *mc;
+ int i, n, vals[MIX_MAX_CHAN];
+
+ DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev));
+ if (sc->sc_dying)
+ return (EIO);
+
+ n = cp->dev;
+ if (n < 0 || n >= sc->sc_nctls)
+ return (ENXIO);
+ mc = &sc->sc_ctls[n];
+
+ if (mc->type == MIX_ON_OFF) {
+ if (cp->type != AUDIO_MIXER_ENUM)
+ return (EINVAL);
+ uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
+ } else {
+ if (cp->type != AUDIO_MIXER_VALUE)
+ return (EINVAL);
+ if (cp->un.value.num_channels == 1)
+ for (i = 0; i < mc->nchan; i++)
+ vals[i] = cp->un.value.level[0];
+ else if (cp->un.value.num_channels == mc->nchan)
+ for (i = 0; i < mc->nchan; i++)
+ vals[i] = cp->un.value.level[i];
+ else
+ return (EINVAL);
+ for (i = 0; i < mc->nchan; i++)
+ uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]);
+ }
+ return (0);
+}
+
+int
+uaudio_trigger_input(addr, start, end, blksize, intr, arg, param)
+ void *addr;
+ void *start, *end;
+ int blksize;
+ void (*intr) __P((void *));
+ void *arg;
+ struct audio_params *param;
+{
+ struct uaudio_softc *sc = addr;
+ struct chan *ch = &sc->sc_chan;
+ usbd_status r;
+ int i, s;
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p "
+ "blksize=%d\n", sc, start, end, blksize));
+
+ uaudio_chan_set_param(ch, param, start, end, blksize);
+ DPRINTFN(3,("uaudio_trigger_input: sample_size=%d bytes/frame=%d "
+ "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
+ ch->fraction));
+
+ r = uaudio_chan_alloc_buffers(sc, ch);
+ if (r != USBD_NORMAL_COMPLETION)
+ return (EIO);
+
+ r = uaudio_chan_open(sc, ch);
+ if (r != USBD_NORMAL_COMPLETION) {
+ uaudio_chan_free_buffers(sc, ch);
+ return (EIO);
+ }
+
+ sc->sc_chan.intr = intr;
+ sc->sc_chan.arg = arg;
+
+ s = splusb();
+ for (i = 0; i < UAUDIO_NCHANBUFS; i++)
+ uaudio_chan_rtransfer(ch);
+ splx(s);
+
+ return (0);
+}
+
+int
+uaudio_trigger_output(addr, start, end, blksize, intr, arg, param)
+ void *addr;
+ void *start, *end;
+ int blksize;
+ void (*intr) __P((void *));
+ void *arg;
+ struct audio_params *param;
+{
+ struct uaudio_softc *sc = addr;
+ struct chan *ch = &sc->sc_chan;
+ usbd_status r;
+ int i, s;
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p "
+ "blksize=%d\n", sc, start, end, blksize));
+
+ uaudio_chan_set_param(ch, param, start, end, blksize);
+ DPRINTFN(3,("uaudio_trigger_output: sample_size=%d bytes/frame=%d "
+ "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
+ ch->fraction));
+
+ r = uaudio_chan_alloc_buffers(sc, ch);
+ if (r != USBD_NORMAL_COMPLETION)
+ return (EIO);
+
+ r = uaudio_chan_open(sc, ch);
+ if (r != USBD_NORMAL_COMPLETION) {
+ uaudio_chan_free_buffers(sc, ch);
+ return (EIO);
+ }
+
+ sc->sc_chan.intr = intr;
+ sc->sc_chan.arg = arg;
+
+ s = splusb();
+ for (i = 0; i < UAUDIO_NCHANBUFS; i++)
+ uaudio_chan_ptransfer(ch);
+ splx(s);
+
+ return (0);
+}
+
+/* Set up a pipe for a channel. */
+usbd_status
+uaudio_chan_open(sc, ch)
+ struct uaudio_softc *sc;
+ struct chan *ch;
+{
+ struct as_info *as = &sc->sc_alts[sc->sc_curaltidx];
+ int endpt = as->edesc->bEndpointAddress;
+ usbd_status r;
+
+ DPRINTF(("uaudio_open_chan: endpt=0x%02x, speed=%d, alt=%d\n",
+ endpt, ch->sample_rate, as->alt));
+
+ /* Set alternate interface corresponding to the mode. */
+ r = usbd_set_interface(sc->sc_as_ifaceh, as->alt);
+ if (r != USBD_NORMAL_COMPLETION)
+ return (r);
+
+ /* Some devices do not support this request, so ignore errors. */
+#ifdef UAUDIO_DEBUG
+ r = uaudio_set_speed(sc, endpt, ch->sample_rate);
+ if (r != USBD_NORMAL_COMPLETION)
+ DPRINTF(("uaudio_chan_open: set_speed failed r=%s\n",
+ usbd_errstr(r)));
+#else
+ (void)uaudio_set_speed(sc, endpt, ch->sample_rate);
+#endif
+
+ DPRINTF(("uaudio_open_chan: create pipe to 0x%02x\n", endpt));
+ r = usbd_open_pipe(sc->sc_as_ifaceh, endpt, 0, &ch->pipe);
+ return (r);
+}
+
+void
+uaudio_chan_close(sc, ch)
+ struct uaudio_softc *sc;
+ struct chan *ch;
+{
+ if (sc->sc_nullalt >= 0) {
+ DPRINTF(("uaudio_close_chan: set null alt=%d\n",
+ sc->sc_nullalt));
+ usbd_set_interface(sc->sc_as_ifaceh, sc->sc_nullalt);
+ }
+ usbd_abort_pipe(ch->pipe);
+ usbd_close_pipe(ch->pipe);
+}
+
+usbd_status
+uaudio_chan_alloc_buffers(sc, ch)
+ struct uaudio_softc *sc;
+ struct chan *ch;
+{
+ usbd_request_handle reqh;
+ void *buf;
+ int i, size;
+
+ size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES;
+ for (i = 0; i < UAUDIO_NCHANBUFS; i++) {
+ reqh = usbd_alloc_request(sc->sc_udev);
+ if (reqh == 0)
+ goto bad;
+ ch->chanbufs[i].reqh = reqh;
+ buf = usbd_alloc_buffer(reqh, size);
+ if (buf == 0) {
+ i++;
+ goto bad;
+ }
+ ch->chanbufs[i].buffer = buf;
+ ch->chanbufs[i].chan = ch;
+ }
+
+ return (USBD_NORMAL_COMPLETION);
+
+bad:
+ while (--i >= 0)
+ /* implicit buffer free */
+ usbd_free_request(ch->chanbufs[i].reqh);
+ return (USBD_NOMEM);
+}
+
+void
+uaudio_chan_free_buffers(sc, ch)
+ struct uaudio_softc *sc;
+ struct chan *ch;
+{
+ int i;
+
+ for (i = 0; i < UAUDIO_NCHANBUFS; i++)
+ usbd_free_request(ch->chanbufs[i].reqh);
+}
+
+/* Called at splusb() */
+void
+uaudio_chan_ptransfer(ch)
+ struct chan *ch;
+{
+ struct chanbuf *cb;
+ int i, n, size, residue, total;
+
+ /* Pick the next channel buffer. */
+ cb = &ch->chanbufs[ch->curchanbuf];
+ if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
+ ch->curchanbuf = 0;
+
+ /* Compute the size of each frame in the next transfer. */
+ residue = ch->residue;
+ total = 0;
+ for (i = 0; i < UAUDIO_NFRAMES; i++) {
+ size = ch->bytes_per_frame;
+ residue += ch->fraction;
+ if (residue >= USB_FRAMES_PER_SECOND) {
+ size += ch->sample_size;
+ residue -= USB_FRAMES_PER_SECOND;
+ }
+ cb->sizes[i] = size;
+ total += size;
+ }
+ ch->residue = residue;
+ cb->size = total;
+
+ /*
+ * Transfer data from upper layer buffer to channel buffer, taking
+ * care of wrapping the upper layer buffer.
+ */
+ n = min(total, ch->end - ch->cur);
+ memcpy(cb->buffer, ch->cur, n);
+ ch->cur += n;
+ if (ch->cur >= ch->end)
+ ch->cur = ch->start;
+ if (total > n) {
+ total -= n;
+ memcpy(cb->buffer + n, ch->cur, total);
+ ch->cur += total;
+ }
+
+#ifdef UAUDIO_DEBUG
+ if (uaudiodebug > 8) {
+ DPRINTF(("uaudio_chan_ptransfer: buffer=%p, residue=0.%03d\n",
+ cb->buffer, ch->residue));
+ for (i = 0; i < UAUDIO_NFRAMES; i++) {
+ DPRINTF((" [%d] length %d\n", i, cb->sizes[i]));
+ }
+ }
+#endif
+
+ DPRINTFN(5,("uaudio_chan_transfer: ptransfer reqh=%p\n", cb->reqh));
+ /* Fill the request */
+ usbd_setup_isoc_request(cb->reqh, ch->pipe, cb, cb->sizes,
+ UAUDIO_NFRAMES, USBD_NO_COPY,
+ uaudio_chan_pintr);
+
+ (void)usbd_transfer(cb->reqh);
+}
+
+void
+uaudio_chan_pintr(reqh, priv, status)
+ usbd_request_handle reqh;
+ usbd_private_handle priv;
+ usbd_status status;
+{
+ struct chanbuf *cb = priv;
+ struct chan *ch = cb->chan;
+ u_int32_t count;
+ int s;
+
+ /* Return if we are aborting. */
+ if (status == USBD_CANCELLED)
+ return;
+
+ usbd_get_request_status(reqh, 0, 0, &count, 0);
+ DPRINTFN(5,("uaudio_chan_pintr: count=%d, transferred=%d\n",
+ count, ch->transferred));
+#ifdef DIAGNOSTIC
+ if (count != cb->size) {
+ printf("uaudio_chan_pintr: count(%d) != size(%d)\n",
+ count, cb->size);
+ }
+#endif
+
+ ch->transferred += cb->size;
+ s = splaudio();
+ /* Call back to upper layer */
+ while (ch->transferred >= ch->blksize) {
+ ch->transferred -= ch->blksize;
+ DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n",
+ ch->intr, ch->arg));
+ ch->intr(ch->arg);
+ }
+ splx(s);
+
+ /* start next transfer */
+ uaudio_chan_ptransfer(ch);
+}
+
+/* Called at splusb() */
+void
+uaudio_chan_rtransfer(ch)
+ struct chan *ch;
+{
+ struct chanbuf *cb;
+ int i, size, residue, total;
+
+ /* Pick the next channel buffer. */
+ cb = &ch->chanbufs[ch->curchanbuf];
+ if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
+ ch->curchanbuf = 0;
+
+ /* Compute the size of each frame in the next transfer. */
+ residue = ch->residue;
+ total = 0;
+ for (i = 0; i < UAUDIO_NFRAMES; i++) {
+ size = ch->bytes_per_frame;
+ residue += ch->fraction;
+ if (residue >= USB_FRAMES_PER_SECOND) {
+ size += ch->sample_size;
+ residue -= USB_FRAMES_PER_SECOND;
+ }
+ cb->sizes[i] = size;
+ total += size;
+ }
+ ch->residue = residue;
+ cb->size = total;
+
+#ifdef UAUDIO_DEBUG
+ if (uaudiodebug > 8) {
+ DPRINTF(("uaudio_chan_rtransfer: buffer=%p, residue=0.%03d\n",
+ cb->buffer, ch->residue));
+ for (i = 0; i < UAUDIO_NFRAMES; i++) {
+ DPRINTF((" [%d] length %d\n", i, cb->sizes[i]));
+ }
+ }
+#endif
+
+ DPRINTFN(5,("uaudio_chan_rtransfer: transfer reqh=%p\n", cb->reqh));
+ /* Fill the request */
+ usbd_setup_isoc_request(cb->reqh, ch->pipe, cb, cb->sizes,
+ UAUDIO_NFRAMES, USBD_NO_COPY,
+ uaudio_chan_rintr);
+
+ (void)usbd_transfer(cb->reqh);
+}
+
+void
+uaudio_chan_rintr(reqh, priv, status)
+ usbd_request_handle reqh;
+ usbd_private_handle priv;
+ usbd_status status;
+{
+ struct chanbuf *cb = priv;
+ struct chan *ch = cb->chan;
+ u_int32_t count;
+ int s, n;
+
+ /* Return if we are aborting. */
+ if (status == USBD_CANCELLED)
+ return;
+
+ usbd_get_request_status(reqh, 0, 0, &count, 0);
+ DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n",
+ count, ch->transferred));
+#ifdef DIAGNOSTIC
+ if (count != cb->size) {
+ printf("uaudio_chan_pintr: count(%d) != size(%d)\n",
+ count, cb->size);
+ }
+#endif
+
+ /*
+ * Transfer data from channel buffer to upper layer buffer, taking
+ * care of wrapping the upper layer buffer.
+ */
+ n = min(count, ch->end - ch->cur);
+ memcpy(ch->cur, cb->buffer, n);
+ ch->cur += n;
+ if (ch->cur >= ch->end)
+ ch->cur = ch->start;
+ if (count > n) {
+ memcpy(ch->cur, cb->buffer + n, count - n);
+ ch->cur += count - n;
+ }
+
+ /* Call back to upper layer */
+ ch->transferred += cb->size;
+ s = splaudio();
+ while (ch->transferred >= ch->blksize) {
+ ch->transferred -= ch->blksize;
+ DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n",
+ ch->intr, ch->arg));
+ ch->intr(ch->arg);
+ }
+ splx(s);
+
+ /* start next transfer */
+ uaudio_chan_rtransfer(ch);
+}
+
+void
+uaudio_chan_set_param(ch, param, start, end, blksize)
+ struct chan *ch;
+ struct audio_params *param;
+ u_char *start, *end;
+ int blksize;
+{
+ int samples_per_frame, sample_size;
+
+ sample_size = param->precision * param->channels / 8;
+ samples_per_frame = param->sample_rate / USB_FRAMES_PER_SECOND;
+ ch->fraction = param->sample_rate % USB_FRAMES_PER_SECOND;
+ ch->sample_size = sample_size;
+ ch->sample_rate = param->sample_rate;
+ ch->bytes_per_frame = samples_per_frame * sample_size;
+ ch->residue = 0;
+
+ ch->start = start;
+ ch->end = end;
+ ch->cur = start;
+ ch->blksize = blksize;
+ ch->transferred = 0;
+
+ ch->curchanbuf = 0;
+}
+
+int
+uaudio_set_params(addr, setmode, usemode, p, r)
+ void *addr;
+ int setmode, usemode;
+ struct audio_params *p, *r;
+{
+ struct uaudio_softc *sc = addr;
+ int flags = sc->sc_altflags;
+ int enc, i, j;
+ void (*pswcode) __P((void *, u_char *buf, int cnt));
+ void (*rswcode) __P((void *, u_char *buf, int cnt));
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ if (sc->sc_chan.pipe)
+ return (EBUSY);
+
+ pswcode = rswcode = 0;
+ enc = p->encoding;
+ switch (p->encoding) {
+ case AUDIO_ENCODING_SLINEAR_BE:
+ if (p->precision == 16) {
+ rswcode = pswcode = swap_bytes;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ } else if (p->precision == 8 && !(flags & HAS_8)) {
+ pswcode = rswcode = change_sign8;
+ enc = AUDIO_ENCODING_ULINEAR_LE;
+ }
+ break;
+ case AUDIO_ENCODING_SLINEAR_LE:
+ if (p->precision == 8 && !(flags & HAS_8)) {
+ pswcode = rswcode = change_sign8;
+ enc = AUDIO_ENCODING_ULINEAR_LE;
+ }
+ break;
+ case AUDIO_ENCODING_ULINEAR_BE:
+ if (p->precision == 16) {
+ pswcode = swap_bytes_change_sign16;
+ rswcode = change_sign16_swap_bytes;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ } else if (p->precision == 8 && !(flags & HAS_8U)) {
+ pswcode = rswcode = change_sign8;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ }
+ break;
+ case AUDIO_ENCODING_ULINEAR_LE:
+ if (p->precision == 16) {
+ pswcode = rswcode = change_sign16;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ } else if (p->precision == 8 && !(flags & HAS_8U)) {
+ pswcode = rswcode = change_sign8;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ }
+ break;
+ case AUDIO_ENCODING_ULAW:
+ if (!(flags & HAS_MULAW)) {
+ if (flags & HAS_8U) {
+ pswcode = mulaw_to_ulinear8;
+ rswcode = ulinear8_to_mulaw;
+ enc = AUDIO_ENCODING_ULINEAR_LE;
+ } else if (flags & HAS_8) {
+ pswcode = mulaw_to_slinear8;
+ rswcode = slinear8_to_mulaw;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ } else
+ return (EINVAL);
+ }
+ break;
+ case AUDIO_ENCODING_ALAW:
+ if (!(flags & HAS_ALAW)) {
+ if (flags & HAS_8U) {
+ pswcode = alaw_to_ulinear8;
+ rswcode = ulinear8_to_alaw;
+ enc = AUDIO_ENCODING_ULINEAR_LE;
+ } else if (flags & HAS_8) {
+ pswcode = alaw_to_slinear8;
+ rswcode = slinear8_to_alaw;
+ enc = AUDIO_ENCODING_SLINEAR_LE;
+ } else
+ return (EINVAL);
+ }
+ break;
+ default:
+ return (EINVAL);
+ }
+ /* XXX do some other conversions... */
+
+ DPRINTF(("uaudio_set_params: chan=%d prec=%d enc=%d rate=%ld\n",
+ p->channels, p->precision, enc, p->sample_rate));
+
+ for (i = 0; i < sc->sc_nalts; i++) {
+ struct usb_audio_streaming_type1_descriptor *a1d =
+ sc->sc_alts[i].asf1desc;
+ if (p->channels == a1d->bNrChannels &&
+ p->precision ==a1d->bBitResolution &&
+ enc == sc->sc_alts[i].encoding) {
+ if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
+ if (UA_SAMP_LO(a1d) < p->sample_rate &&
+ p->sample_rate < UA_SAMP_HI(a1d))
+ goto found;
+ } else {
+ for (j = 0; j < a1d->bSamFreqType; j++) {
+ /* XXX allow for some slack */
+ if (UA_GETSAMP(a1d, j) ==
+ p->sample_rate)
+ goto found;
+ }
+ }
+ }
+ }
+ return (EINVAL);
+
+ found:
+ p->sw_code = pswcode;
+ r->sw_code = rswcode;
+ sc->sc_curaltidx = i;
+
+ DPRINTF(("uaudio_set_params: use altidx=%d, altno=%d\n",
+ sc->sc_curaltidx,
+ sc->sc_alts[sc->sc_curaltidx].idesc->bAlternateSetting));
+
+ return (0);
+}
+
+usbd_status
+uaudio_set_speed(sc, endpt, speed)
+ struct uaudio_softc *sc;
+ int endpt;
+ u_int speed;
+{
+ usb_device_request_t req;
+ u_int8_t data[3];
+
+ DPRINTFN(5,("uaudio_set_speed: endpt=%d speed=%u\n", endpt, speed));
+ req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
+ req.bRequest = SET_CUR;
+ USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
+ USETW(req.wIndex, endpt);
+ USETW(req.wLength, 3);
+ data[0] = speed;
+ data[1] = speed >> 8;
+ data[2] = speed >> 16;
+
+ return (usbd_do_request(sc->sc_udev, &req, &data));
+}
+
diff --git a/sys/dev/usb/uaudioreg.h b/sys/dev/usb/uaudioreg.h
new file mode 100644
index 00000000000..113752e6214
--- /dev/null
+++ b/sys/dev/usb/uaudioreg.h
@@ -0,0 +1,278 @@
+/* $OpenBSD: uaudioreg.h,v 1.1 1999/11/11 15:54:59 ho Exp $ */
+/* $NetBSD: uaudioreg.h,v 1.2 1999/10/13 20:13:29 augustss Exp $ */
+
+/*
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Author: Lennart Augustsson <augustss@carlstedt.se>
+ * Carlstedt Research & Technology
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define UAUDIO_VERSION 0x100
+
+#define UDESC_CS_DEVICE 0x21
+#define UDESC_CS_CONFIG 0x22
+#define UDESC_CS_STRING 0x23
+#define UDESC_CS_INTERFACE 0x24
+#define UDESC_CS_ENDPOINT 0x25
+
+#define UDESCSUB_AC_HEADER 1
+#define UDESCSUB_AC_INPUT 2
+#define UDESCSUB_AC_OUTPUT 3
+#define UDESCSUB_AC_MIXER 4
+#define UDESCSUB_AC_SELECTOR 5
+#define UDESCSUB_AC_FEATURE 6
+#define UDESCSUB_AC_PROCESSING 7
+#define UDESCSUB_AC_EXTENSION 8
+
+/* The first fields are identical to usb_endpoint_descriptor_t */
+typedef struct {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bEndpointAddress;
+ uByte bmAttributes;
+ uWord wMaxPacketSize;
+ uByte bInterval;
+ /*
+ * The following two entries are only used by the Audio Class.
+ * And according to the specs the Audio Class is the only one
+ * allowed to extend the endpoint descriptor.
+ * Who knows what goes on in the minds of the people in the USB
+ * standardization? :-(
+ */
+ uByte bRefresh;
+ uByte bSynchAddress;
+} usb_endpoint_descriptor_audio_t;
+
+struct usb_audio_control_descriptor {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uWord bcdADC;
+ uWord wTotalLength;
+ uByte bInCollection;
+ uByte baInterfaceNr[1];
+};
+
+struct usb_audio_streaming_interface_descriptor {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bTerminalLink;
+ uByte bDelay;
+ uWord wFormatTag;
+};
+
+struct usb_audio_streaming_endpoint_descriptor {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bmAttributes;
+ uByte bLockDelayUnits;
+ uWord wLockDelay;
+};
+
+struct usb_audio_streaming_type1_descriptor {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bFormatType;
+ uByte bNrChannels;
+ uByte bSubFrameSize;
+ uByte bBitResolution;
+ uByte bSamFreqType;
+#define UA_SAMP_CONTNUOUS 0
+ uByte tSamFreq[3*2]; /* room for low and high */
+#define UA_GETSAMP(p, n) ((p)->tSamFreq[(n)*3+0] | ((p)->tSamFreq[(n)*3+1] << 8) | ((p)->tSamFreq[(n)*3+2] << 16))
+#define UA_SAMP_LO(p) UA_GETSAMP(p, 0)
+#define UA_SAMP_HI(p) UA_GETSAMP(p, 1)
+};
+
+struct usb_audio_cluster {
+ uByte bNrChannels;
+ uWord wChannelConfig;
+ uByte iChannelNames;
+};
+
+/* UDESCSUB_AC_INPUT */
+struct usb_audio_input_terminal {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bTerminalId;
+ uWord wTerminalType;
+ uByte bAssocTerminal;
+ uByte bNrChannels;
+ uWord wChannelConfig;
+ uByte iChannelNames;
+ uByte iTerminal;
+};
+
+/* UDESCSUB_AC_OUTPUT */
+struct usb_audio_output_terminal {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bTerminalId;
+ uWord wTerminalType;
+ uByte bAssocTerminal;
+ uByte bSourceId;
+ uByte iTerminal;
+};
+
+/* UDESCSUB_AC_MIXER */
+struct usb_audio_mixer_unit {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bUnitId;
+ uByte bNrInPins;
+ uByte baSourceId[255]; /* length is really bNrInPins */
+ /* struct usb_audio_mixer_unit_1 */
+};
+struct usb_audio_mixer_unit_1 {
+ uByte bNrChannels;
+ uWord wChannelConfig;
+ uByte iChannelNames;
+ uByte bmControls[255];
+ /*uByte iMixer;*/
+};
+
+/* UDESCSUB_AC_SELECTOR */
+struct usb_audio_selector_unit {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bUnitId;
+ uByte bNrInPins;
+ uByte baSourceId[255];
+ /* uByte iSelector; */
+};
+
+/* UDESCSUB_AC_FEATURE */
+struct usb_audio_feature_unit {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bUnitId;
+ uByte bSourceId;
+ uByte bControlSize;
+ uByte bmaControls[255]; /* size for more than enough */
+ /* uByte iFeature; */
+};
+
+/* UDESCSUB_AC_PROCESSING */
+struct usb_audio_processing_unit {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bUnitId;
+ uWord wProcessType;
+ uByte bNrInPins;
+ uByte baSourceId[255];
+ /* struct usb_audio_processing_unit_1 */
+};
+struct usb_audio_processing_unit_1{
+ uByte bNrChannels;
+ uWord wChannelConfig;
+ uByte iChannelNames;
+ uByte bControlSize;
+ uByte bmControls[255];
+ /*uByte iProcessing;*/
+};
+
+/* UDESCSUB_AC_EXTENSION */
+struct usb_audio_extension_unit {
+ uByte bLength;
+ uByte bDescriptorType;
+ uByte bDescriptorSubtype;
+ uByte bUnitId;
+ uWord wExtensionCode;
+ uByte bNrInPins;
+ uByte baSourceId[255];
+ /* struct usb_audio_extension_unit_1 */
+};
+struct usb_audio_extension_unit_1 {
+ uByte bNrChannels;
+ uWord wChannelConfig;
+ uByte iChannelNames;
+ uByte bControlSize;
+ uByte bmControls[255];
+#define UA_EXT_ENABLE 0
+ /*uByte iExtension;*/
+};
+
+#define UAT_STREAM 0x0101
+
+#define SET_CUR 0x01
+#define GET_CUR 0x81
+#define SET_MIN 0x02
+#define GET_MIN 0x82
+#define SET_MAX 0x03
+#define GET_MAX 0x83
+#define SET_RES 0x04
+#define GET_RES 0x84
+#define SET_MEM 0x05
+#define GET_MEM 0x85
+#define GET_STAT 0xff
+
+#define MUTE_CONTROL 0x01
+#define VOLUME_CONTROL 0x02
+#define BASS_CONTROL 0x03
+#define MID_CONTROL 0x04
+#define TREBLE_CONTROL 0x05
+#define GRAPHIC_EQUALIZER_CONTROL 0x06
+#define AGC_CONTROL 0x07
+#define DELAY_CONTROL 0x08
+#define BASS_BOOST_CONTROL 0x09
+#define LOUDNESS_CONTROL 0x0a
+
+#define FU_MASK(u) (1 << ((u)-1))
+
+#define MASTER_CHAN 0
+
+#define AS_GENERAL 1
+#define FORMAT_TYPE 2
+#define FORMAT_SPECIFIC 3
+
+#define UA_FMT_PCM 1
+#define UA_FMT_PCM8 2
+#define UA_FMT_IEEE_FLOAT 3
+#define UA_FMT_ALAW 4
+#define UA_FMT_MULAW 5
+
+#define SAMPLING_FREQ_CONTROL 0x01
+
+#define FORMAT_TYPE_UNDEFINED 0
+#define FORMAT_TYPE_I 1
+#define FORMAT_TYPE_II 2
+#define FORMAT_TYPE_III 3