d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bba4862c64
freebsd-skq/sys/dev/sound/usb/uaudio.c
Ariff Abdullah bba4862c64 Last major commit and updates for RELENG_7: 
- Rework the entire pcm_channel structure:
  * Remove rarely used link placeholder, instead, make each pcm_channel
    as head/link of each own/each other. Unlock - Lock sequence due to
    sleep malloc has been reduced.
  * Implement "busy" queue which will contain list of busy/active
    channels. This greatly reduce locking contention for example while
    servicing interrupt for hardware with many channels or when virtual
    channels reach its 256 peak channels.

- So I heard you like v chan ... O RLY?
  Welcome to Virtual **Record** Channels (vrec, rec vchans, vchans for
  recording, Rec-Chan, you decide), the ultimate solutions for your
  nagging O_RDWR full-duplex wannabe (note: flash plugins) monopolizing
  single record channel causing EBUSY.  Vrec works exactly like Vchans
  (or, should I rename it to "Vplay" :) , except that it operates on the
  opposite direction (recording). Up to 256 vrecs (like vchans) are
  possible.

  Notes:
   * Relocate dev.pcm.%d.{vchans,vchanformat,vchanrate} to each of its
     respective node/direction:
       dev.pcm.%d.play.* for "play"   (cdev = dsp%d.vp%d)
       dev.pcm.%d.rec.*  for "record" (cdev = dsp%d.vr%d)
   * Don't expect that it will magically give you ability to split
     "recording source" (eg: 1 channel for cdrom, 1 channel for mic,
     etc). Just admit that you only have a *single* recording source /
     channel. Please bug your hardware vendor instead :)

- Bump maxautovchans from 4 to 16. For a full-fledged multimedia
  desktop/workstation with too many soundservers installed (esound,
  artsd, jackd, pulse/polypaudio, ding-dong pling plong mudkip fuh fuh,
  etc), 4 seems inadequate. There will be no memory penalty here, since
  virtual channels are allocate only by demand.

- Nuke/Rework the entire statically created cdev entries. Everything is
  clonable through snd own clone manager which designed to withstand many
  kind of abusive devfs droids such as:
      * while : ; do /bin/test -e /dev/dsp ; done
      * jot 16777216 0 | while read x ; do ls /dev/dsp0.$x ; done
      * hundreds (could be thousands) concurrent threads/process opening
	"/dev/dsp" (previously, this might result EBUSY even with just
	3 contesting threads/procs).
  o Reusable clone objects (instead of creating new one like there's no
    tomorrow) after certain expiration deadline. The clone allocator will
    decide whether to reuse, share, or creating new clone.
  o Automatic garbage collector.

- Dynamic unit magic allocator. Maximum attached soundcards can be tuned
  using tunable "hw.snd.maxunit" (Default to 512). Minimum is 16, and
  maximum is 2048.

- ..other fixes, mostly related to concurrency issues.

joel@ will do the manpage updates on sound(4).

Have fun.
2007-05-31 18:43:33 +00:00

4663 lines
119 KiB
C
Raw Blame History

/* $NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $ */
/* $FreeBSD$ */
/*-
* Copyright (c) 1999 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson (lennart@augustsson.net) 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.usb.org/developers/devclass_docs/audio10.pdf
* http://www.usb.org/developers/devclass_docs/frmts10.pdf
* http://www.usb.org/developers/devclass_docs/termt10.pdf
*/
#include <sys/cdefs.h>
#if defined(__NetBSD__) || defined(__OpenBSD__)
__KERNEL_RCSID(0, "$NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $");
#endif
/*
* Also merged:
* $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $
* $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $
* $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $
* $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $
* $NetBSD: uaudio.c,v 1.102 2006/04/14 17:00:55 christos Exp $
* $NetBSD: uaudio.c,v 1.103 2006/05/11 19:09:25 mrg Exp $
* $NetBSD: uaudio.c,v 1.105 2006/10/04 16:00:15 christos Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/device.h>
#include <sys/ioctl.h>
#endif
#include <sys/tty.h>
#include <sys/file.h>
#include <sys/reboot.h> /* for bootverbose */
#include <sys/select.h>
#include <sys/proc.h>
#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/device.h>
#elif defined(__FreeBSD__)
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/conf.h>
#endif
#include <sys/poll.h>
#if defined(__FreeBSD__)
#include <sys/sysctl.h>
#include <sys/sbuf.h>
#endif
#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/audioio.h>
#include <dev/audio_if.h>
#include <dev/audiovar.h>
#include <dev/mulaw.h>
#include <dev/auconv.h>
#elif defined(__FreeBSD__)
#include <dev/sound/pcm/sound.h> /* XXXXX */
#include <dev/sound/chip.h>
#include "feeder_if.h"
#endif
#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usb_quirks.h>
#if defined(__NetBSD__) || defined(__OpenBSD__)
#include <dev/usb/uaudioreg.h>
#elif defined(__FreeBSD__)
#include <dev/sound/usb/uaudioreg.h>
#include <dev/sound/usb/uaudio.h>
#endif
#if defined(__NetBSD__) || defined(__OpenBSD__)
/* #define UAUDIO_DEBUG */
#else
/* #define USB_DEBUG */
#endif
/* #define UAUDIO_MULTIPLE_ENDPOINTS */
#ifdef USB_DEBUG
#define DPRINTF(x) do { if (uaudiodebug) logprintf x; } while (0)
#define DPRINTFN(n,x) do { if (uaudiodebug>(n)) logprintf x; } while (0)
int uaudiodebug = 0;
#if defined(__FreeBSD__)
SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio");
SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW,
&uaudiodebug, 0, "uaudio debug level");
#endif
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif
#define UAUDIO_NCHANBUFS 6 /* number of outstanding request */
#if defined(__NetBSD__) || defined(__OpenBSD__)
#define UAUDIO_NFRAMES 10 /* ms of sound in each request */
#elif defined(__FreeBSD__)
#define UAUDIO_NFRAMES 20 /* ms of sound in each request */
#endif
#define MIX_MAX_CHAN 8
struct mixerctl {
uint16_t wValue[MIX_MAX_CHAN]; /* using nchan */
uint16_t wIndex;
uint8_t nchan;
uint8_t type;
#define MIX_ON_OFF 1
#define MIX_SIGNED_16 2
#define MIX_UNSIGNED_16 3
#define MIX_SIGNED_8 4
#define MIX_SELECTOR 5
#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_int delta;
u_int mul;
#if defined(__FreeBSD__) /* XXXXX */
unsigned ctl;
#define MAX_SELECTOR_INPUT_PIN 256
uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN];
#endif
uint8_t class;
#if !defined(__FreeBSD__)
char ctlname[MAX_AUDIO_DEV_LEN];
char *ctlunit;
#endif
};
#define MAKE(h,l) (((h) << 8) | (l))
struct as_info {
uint8_t alt;
uint8_t encoding;
uint8_t attributes; /* Copy of bmAttributes of
* usb_audio_streaming_endpoint_descriptor
*/
usbd_interface_handle ifaceh;
const usb_interface_descriptor_t *idesc;
const usb_endpoint_descriptor_audio_t *edesc;
const usb_endpoint_descriptor_audio_t *edesc1;
const struct usb_audio_streaming_type1_descriptor *asf1desc;
int sc_busy; /* currently used */
};
struct chan {
#if defined(__NetBSD__) || defined(__OpenBSD__)
void (*intr)(void *); /* DMA completion intr handler */
void *arg; /* arg for intr() */
#else
struct pcm_channel *pcm_ch;
#endif
usbd_pipe_handle pipe;
usbd_pipe_handle sync_pipe;
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 altidx; /* currently used altidx */
int curchanbuf;
struct chanbuf {
struct chan *chan;
usbd_xfer_handle xfer;
u_char *buffer;
u_int16_t sizes[UAUDIO_NFRAMES];
u_int16_t offsets[UAUDIO_NFRAMES];
u_int16_t size;
} chanbufs[UAUDIO_NCHANBUFS];
struct uaudio_softc *sc; /* our softc */
#if defined(__FreeBSD__)
u_int32_t format;
int precision;
int channels;
#endif
};
struct uaudio_softc {
device_t sc_dev; /* base device */
usbd_device_handle sc_udev; /* USB device */
int sc_ac_iface; /* Audio Control interface */
usbd_interface_handle sc_ac_ifaceh;
struct chan sc_playchan; /* play channel */
struct chan sc_recchan; /* record channel */
int sc_nullalt;
int sc_audio_rev;
struct as_info *sc_alts; /* alternate settings */
int sc_nalts; /* # of alternate settings */
int sc_altflags;
#define HAS_8 0x01
#define HAS_16 0x02
#define HAS_8U 0x04
#define HAS_ALAW 0x08
#define HAS_MULAW 0x10
#define UA_NOFRAC 0x20 /* don't do sample rate adjustment */
#define HAS_24 0x40
#define HAS_32 0x80
int sc_mode; /* play/record capability */
struct mixerctl *sc_ctls; /* mixer controls */
int sc_nctls; /* # of mixer controls */
device_t sc_audiodev;
char sc_dying;
#if defined(__FreeBSD__)
struct sbuf uaudio_sndstat;
int uaudio_sndstat_flag;
int async;
#endif
int sc_vendor;
int sc_product;
int sc_release;
};
struct terminal_list {
int size;
uint16_t terminals[1];
};
#define TERMINAL_LIST_SIZE(N) (offsetof(struct terminal_list, terminals) \
+ sizeof(uint16_t) * (N))
struct io_terminal {
union {
const usb_descriptor_t *desc;
const struct usb_audio_input_terminal *it;
const struct usb_audio_output_terminal *ot;
const struct usb_audio_mixer_unit *mu;
const struct usb_audio_selector_unit *su;
const struct usb_audio_feature_unit *fu;
const struct usb_audio_processing_unit *pu;
const struct usb_audio_extension_unit *eu;
} d;
int inputs_size;
struct terminal_list **inputs; /* list of source input terminals */
struct terminal_list *output; /* list of destination output terminals */
int direct; /* directly connected to an output terminal */
};
#define UAC_OUTPUT 0
#define UAC_INPUT 1
#define UAC_EQUAL 2
#define UAC_RECORD 3
#define UAC_NCLASSES 4
#ifdef USB_DEBUG
#if defined(__FreeBSD__)
#define AudioCinputs "inputs"
#define AudioCoutputs "outputs"
#define AudioCrecord "record"
#define AudioCequalization "equalization"
#endif
static const char *uac_names[] = {
AudioCoutputs, AudioCinputs, AudioCequalization, AudioCrecord,
};
#endif
static usbd_status uaudio_identify_ac
(struct uaudio_softc *, const usb_config_descriptor_t *);
static usbd_status uaudio_identify_as
(struct uaudio_softc *, const usb_config_descriptor_t *);
static usbd_status uaudio_process_as
(struct uaudio_softc *, const char *, int *, int,
const usb_interface_descriptor_t *);
static void uaudio_add_alt(struct uaudio_softc *, const struct as_info *);
static const usb_interface_descriptor_t *uaudio_find_iface
(const char *, int, int *, int);
static void uaudio_mixer_add_ctl(struct uaudio_softc *, struct mixerctl *);
#if defined(__NetBSD__) || defined(__OpenBSD__)
static char *uaudio_id_name
(struct uaudio_softc *, const struct io_terminal *, int);
#endif
#ifdef USB_DEBUG
static void uaudio_dump_cluster(const struct usb_audio_cluster *);
#endif
static struct usb_audio_cluster uaudio_get_cluster
(int, const struct io_terminal *);
static void uaudio_add_input
(struct uaudio_softc *, const struct io_terminal *, int);
static void uaudio_add_output
(struct uaudio_softc *, const struct io_terminal *, int);
static void uaudio_add_mixer
(struct uaudio_softc *, const struct io_terminal *, int);
static void uaudio_add_selector
(struct uaudio_softc *, const struct io_terminal *, int);
#ifdef USB_DEBUG
static const char *uaudio_get_terminal_name(int);
#endif
static int uaudio_determine_class
(const struct io_terminal *, struct mixerctl *);
#if defined(__FreeBSD__)
static const int uaudio_feature_name(const struct io_terminal *,
struct mixerctl *);
#else
static const char *uaudio_feature_name
(const struct io_terminal *, struct mixerctl *);
#endif
static void uaudio_add_feature
(struct uaudio_softc *, const struct io_terminal *, int);
static void uaudio_add_processing_updown
(struct uaudio_softc *, const struct io_terminal *, int);
static void uaudio_add_processing
(struct uaudio_softc *, const struct io_terminal *, int);
static void uaudio_add_extension
(struct uaudio_softc *, const struct io_terminal *, int);
static struct terminal_list *uaudio_merge_terminal_list
(const struct io_terminal *);
static struct terminal_list *uaudio_io_terminaltype
(int, struct io_terminal *, int);
static usbd_status uaudio_identify
(struct uaudio_softc *, const usb_config_descriptor_t *);
static int uaudio_signext(int, int);
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int uaudio_value2bsd(struct mixerctl *, int);
#endif
static int uaudio_bsd2value(struct mixerctl *, int);
static int uaudio_get(struct uaudio_softc *, int, int, int, int, int);
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int uaudio_ctl_get
(struct uaudio_softc *, int, struct mixerctl *, int);
#endif
static void uaudio_set
(struct uaudio_softc *, int, int, int, int, int, int);
static void uaudio_ctl_set
(struct uaudio_softc *, int, struct mixerctl *, int, int);
static usbd_status uaudio_set_speed(struct uaudio_softc *, int, u_int);
static usbd_status uaudio_chan_open(struct uaudio_softc *, struct chan *);
static void uaudio_chan_close(struct uaudio_softc *, struct chan *);
static usbd_status uaudio_chan_alloc_buffers
(struct uaudio_softc *, struct chan *);
static void uaudio_chan_free_buffers(struct uaudio_softc *, struct chan *);
#if defined(__NetBSD__) || defined(__OpenBSD__)
static void uaudio_chan_init
(struct chan *, int, const struct audio_params *, int);
static void uaudio_chan_set_param(struct chan *, u_char *, u_char *, int);
#endif
static void uaudio_chan_ptransfer(struct chan *);
static void uaudio_chan_pintr
(usbd_xfer_handle, usbd_private_handle, usbd_status);
static void uaudio_chan_rtransfer(struct chan *);
static void uaudio_chan_rintr
(usbd_xfer_handle, usbd_private_handle, usbd_status);
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int uaudio_open(void *, int);
static void uaudio_close(void *);
static int uaudio_drain(void *);
static int uaudio_query_encoding(void *, struct audio_encoding *);
static void uaudio_get_minmax_rates
(int, const struct as_info *, const struct audio_params *,
int, u_long *, u_long *);
static int uaudio_match_alt_sub
(int, const struct as_info *, const struct audio_params *, int, u_long);
static int uaudio_match_alt_chan
(int, const struct as_info *, struct audio_params *, int);
static int uaudio_match_alt
(int, const struct as_info *, struct audio_params *, int);
static int uaudio_set_params
(void *, int, int, struct audio_params *, struct audio_params *);
static int uaudio_round_blocksize(void *, int);
static int uaudio_trigger_output
(void *, void *, void *, int, void (*)(void *), void *,
struct audio_params *);
static int uaudio_trigger_input
(void *, void *, void *, int, void (*)(void *), void *,
struct audio_params *);
static int uaudio_halt_in_dma(void *);
static int uaudio_halt_out_dma(void *);
static int uaudio_getdev(void *, struct audio_device *);
static int uaudio_mixer_set_port(void *, mixer_ctrl_t *);
static int uaudio_mixer_get_port(void *, mixer_ctrl_t *);
static int uaudio_query_devinfo(void *, mixer_devinfo_t *);
static int uaudio_get_props(void *);
static const 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,
NULL,
};
static struct audio_device uaudio_device = {
"USB audio",
"",
"uaudio"
};
#elif defined(__FreeBSD__)
static int audio_attach_mi(device_t);
static int uaudio_init_params(struct uaudio_softc * sc, struct chan *ch, int mode);
static int uaudio_sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose);
/* for NetBSD compatibirity */
#define AUMODE_PLAY 0x01
#define AUMODE_RECORD 0x02
#define AUDIO_PROP_FULLDUPLEX 0x01
#define AUDIO_ENCODING_ULAW 1
#define AUDIO_ENCODING_ALAW 2
#define AUDIO_ENCODING_SLINEAR_LE 6
#define AUDIO_ENCODING_SLINEAR_BE 7
#define AUDIO_ENCODING_ULINEAR_LE 8
#define AUDIO_ENCODING_ULINEAR_BE 9
#endif /* FreeBSD */
#if defined(__NetBSD__) || defined(__OpenBSD__)
USB_DECLARE_DRIVER(uaudio);
#elif defined(__FreeBSD__)
USB_DECLARE_DRIVER_INIT(uaudio,
DEVMETHOD(device_suspend, bus_generic_suspend),
DEVMETHOD(device_resume, bus_generic_resume),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(bus_print_child, bus_generic_print_child)
);
#endif
USB_MATCH(uaudio)
{
USB_MATCH_START(uaudio, uaa);
usb_interface_descriptor_t *id;
if (uaa->iface == NULL)
return UMATCH_NONE;
id = usbd_get_interface_descriptor(uaa->iface);
/* Trigger on the control interface. */
if (id == NULL ||
id->bInterfaceClass != UICLASS_AUDIO ||
id->bInterfaceSubClass != UISUBCLASS_AUDIOCONTROL ||
(usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO))
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 err;
int i, j, found;
#if defined(__FreeBSD__)
usbd_devinfo(uaa->device, 0, devinfo);
USB_ATTACH_SETUP;
#else
usbd_devinfo(uaa->device, 0, devinfo, sizeof(devinfo));
printf(": %s\n", devinfo);
#endif
sc->sc_udev = uaa->device;
sc->sc_vendor = uaa->vendor;
sc->sc_product = uaa->product;
sc->sc_release = uaa->release;
#if defined(__FreeBSD__)
if (resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev), "async", &i) == 0 && i != 0)
sc->async = 1;
else
sc->async = 0;
#endif
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
device_get_nameunit(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
err = uaudio_identify(sc, cdesc);
if (err) {
printf("%s: audio descriptors make no sense, error=%d\n",
device_get_nameunit(sc->sc_dev), err);
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] == NULL)
continue;
id = usbd_get_interface_descriptor(uaa->ifaces[i]);
if (id == NULL)
continue;
found = 0;
for (j = 0; j < sc->sc_nalts; j++) {
if (id->bInterfaceNumber ==
sc->sc_alts[j].idesc->bInterfaceNumber) {
sc->sc_alts[j].ifaceh = uaa->ifaces[i];
found = 1;
}
}
if (found)
uaa->ifaces[i] = NULL;
}
for (j = 0; j < sc->sc_nalts; j++) {
if (sc->sc_alts[j].ifaceh == NULL) {
printf("%s: alt %d missing AS interface(s)\n",
device_get_nameunit(sc->sc_dev), j);
USB_ATTACH_ERROR_RETURN;
}
}
printf("%s: audio rev %d.%02x\n", device_get_nameunit(sc->sc_dev),
sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff);
sc->sc_playchan.sc = sc->sc_recchan.sc = sc;
sc->sc_playchan.altidx = -1;
sc->sc_recchan.altidx = -1;
if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_FRAC)
sc->sc_altflags |= UA_NOFRAC;
#ifndef USB_DEBUG
if (bootverbose)
#endif
printf("%s: %d mixer controls\n", device_get_nameunit(sc->sc_dev),
sc->sc_nctls);
#if !defined(__FreeBSD__)
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
USBDEV(sc->sc_dev));
#endif
DPRINTF(("uaudio_attach: doing audio_attach_mi\n"));
#if defined(__OpenBSD__)
audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
#elif defined(__NetBSD__)
sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
#elif defined(__FreeBSD__)
sc->sc_dying = 0;
if (audio_attach_mi(sc->sc_dev)) {
printf("audio_attach_mi failed\n");
USB_ATTACH_ERROR_RETURN;
}
#endif
#if defined(__FreeBSD__)
SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->sc_dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)),
OID_AUTO, "async", CTLFLAG_RW, &sc->async, 0,
"Asynchronous USB request");
#endif
USB_ATTACH_SUCCESS_RETURN;
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
int
uaudio_activate(device_t self, enum devact act)
{
struct uaudio_softc *sc;
int rv;
sc = (struct uaudio_softc *)self;
rv = 0;
switch (act) {
case DVACT_ACTIVATE:
return EOPNOTSUPP;
case DVACT_DEACTIVATE:
if (sc->sc_audiodev != NULL)
rv = config_deactivate(sc->sc_audiodev);
sc->sc_dying = 1;
break;
}
return rv;
}
#endif
#if defined(__NetBSD__) || defined(__OpenBSD__)
int
uaudio_detach(device_t self, int flags)
{
struct uaudio_softc *sc;
int rv;
sc = (struct uaudio_softc *)self;
rv = 0;
/* Wait for outstanding requests to complete. */
usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
if (sc->sc_audiodev != NULL)
rv = config_detach(sc->sc_audiodev, flags);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
USBDEV(sc->sc_dev));
return rv;
}
#elif defined(__FreeBSD__)
USB_DETACH(uaudio)
{
struct sndcard_func *func;
device_t *devlist = NULL;
int err, i, devcount;
USB_DETACH_START(uaudio, sc);
sbuf_delete(&(sc->uaudio_sndstat));
sc->uaudio_sndstat_flag = 0;
sc->sc_dying = 1;
#if 0 /* XXX */
/* Wait for outstanding requests to complete. */
usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
#endif
err = bus_generic_detach(sc->sc_dev);
if (err == 0) {
device_get_children(sc->sc_dev, &devlist, &devcount);
for (i = 0; devlist != NULL && i < devcount; i++) {
func = device_get_ivars(devlist[i]);
if (func != NULL && func->func == SCF_PCM &&
func->varinfo == NULL) {
device_set_ivars(devlist[i], NULL);
free(func, M_DEVBUF);
device_delete_child(sc->sc_dev, devlist[i]);
}
}
if (devlist != NULL)
free(devlist, M_TEMP);
}
return err;
}
#endif
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int
uaudio_query_encoding(void *addr, struct audio_encoding *fp)
{
struct uaudio_softc *sc;
int flags;
int idx;
sc = addr;
flags = sc->sc_altflags;
if (sc->sc_dying)
return EIO;
if (sc->sc_nalts == 0 || flags == 0)
return ENXIO;
idx = fp->index;
switch (idx) {
case 0:
strlcpy(fp->name, AudioEulinear, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_ULINEAR;
fp->precision = 8;
fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
return (0);
case 1:
strlcpy(fp->name, AudioEmulaw, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_ULAW;
fp->precision = 8;
fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
return (0);
case 2:
strlcpy(fp->name, AudioEalaw, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_ALAW;
fp->precision = 8;
fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
return (0);
case 3:
strlcpy(fp->name, AudioEslinear, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_SLINEAR;
fp->precision = 8;
fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
return (0);
case 4:
strlcpy(fp->name, AudioEslinear_le, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
fp->precision = 16;
fp->flags = 0;
return (0);
case 5:
strlcpy(fp->name, AudioEulinear_le, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
fp->precision = 16;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
return (0);
case 6:
strlcpy(fp->name, AudioEslinear_be, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
fp->precision = 16;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
return (0);
case 7:
strlcpy(fp->name, AudioEulinear_be, sizeof(fp->name));
fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
fp->precision = 16;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
return (0);
default:
return (EINVAL);
}
}
#endif
static const usb_interface_descriptor_t *
uaudio_find_iface(const char *buf, int size, int *offsp, int subtype)
{
const usb_interface_descriptor_t *d;
while (*offsp < size) {
d = (const void *)(buf + *offsp);
*offsp += d->bLength;
if (d->bDescriptorType == UDESC_INTERFACE &&
d->bInterfaceClass == UICLASS_AUDIO &&
d->bInterfaceSubClass == subtype)
return d;
}
return NULL;
}
static void
uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct mixerctl *mc)
{
int res;
size_t len;
struct mixerctl *nmc;
#if defined(__FreeBSD__)
if (mc->class < UAC_NCLASSES) {
DPRINTF(("%s: adding %s.%d\n",
__func__, uac_names[mc->class], mc->ctl));
} else {
DPRINTF(("%s: adding %d\n", __func__, mc->ctl));
}
#else
if (mc->class < UAC_NCLASSES) {
DPRINTF(("%s: adding %s.%s\n",
__func__, uac_names[mc->class], mc->ctlname));
} else {
DPRINTF(("%s: adding %s\n", __func__, mc->ctlname));
}
#endif
len = sizeof(*mc) * (sc->sc_nctls + 1);
nmc = malloc(len, M_USBDEV, M_NOWAIT);
if (nmc == NULL) {
printf("uaudio_mixer_add_ctl: no memory\n");
return;
}
/* Copy old data, if there was any */
if (sc->sc_nctls != 0) {
memcpy(nmc, sc->sc_ctls, sizeof(*mc) * (sc->sc_nctls));
free(sc->sc_ctls, M_USBDEV);
}
sc->sc_ctls = nmc;
mc->delta = 0;
if (mc->type == MIX_ON_OFF) {
mc->minval = 0;
mc->maxval = 1;
} else if (mc->type == MIX_SELECTOR) {
;
} else {
/* 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)));
mc->mul = mc->maxval - mc->minval;
if (mc->mul == 0)
mc->mul = 1;
res = uaudio_get(sc, GET_RES, UT_READ_CLASS_INTERFACE,
mc->wValue[0], mc->wIndex,
MIX_SIZE(mc->type));
if (res > 0)
mc->delta = (res * 255 + mc->mul/2) / mc->mul;
}
sc->sc_ctls[sc->sc_nctls++] = *mc;
#ifdef USB_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]));
#if defined(__FreeBSD__)
DPRINTF((" wIndex=%04x type=%d ctl='%d' "
"min=%d max=%d\n",
mc->wIndex, mc->type, mc->ctl,
mc->minval, mc->maxval));
#else
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
}
#endif
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
static char *
uaudio_id_name(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
static char buf[32];
snprintf(buf, sizeof(buf), "i%d", id);
return buf;
}
#endif
#ifdef USB_DEBUG
static void
uaudio_dump_cluster(const struct usb_audio_cluster *cl)
{
static const char *channel_names[16] = {
"LEFT", "RIGHT", "CENTER", "LFE",
"LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER",
"SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP",
"RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15",
};
int cc, i, first;
cc = UGETW(cl->wChannelConfig);
logprintf("cluster: bNrChannels=%u wChannelConfig=0x%.4x",
cl->bNrChannels, cc);
first = TRUE;
for (i = 0; cc != 0; i++) {
if (cc & 1) {
logprintf("%c%s", first ? '<' : ',', channel_names[i]);
first = FALSE;
}
cc = cc >> 1;
}
logprintf("> iChannelNames=%u", cl->iChannelNames);
}
#endif
static struct usb_audio_cluster
uaudio_get_cluster(int id, const struct io_terminal *iot)
{
struct usb_audio_cluster r;
const usb_descriptor_t *dp;
int i;
for (i = 0; i < 25; i++) { /* avoid infinite loops */
dp = iot[id].d.desc;
if (dp == 0)
goto bad;
switch (dp->bDescriptorSubtype) {
case UDESCSUB_AC_INPUT:
r.bNrChannels = iot[id].d.it->bNrChannels;
USETW(r.wChannelConfig, UGETW(iot[id].d.it->wChannelConfig));
r.iChannelNames = iot[id].d.it->iChannelNames;
return r;
case UDESCSUB_AC_OUTPUT:
id = iot[id].d.ot->bSourceId;
break;
case UDESCSUB_AC_MIXER:
r = *(const struct usb_audio_cluster *)
&iot[id].d.mu->baSourceId[iot[id].d.mu->bNrInPins];
return r;
case UDESCSUB_AC_SELECTOR:
/* XXX This is not really right */
id = iot[id].d.su->baSourceId[0];
break;
case UDESCSUB_AC_FEATURE:
id = iot[id].d.fu->bSourceId;
break;
case UDESCSUB_AC_PROCESSING:
r = *(const struct usb_audio_cluster *)
&iot[id].d.pu->baSourceId[iot[id].d.pu->bNrInPins];
return r;
case UDESCSUB_AC_EXTENSION:
r = *(const struct usb_audio_cluster *)
&iot[id].d.eu->baSourceId[iot[id].d.eu->bNrInPins];
return r;
default:
goto bad;
}
}
bad:
printf("uaudio_get_cluster: bad data\n");
memset(&r, 0, sizeof r);
return r;
}
static void
uaudio_add_input(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
#ifdef USB_DEBUG
const struct usb_audio_input_terminal *d = iot[id].d.it;
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
}
static void
uaudio_add_output(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
#ifdef USB_DEBUG
const struct usb_audio_output_terminal *d;
d = iot[id].d.ot;
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
}
static void
uaudio_add_mixer(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
const struct usb_audio_mixer_unit *d = iot[id].d.mu;
const struct usb_audio_mixer_unit_1 *d1;
int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k;
const 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], iot).bNrChannels;
/* and the number of output channels */
d1 = (const 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);
uaudio_determine_class(&iot[id], &mix);
mix.type = MIX_SIGNED_16;
#if !defined(__FreeBSD__) /* XXXXX */
mix.ctlunit = AudioNvolume;
#endif
#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], iot).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);
}
#if !defined(__FreeBSD__)
snprintf(mix.ctlname, sizeof(mix.ctlname), "mix%d-%s",
d->bUnitId, uaudio_id_name(sc, iot,
d->baSourceId[i]));
#endif
mix.nchan = chs;
uaudio_mixer_add_ctl(sc, &mix);
} else {
/* XXX */
}
#undef BIT
p += chs;
}
}
static void
uaudio_add_selector(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
const struct usb_audio_selector_unit *d;
struct mixerctl mix;
#if !defined(__FreeBSD__)
int i, wp;
#else
int i;
struct mixerctl dummy;
#endif
d = iot[id].d.su;
DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n",
d->bUnitId, d->bNrInPins));
mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
mix.wValue[0] = MAKE(0, 0);
uaudio_determine_class(&iot[id], &mix);
mix.nchan = 1;
mix.type = MIX_SELECTOR;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
mix.minval = 1;
mix.maxval = d->bNrInPins;
mix.mul = mix.maxval - mix.minval;
for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
mix.slctrtype[i] = SOUND_MIXER_NRDEVICES;
}
for (i = mix.minval; i <= mix.maxval; i++) {
mix.slctrtype[i - 1] = uaudio_feature_name(&iot[d->baSourceId[i - 1]], &dummy);
}
#else
mix.ctlunit = "";
mix.minval = 1;
mix.maxval = d->bNrInPins;
mix.mul = mix.maxval - mix.minval;
wp = snprintf(mix.ctlname, MAX_AUDIO_DEV_LEN, "sel%d-", d->bUnitId);
for (i = 1; i <= d->bNrInPins; i++) {
wp += snprintf(mix.ctlname + wp, MAX_AUDIO_DEV_LEN - wp,
"i%d", d->baSourceId[i - 1]);
if (wp > MAX_AUDIO_DEV_LEN - 1)
break;
}
#endif
uaudio_mixer_add_ctl(sc, &mix);
}
#ifdef USB_DEBUG
static const char *
uaudio_get_terminal_name(int terminal_type)
{
static char buf[100];
switch (terminal_type) {
/* USB terminal types */
case UAT_UNDEFINED: return "UAT_UNDEFINED";
case UAT_STREAM: return "UAT_STREAM";
case UAT_VENDOR: return "UAT_VENDOR";
/* input terminal types */
case UATI_UNDEFINED: return "UATI_UNDEFINED";
case UATI_MICROPHONE: return "UATI_MICROPHONE";
case UATI_DESKMICROPHONE: return "UATI_DESKMICROPHONE";
case UATI_PERSONALMICROPHONE: return "UATI_PERSONALMICROPHONE";
case UATI_OMNIMICROPHONE: return "UATI_OMNIMICROPHONE";
case UATI_MICROPHONEARRAY: return "UATI_MICROPHONEARRAY";
case UATI_PROCMICROPHONEARR: return "UATI_PROCMICROPHONEARR";
/* output terminal types */
case UATO_UNDEFINED: return "UATO_UNDEFINED";
case UATO_SPEAKER: return "UATO_SPEAKER";
case UATO_HEADPHONES: return "UATO_HEADPHONES";
case UATO_DISPLAYAUDIO: return "UATO_DISPLAYAUDIO";
case UATO_DESKTOPSPEAKER: return "UATO_DESKTOPSPEAKER";
case UATO_ROOMSPEAKER: return "UATO_ROOMSPEAKER";
case UATO_COMMSPEAKER: return "UATO_COMMSPEAKER";
case UATO_SUBWOOFER: return "UATO_SUBWOOFER";
/* bidir terminal types */
case UATB_UNDEFINED: return "UATB_UNDEFINED";
case UATB_HANDSET: return "UATB_HANDSET";
case UATB_HEADSET: return "UATB_HEADSET";
case UATB_SPEAKERPHONE: return "UATB_SPEAKERPHONE";
case UATB_SPEAKERPHONEESUP: return "UATB_SPEAKERPHONEESUP";
case UATB_SPEAKERPHONEECANC: return "UATB_SPEAKERPHONEECANC";
/* telephony terminal types */
case UATT_UNDEFINED: return "UATT_UNDEFINED";
case UATT_PHONELINE: return "UATT_PHONELINE";
case UATT_TELEPHONE: return "UATT_TELEPHONE";
case UATT_DOWNLINEPHONE: return "UATT_DOWNLINEPHONE";
/* external terminal types */
case UATE_UNDEFINED: return "UATE_UNDEFINED";
case UATE_ANALOGCONN: return "UATE_ANALOGCONN";
case UATE_LINECONN: return "UATE_LINECONN";
case UATE_LEGACYCONN: return "UATE_LEGACYCONN";
case UATE_DIGITALAUIFC: return "UATE_DIGITALAUIFC";
case UATE_SPDIF: return "UATE_SPDIF";
case UATE_1394DA: return "UATE_1394DA";
case UATE_1394DV: return "UATE_1394DV";
/* embedded function terminal types */
case UATF_UNDEFINED: return "UATF_UNDEFINED";
case UATF_CALIBNOISE: return "UATF_CALIBNOISE";
case UATF_EQUNOISE: return "UATF_EQUNOISE";
case UATF_CDPLAYER: return "UATF_CDPLAYER";
case UATF_DAT: return "UATF_DAT";
case UATF_DCC: return "UATF_DCC";
case UATF_MINIDISK: return "UATF_MINIDISK";
case UATF_ANALOGTAPE: return "UATF_ANALOGTAPE";
case UATF_PHONOGRAPH: return "UATF_PHONOGRAPH";
case UATF_VCRAUDIO: return "UATF_VCRAUDIO";
case UATF_VIDEODISCAUDIO: return "UATF_VIDEODISCAUDIO";
case UATF_DVDAUDIO: return "UATF_DVDAUDIO";
case UATF_TVTUNERAUDIO: return "UATF_TVTUNERAUDIO";
case UATF_SATELLITE: return "UATF_SATELLITE";
case UATF_CABLETUNER: return "UATF_CABLETUNER";
case UATF_DSS: return "UATF_DSS";
case UATF_RADIORECV: return "UATF_RADIORECV";
case UATF_RADIOXMIT: return "UATF_RADIOXMIT";
case UATF_MULTITRACK: return "UATF_MULTITRACK";
case UATF_SYNTHESIZER: return "UATF_SYNTHESIZER";
default:
snprintf(buf, sizeof(buf), "unknown type (0x%.4x)", terminal_type);
return buf;
}
}
#endif
static int
uaudio_determine_class(const struct io_terminal *iot, struct mixerctl *mix)
{
int terminal_type;
if (iot == NULL || iot->output == NULL) {
mix->class = UAC_OUTPUT;
return 0;
}
terminal_type = 0;
if (iot->output->size == 1)
terminal_type = iot->output->terminals[0];
/*
* If the only output terminal is USB,
* the class is UAC_RECORD.
*/
if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
mix->class = UAC_RECORD;
if (iot->inputs_size == 1
&& iot->inputs[0] != NULL
&& iot->inputs[0]->size == 1)
return iot->inputs[0]->terminals[0];
else
return 0;
}
/*
* If the ultimate destination of the unit is just one output
* terminal and the unit is connected to the output terminal
* directly, the class is UAC_OUTPUT.
*/
if (terminal_type != 0 && iot->direct) {
mix->class = UAC_OUTPUT;
return terminal_type;
}
/*
* If the unit is connected to just one input terminal,
* the class is UAC_INPUT.
*/
if (iot->inputs_size == 1 && iot->inputs[0] != NULL
&& iot->inputs[0]->size == 1) {
mix->class = UAC_INPUT;
return iot->inputs[0]->terminals[0];
}
/*
* Otherwise, the class is UAC_OUTPUT.
*/
mix->class = UAC_OUTPUT;
return terminal_type;
}
#if defined(__FreeBSD__)
const int
uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
{
int terminal_type;
terminal_type = uaudio_determine_class(iot, mix);
if (mix->class == UAC_RECORD && terminal_type == 0)
return SOUND_MIXER_IMIX;
DPRINTF(("%s: terminal_type=%s\n", __func__,
uaudio_get_terminal_name(terminal_type)));
switch (terminal_type) {
case UAT_STREAM:
return SOUND_MIXER_PCM;
case UATI_MICROPHONE:
case UATI_DESKMICROPHONE:
case UATI_PERSONALMICROPHONE:
case UATI_OMNIMICROPHONE:
case UATI_MICROPHONEARRAY:
case UATI_PROCMICROPHONEARR:
return SOUND_MIXER_MIC;
case UATO_SPEAKER:
case UATO_DESKTOPSPEAKER:
case UATO_ROOMSPEAKER:
case UATO_COMMSPEAKER:
return SOUND_MIXER_SPEAKER;
case UATE_ANALOGCONN:
case UATE_LINECONN:
case UATE_LEGACYCONN:
return SOUND_MIXER_LINE;
case UATE_DIGITALAUIFC:
case UATE_SPDIF:
case UATE_1394DA:
case UATE_1394DV:
return SOUND_MIXER_ALTPCM;
case UATF_CDPLAYER:
return SOUND_MIXER_CD;
case UATF_SYNTHESIZER:
return SOUND_MIXER_SYNTH;
case UATF_VIDEODISCAUDIO:
case UATF_DVDAUDIO:
case UATF_TVTUNERAUDIO:
return SOUND_MIXER_VIDEO;
/* telephony terminal types */
case UATT_UNDEFINED:
case UATT_PHONELINE:
case UATT_TELEPHONE:
case UATT_DOWNLINEPHONE:
return SOUND_MIXER_PHONEIN;
/* return SOUND_MIXER_PHONEOUT;*/
case UATF_RADIORECV:
case UATF_RADIOXMIT:
return SOUND_MIXER_RADIO;
case UAT_UNDEFINED:
case UAT_VENDOR:
case UATI_UNDEFINED:
/* output terminal types */
case UATO_UNDEFINED:
case UATO_DISPLAYAUDIO:
case UATO_SUBWOOFER:
case UATO_HEADPHONES:
/* bidir terminal types */
case UATB_UNDEFINED:
case UATB_HANDSET:
case UATB_HEADSET:
case UATB_SPEAKERPHONE:
case UATB_SPEAKERPHONEESUP:
case UATB_SPEAKERPHONEECANC:
/* external terminal types */
case UATE_UNDEFINED:
/* embedded function terminal types */
case UATF_UNDEFINED:
case UATF_CALIBNOISE:
case UATF_EQUNOISE:
case UATF_DAT:
case UATF_DCC:
case UATF_MINIDISK:
case UATF_ANALOGTAPE:
case UATF_PHONOGRAPH:
case UATF_VCRAUDIO:
case UATF_SATELLITE:
case UATF_CABLETUNER:
case UATF_DSS:
case UATF_MULTITRACK:
case 0xffff:
default:
DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type));
return SOUND_MIXER_VOLUME;
}
return SOUND_MIXER_VOLUME;
}
#else
static const char *
uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
{
int terminal_type;
terminal_type = uaudio_determine_class(iot, mix);
if (mix->class == UAC_RECORD && terminal_type == 0)
return AudioNmixerout;
DPRINTF(("%s: terminal_type=%s\n", __func__,
uaudio_get_terminal_name(terminal_type)));
switch (terminal_type) {
case UAT_STREAM:
return AudioNdac;
case UATI_MICROPHONE:
case UATI_DESKMICROPHONE:
case UATI_PERSONALMICROPHONE:
case UATI_OMNIMICROPHONE:
case UATI_MICROPHONEARRAY:
case UATI_PROCMICROPHONEARR:
return AudioNmicrophone;
case UATO_SPEAKER:
case UATO_DESKTOPSPEAKER:
case UATO_ROOMSPEAKER:
case UATO_COMMSPEAKER:
return AudioNspeaker;
case UATO_HEADPHONES:
return AudioNheadphone;
case UATO_SUBWOOFER:
return AudioNlfe;
/* telephony terminal types */
case UATT_UNDEFINED:
case UATT_PHONELINE:
case UATT_TELEPHONE:
case UATT_DOWNLINEPHONE:
return "phone";
case UATE_ANALOGCONN:
case UATE_LINECONN:
case UATE_LEGACYCONN:
return AudioNline;
case UATE_DIGITALAUIFC:
case UATE_SPDIF:
case UATE_1394DA:
case UATE_1394DV:
return AudioNaux;
case UATF_CDPLAYER:
return AudioNcd;
case UATF_SYNTHESIZER:
return AudioNfmsynth;
case UATF_VIDEODISCAUDIO:
case UATF_DVDAUDIO:
case UATF_TVTUNERAUDIO:
return AudioNvideo;
case UAT_UNDEFINED:
case UAT_VENDOR:
case UATI_UNDEFINED:
/* output terminal types */
case UATO_UNDEFINED:
case UATO_DISPLAYAUDIO:
/* bidir terminal types */
case UATB_UNDEFINED:
case UATB_HANDSET:
case UATB_HEADSET:
case UATB_SPEAKERPHONE:
case UATB_SPEAKERPHONEESUP:
case UATB_SPEAKERPHONEECANC:
/* external terminal types */
case UATE_UNDEFINED:
/* embedded function terminal types */
case UATF_UNDEFINED:
case UATF_CALIBNOISE:
case UATF_EQUNOISE:
case UATF_DAT:
case UATF_DCC:
case UATF_MINIDISK:
case UATF_ANALOGTAPE:
case UATF_PHONOGRAPH:
case UATF_VCRAUDIO:
case UATF_SATELLITE:
case UATF_CABLETUNER:
case UATF_DSS:
case UATF_RADIORECV:
case UATF_RADIOXMIT:
case UATF_MULTITRACK:
case 0xffff:
default:
DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type));
return AudioNmaster;
}
return AudioNmaster;
}
#endif
static void
uaudio_add_feature(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
const struct usb_audio_feature_unit *d;
const uByte *ctls;
int ctlsize;
int nchan;
u_int fumask, mmask, cmask;
struct mixerctl mix;
int chan, ctl, i, unit;
#if defined(__FreeBSD__)
int mixernumber;
#else
const char *mixername;
#endif
#define GET(i) (ctls[(i)*ctlsize] | \
(ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0))
d = iot[id].d.fu;
ctls = d->bmaControls;
ctlsize = d->bControlSize;
nchan = (d->bLength - 7) / ctlsize;
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);
}
#if !defined(__FreeBSD__)
DPRINTFN(1,("uaudio_add_feature: bUnitId=%d, "
"%d channels, mmask=0x%04x, cmask=0x%04x\n",
d->bUnitId, nchan, mmask, cmask));
#endif
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
#if defined(__FreeBSD__)
mixernumber = uaudio_feature_name(&iot[id], &mix);
#else
mixername = uaudio_feature_name(&iot[id], &mix);
#endif
switch (ctl) {
case MUTE_CONTROL:
mix.type = MIX_ON_OFF;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_NRDEVICES;
#else
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNmute);
#endif
break;
case VOLUME_CONTROL:
mix.type = MIX_SIGNED_16;
#if defined(__FreeBSD__)
mix.ctl = mixernumber;
#else
mix.ctlunit = AudioNvolume;
strlcpy(mix.ctlname, mixername, sizeof(mix.ctlname));
#endif
break;
case BASS_CONTROL:
mix.type = MIX_SIGNED_8;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_BASS;
#else
mix.ctlunit = AudioNbass;
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNbass);
#endif
break;
case MID_CONTROL:
mix.type = MIX_SIGNED_8;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
#else
mix.ctlunit = AudioNmid;
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNmid);
#endif
break;
case TREBLE_CONTROL:
mix.type = MIX_SIGNED_8;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_TREBLE;
#else
mix.ctlunit = AudioNtreble;
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNtreble);
#endif
break;
case GRAPHIC_EQUALIZER_CONTROL:
continue; /* XXX don't add anything */
break;
case AGC_CONTROL:
mix.type = MIX_ON_OFF;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
#else
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname), "%s.%s",
mixername, AudioNagc);
#endif
break;
case DELAY_CONTROL:
mix.type = MIX_UNSIGNED_16;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
#else
mix.ctlunit = "4 ms";
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNdelay);
#endif
break;
case BASS_BOOST_CONTROL:
mix.type = MIX_ON_OFF;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
#else
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNbassboost);
#endif
break;
case LOUDNESS_CONTROL:
mix.type = MIX_ON_OFF;
#if defined(__FreeBSD__)
mix.ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
#else
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname),
"%s.%s", mixername, AudioNloudness);
#endif
break;
}
uaudio_mixer_add_ctl(sc, &mix);
}
}
static void
uaudio_add_processing_updown(struct uaudio_softc *sc,
const struct io_terminal *iot, int id)
{
const struct usb_audio_processing_unit *d;
const struct usb_audio_processing_unit_1 *d1;
const struct usb_audio_processing_unit_updown *ud;
struct mixerctl mix;
int i;
d = iot[id].d.pu;
d1 = (const struct usb_audio_processing_unit_1 *)
&d->baSourceId[d->bNrInPins];
ud = (const struct usb_audio_processing_unit_updown *)
&d1->bmControls[d1->bControlSize];
DPRINTFN(2,("uaudio_add_processing_updown: bUnitId=%d bNrModes=%d\n",
d->bUnitId, ud->bNrModes));
if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
DPRINTF(("uaudio_add_processing_updown: no mode select\n"));
return;
}
mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
mix.nchan = 1;
mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0);
uaudio_determine_class(&iot[id], &mix);
mix.type = MIX_ON_OFF; /* XXX */
#if !defined(__FreeBSD__)
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d-mode", d->bUnitId);
#endif
for (i = 0; i < ud->bNrModes; i++) {
DPRINTFN(2,("uaudio_add_processing_updown: i=%d bm=0x%x\n",
i, UGETW(ud->waModes[i])));
/* XXX */
}
uaudio_mixer_add_ctl(sc, &mix);
}
static void
uaudio_add_processing(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
const struct usb_audio_processing_unit *d;
const struct usb_audio_processing_unit_1 *d1;
int ptype;
struct mixerctl mix;
d = iot[id].d.pu;
d1 = (const struct usb_audio_processing_unit_1 *)
&d->baSourceId[d->bNrInPins];
ptype = UGETW(d->wProcessType);
DPRINTFN(2,("uaudio_add_processing: wProcessType=%d bUnitId=%d "
"bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins));
if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
mix.nchan = 1;
mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0);
uaudio_determine_class(&iot[id], &mix);
mix.type = MIX_ON_OFF;
#if !defined(__FreeBSD__)
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d.%d-enable",
d->bUnitId, ptype);
#endif
uaudio_mixer_add_ctl(sc, &mix);
}
switch(ptype) {
case UPDOWNMIX_PROCESS:
uaudio_add_processing_updown(sc, iot, id);
break;
case DOLBY_PROLOGIC_PROCESS:
case P3D_STEREO_EXTENDER_PROCESS:
case REVERBATION_PROCESS:
case CHORUS_PROCESS:
case DYN_RANGE_COMP_PROCESS:
default:
#ifdef USB_DEBUG
printf("uaudio_add_processing: unit %d, type=%d not impl.\n",
d->bUnitId, ptype);
#endif
break;
}
}
static void
uaudio_add_extension(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
{
const struct usb_audio_extension_unit *d;
const struct usb_audio_extension_unit_1 *d1;
struct mixerctl mix;
d = iot[id].d.eu;
d1 = (const struct usb_audio_extension_unit_1 *)
&d->baSourceId[d->bNrInPins];
DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n",
d->bUnitId, d->bNrInPins));
if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_XU)
return;
if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
mix.nchan = 1;
mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0);
uaudio_determine_class(&iot[id], &mix);
mix.type = MIX_ON_OFF;
#if !defined(__FreeBSD__)
mix.ctlunit = "";
snprintf(mix.ctlname, sizeof(mix.ctlname), "ext%d-enable",
d->bUnitId);
#endif
uaudio_mixer_add_ctl(sc, &mix);
}
}
static struct terminal_list*
uaudio_merge_terminal_list(const struct io_terminal *iot)
{
struct terminal_list *tml;
uint16_t *ptm;
int i, len;
len = 0;
if (iot->inputs == NULL)
return NULL;
for (i = 0; i < iot->inputs_size; i++) {
if (iot->inputs[i] != NULL)
len += iot->inputs[i]->size;
}
tml = malloc(TERMINAL_LIST_SIZE(len), M_TEMP, M_NOWAIT);
if (tml == NULL) {
printf("uaudio_merge_terminal_list: no memory\n");
return NULL;
}
tml->size = 0;
ptm = tml->terminals;
for (i = 0; i < iot->inputs_size; i++) {
if (iot->inputs[i] == NULL)
continue;
if (iot->inputs[i]->size > len)
break;
memcpy(ptm, iot->inputs[i]->terminals,
iot->inputs[i]->size * sizeof(uint16_t));
tml->size += iot->inputs[i]->size;
ptm += iot->inputs[i]->size;
len -= iot->inputs[i]->size;
}
return tml;
}
static struct terminal_list *
uaudio_io_terminaltype(int outtype, struct io_terminal *iot, int id)
{
struct terminal_list *tml;
struct io_terminal *it;
int src_id, i;
it = &iot[id];
if (it->output != NULL) {
/* already has outtype? */
for (i = 0; i < it->output->size; i++)
if (it->output->terminals[i] == outtype)
return uaudio_merge_terminal_list(it);
tml = malloc(TERMINAL_LIST_SIZE(it->output->size + 1),
M_TEMP, M_NOWAIT);
if (tml == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return uaudio_merge_terminal_list(it);
}
memcpy(tml, it->output, TERMINAL_LIST_SIZE(it->output->size));
tml->terminals[it->output->size] = outtype;
tml->size++;
free(it->output, M_TEMP);
it->output = tml;
if (it->inputs != NULL) {
for (i = 0; i < it->inputs_size; i++)
if (it->inputs[i] != NULL)
free(it->inputs[i], M_TEMP);
free(it->inputs, M_TEMP);
}
it->inputs_size = 0;
it->inputs = NULL;
} else { /* end `iot[id] != NULL' */
it->inputs_size = 0;
it->inputs = NULL;
it->output = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
if (it->output == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
it->output->terminals[0] = outtype;
it->output->size = 1;
it->direct = FALSE;
}
switch (it->d.desc->bDescriptorSubtype) {
case UDESCSUB_AC_INPUT:
it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
tml = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
if (tml == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
free(it->inputs, M_TEMP);
it->inputs = NULL;
return NULL;
}
it->inputs[0] = tml;
tml->terminals[0] = UGETW(it->d.it->wTerminalType);
tml->size = 1;
it->inputs_size = 1;
return uaudio_merge_terminal_list(it);
case UDESCSUB_AC_FEATURE:
src_id = it->d.fu->bSourceId;
it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return uaudio_io_terminaltype(outtype, iot, src_id);
}
it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
it->inputs_size = 1;
return uaudio_merge_terminal_list(it);
case UDESCSUB_AC_OUTPUT:
it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
src_id = it->d.ot->bSourceId;
it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
it->inputs_size = 1;
iot[src_id].direct = TRUE;
return NULL;
case UDESCSUB_AC_MIXER:
it->inputs_size = 0;
it->inputs = malloc(sizeof(struct terminal_list *)
* it->d.mu->bNrInPins, M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
for (i = 0; i < it->d.mu->bNrInPins; i++) {
src_id = it->d.mu->baSourceId[i];
it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
src_id);
it->inputs_size++;
}
return uaudio_merge_terminal_list(it);
case UDESCSUB_AC_SELECTOR:
it->inputs_size = 0;
it->inputs = malloc(sizeof(struct terminal_list *)
* it->d.su->bNrInPins, M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
for (i = 0; i < it->d.su->bNrInPins; i++) {
src_id = it->d.su->baSourceId[i];
it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
src_id);
it->inputs_size++;
}
return uaudio_merge_terminal_list(it);
case UDESCSUB_AC_PROCESSING:
it->inputs_size = 0;
it->inputs = malloc(sizeof(struct terminal_list *)
* it->d.pu->bNrInPins, M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
for (i = 0; i < it->d.pu->bNrInPins; i++) {
src_id = it->d.pu->baSourceId[i];
it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
src_id);
it->inputs_size++;
}
return uaudio_merge_terminal_list(it);
case UDESCSUB_AC_EXTENSION:
it->inputs_size = 0;
it->inputs = malloc(sizeof(struct terminal_list *)
* it->d.eu->bNrInPins, M_TEMP, M_NOWAIT);
if (it->inputs == NULL) {
printf("uaudio_io_terminaltype: no memory\n");
return NULL;
}
for (i = 0; i < it->d.eu->bNrInPins; i++) {
src_id = it->d.eu->baSourceId[i];
it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
src_id);
it->inputs_size++;
}
return uaudio_merge_terminal_list(it);
case UDESCSUB_AC_HEADER:
default:
return NULL;
}
}
static usbd_status
uaudio_identify(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
{
usbd_status err;
err = uaudio_identify_ac(sc, cdesc);
if (err)
return err;
return uaudio_identify_as(sc, cdesc);
}
static void
uaudio_add_alt(struct uaudio_softc *sc, const struct as_info *ai)
{
size_t len;
struct as_info *nai;
len = sizeof(*ai) * (sc->sc_nalts + 1);
nai = malloc(len, M_USBDEV, M_NOWAIT);
if (nai == NULL) {
printf("uaudio_add_alt: no memory\n");
return;
}
/* Copy old data, if there was any */
if (sc->sc_nalts != 0) {
memcpy(nai, sc->sc_alts, sizeof(*ai) * (sc->sc_nalts));
free(sc->sc_alts, M_USBDEV);
}
sc->sc_alts = nai;
DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n",
ai->alt, ai->encoding));
sc->sc_alts[sc->sc_nalts++] = *ai;
}
static usbd_status
uaudio_process_as(struct uaudio_softc *sc, const char *buf, int *offsp,
int size, const usb_interface_descriptor_t *id)
#define offs (*offsp)
{
const struct usb_audio_streaming_interface_descriptor *asid;
const struct usb_audio_streaming_type1_descriptor *asf1d;
const usb_endpoint_descriptor_audio_t *ed;
const usb_endpoint_descriptor_audio_t *epdesc1;
const struct usb_audio_streaming_endpoint_descriptor *sed;
int format, chan, prec, enc;
int dir, type, sync;
struct as_info ai;
const char *format_str;
asid = (const void *)(buf + offs);
if (asid->bDescriptorType != UDESC_CS_INTERFACE ||
asid->bDescriptorSubtype != AS_GENERAL)
return USBD_INVAL;
DPRINTF(("uaudio_process_as: asid: bTerminakLink=%d wFormatTag=%d\n",
asid->bTerminalLink, UGETW(asid->wFormatTag)));
offs += asid->bLength;
if (offs > size)
return USBD_INVAL;
asf1d = (const 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",
device_get_nameunit(sc->sc_dev), UGETW(asid->wFormatTag));
return USBD_NORMAL_COMPLETION;
}
ed = (const void *)(buf + offs);
if (ed->bDescriptorType != UDESC_ENDPOINT)
return USBD_INVAL;
DPRINTF(("uaudio_process_as: endpoint[0] 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);
if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_INP_ASYNC) &&
dir == UE_DIR_IN && type == UE_ISO_ADAPT)
type = UE_ISO_ASYNC;
/* We can't handle endpoints that need a sync pipe yet. */
sync = FALSE;
if (dir == UE_DIR_IN && type == UE_ISO_ADAPT) {
sync = TRUE;
#ifndef UAUDIO_MULTIPLE_ENDPOINTS
printf("%s: ignored input endpoint of type adaptive\n",
device_get_nameunit(sc->sc_dev));
return USBD_NORMAL_COMPLETION;
#endif
}
if (dir != UE_DIR_IN && type == UE_ISO_ASYNC) {
sync = TRUE;
#ifndef UAUDIO_MULTIPLE_ENDPOINTS
printf("%s: ignored output endpoint of type async\n",
device_get_nameunit(sc->sc_dev));
return USBD_NORMAL_COMPLETION;
#endif
}
sed = (const void *)(buf + offs);
if (sed->bDescriptorType != UDESC_CS_ENDPOINT ||
sed->bDescriptorSubtype != AS_GENERAL)
return USBD_INVAL;
DPRINTF((" streadming_endpoint: offset=%d bLength=%d\n", offs, sed->bLength));
offs += sed->bLength;
if (offs > size)
return USBD_INVAL;
#ifdef UAUDIO_MULTIPLE_ENDPOINTS
if (sync && id->bNumEndpoints <= 1) {
printf("%s: a sync-pipe endpoint but no other endpoint\n",
device_get_nameunit(sc->sc_dev));
return USBD_INVAL;
}
#endif
if (!sync && id->bNumEndpoints > 1) {
printf("%s: non sync-pipe endpoint but multiple endpoints\n",
device_get_nameunit(sc->sc_dev));
return USBD_INVAL;
}
epdesc1 = NULL;
if (id->bNumEndpoints > 1) {
epdesc1 = (const void*)(buf + offs);
if (epdesc1->bDescriptorType != UDESC_ENDPOINT)
return USBD_INVAL;
DPRINTF(("uaudio_process_as: endpoint[1] bLength=%d "
"bDescriptorType=%d bEndpointAddress=%d "
"bmAttributes=0x%x wMaxPacketSize=%d bInterval=%d "
"bRefresh=%d bSynchAddress=%d\n",
epdesc1->bLength, epdesc1->bDescriptorType,
epdesc1->bEndpointAddress, epdesc1->bmAttributes,
UGETW(epdesc1->wMaxPacketSize), epdesc1->bInterval,
epdesc1->bRefresh, epdesc1->bSynchAddress));
offs += epdesc1->bLength;
if (offs > size)
return USBD_INVAL;
if (epdesc1->bSynchAddress != 0) {
printf("%s: invalid endpoint: bSynchAddress=0\n",
device_get_nameunit(sc->sc_dev));
return USBD_INVAL;
}
if (UE_GET_XFERTYPE(epdesc1->bmAttributes) != UE_ISOCHRONOUS) {
printf("%s: invalid endpoint: bmAttributes=0x%x\n",
device_get_nameunit(sc->sc_dev), epdesc1->bmAttributes);
return USBD_INVAL;
}
if (epdesc1->bEndpointAddress != ed->bSynchAddress) {
printf("%s: invalid endpoint addresses: "
"ep[0]->bSynchAddress=0x%x "
"ep[1]->bEndpointAddress=0x%x\n",
device_get_nameunit(sc->sc_dev), ed->bSynchAddress,
epdesc1->bEndpointAddress);
return USBD_INVAL;
}
/* UE_GET_ADDR(epdesc1->bEndpointAddress), and epdesc1->bRefresh */
}
format = UGETW(asid->wFormatTag);
chan = asf1d->bNrChannels;
prec = asf1d->bBitResolution;
if (prec != 8 && prec != 16 && prec != 24 && prec != 32) {
printf("%s: ignored setting with precision %d\n",
device_get_nameunit(sc->sc_dev), prec);
return USBD_NORMAL_COMPLETION;
}
switch (format) {
case UA_FMT_PCM:
if (prec == 8) {
sc->sc_altflags |= HAS_8;
} else if (prec == 16) {
sc->sc_altflags |= HAS_16;
} else if (prec == 24) {
sc->sc_altflags |= HAS_24;
} else if (prec == 32) {
sc->sc_altflags |= HAS_32;
}
enc = AUDIO_ENCODING_SLINEAR_LE;
format_str = "pcm";
break;
case UA_FMT_PCM8:
enc = AUDIO_ENCODING_ULINEAR_LE;
sc->sc_altflags |= HAS_8U;
format_str = "pcm8";
break;
case UA_FMT_ALAW:
enc = AUDIO_ENCODING_ALAW;
sc->sc_altflags |= HAS_ALAW;
format_str = "alaw";
break;
case UA_FMT_MULAW:
enc = AUDIO_ENCODING_ULAW;
sc->sc_altflags |= HAS_MULAW;
format_str = "mulaw";
break;
case UA_FMT_IEEE_FLOAT:
default:
printf("%s: ignored setting with format %d\n",
device_get_nameunit(sc->sc_dev), format);
return USBD_NORMAL_COMPLETION;
}
#ifdef USB_DEBUG
printf("%s: %s: %dch, %d/%dbit, %s,", device_get_nameunit(sc->sc_dev),
dir == UE_DIR_IN ? "recording" : "playback",
chan, prec, asf1d->bSubFrameSize * 8, format_str);
if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
printf(" %d-%dHz\n", UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
} else {
int r;
printf(" %d", UA_GETSAMP(asf1d, 0));
for (r = 1; r < asf1d->bSamFreqType; r++)
printf(",%d", UA_GETSAMP(asf1d, r));
printf("Hz\n");
}
#endif
#if defined(__FreeBSD__)
if (sc->uaudio_sndstat_flag != 0) {
sbuf_printf(&(sc->uaudio_sndstat), "\n\t");
sbuf_printf(&(sc->uaudio_sndstat),
"mode %d:(%s) %dch, %d/%dbit, %s,",
id->bAlternateSetting,
dir == UE_DIR_IN ? "input" : "output",
chan, prec, asf1d->bSubFrameSize * 8, format_str);
if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
sbuf_printf(&(sc->uaudio_sndstat), " %d-%dHz",
UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
} else {
int r;
sbuf_printf(&(sc->uaudio_sndstat),
" %d", UA_GETSAMP(asf1d, 0));
for (r = 1; r < asf1d->bSamFreqType; r++)
sbuf_printf(&(sc->uaudio_sndstat),
",%d", UA_GETSAMP(asf1d, r));
sbuf_printf(&(sc->uaudio_sndstat), "Hz");
}
}
#endif
ai.alt = id->bAlternateSetting;
ai.encoding = enc;
ai.attributes = sed->bmAttributes;
ai.idesc = id;
ai.edesc = ed;
ai.edesc1 = epdesc1;
ai.asf1desc = asf1d;
ai.sc_busy = 0;
ai.ifaceh = NULL;
uaudio_add_alt(sc, &ai);
#ifdef USB_DEBUG
if (ai.attributes & UA_SED_FREQ_CONTROL)
DPRINTFN(1, ("uaudio_process_as: FREQ_CONTROL\n"));
if (ai.attributes & UA_SED_PITCH_CONTROL)
DPRINTFN(1, ("uaudio_process_as: PITCH_CONTROL\n"));
#endif
sc->sc_mode |= (dir == UE_DIR_OUT) ? AUMODE_PLAY : AUMODE_RECORD;
return USBD_NORMAL_COMPLETION;
}
#undef offs
static usbd_status
uaudio_identify_as(struct uaudio_softc *sc,
const usb_config_descriptor_t *cdesc)
{
const usb_interface_descriptor_t *id;
const char *buf;
int size, offs;
size = UGETW(cdesc->wTotalLength);
buf = (const char *)cdesc;
/* Locate the AudioStreaming interface descriptor. */
offs = 0;
id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOSTREAM);
if (id == NULL)
return USBD_INVAL;
#if defined(__FreeBSD__)
sc->uaudio_sndstat_flag = 0;
if (sbuf_new(&(sc->uaudio_sndstat), NULL, 4096, SBUF_AUTOEXTEND) != NULL)
sc->uaudio_sndstat_flag = 1;
#endif
/* Loop through all the alternate settings. */
while (offs <= size) {
DPRINTFN(2, ("uaudio_identify: interface=%d offset=%d\n",
id->bInterfaceNumber, offs));
switch (id->bNumEndpoints) {
case 0:
DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n",
id->bAlternateSetting));
sc->sc_nullalt = id->bAlternateSetting;
break;
case 1:
#ifdef UAUDIO_MULTIPLE_ENDPOINTS
case 2:
#endif
uaudio_process_as(sc, buf, &offs, size, id);
break;
default:
printf("%s: ignored audio interface with %d "
"endpoints\n",
device_get_nameunit(sc->sc_dev), id->bNumEndpoints);
break;
}
id = uaudio_find_iface(buf, size, &offs,UISUBCLASS_AUDIOSTREAM);
if (id == NULL)
break;
}
#if defined(__FreeBSD__)
sbuf_finish(&(sc->uaudio_sndstat));
#endif
if (offs > size)
return USBD_INVAL;
DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts));
if (sc->sc_mode == 0) {
printf("%s: no usable endpoint found\n",
device_get_nameunit(sc->sc_dev));
return USBD_INVAL;
}
return USBD_NORMAL_COMPLETION;
}
static usbd_status
uaudio_identify_ac(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
{
struct io_terminal* iot;
const usb_interface_descriptor_t *id;
const struct usb_audio_control_descriptor *acdp;
const usb_descriptor_t *dp;
const struct usb_audio_output_terminal *pot;
struct terminal_list *tml;
const char *buf, *ibuf, *ibufend;
int size, offs, aclen, ndps, i, j;
size = UGETW(cdesc->wTotalLength);
buf = (const char *)cdesc;
/* Locate the AudioControl interface descriptor. */
offs = 0;
id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOCONTROL);
if (id == NULL)
return USBD_INVAL;
if (offs + sizeof *acdp > size)
return USBD_INVAL;
sc->sc_ac_iface = id->bInterfaceNumber;
DPRINTFN(2,("uaudio_identify_ac: AC interface is %d\n", sc->sc_ac_iface));
/* A class-specific AC interface header should follow. */
ibuf = buf + offs;
acdp = (const 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;
sc->sc_audio_rev = UGETW(acdp->bcdADC);
DPRINTFN(2,("uaudio_identify_ac: found AC header, vers=%03x, len=%d\n",
sc->sc_audio_rev, aclen));
sc->sc_nullalt = -1;
/* Scan through all the AC specific descriptors */
ibufend = ibuf + aclen;
dp = (const usb_descriptor_t *)ibuf;
ndps = 0;
iot = malloc(sizeof(struct io_terminal) * 256, M_TEMP, M_NOWAIT | M_ZERO);
if (iot == NULL) {
printf("%s: no memory\n", __func__);
return USBD_NOMEM;
}
for (;;) {
ibuf += dp->bLength;
if (ibuf >= ibufend)
break;
dp = (const usb_descriptor_t *)ibuf;
if (ibuf + dp->bLength > ibufend) {
free(iot, M_TEMP);
return USBD_INVAL;
}
if (dp->bDescriptorType != UDESC_CS_INTERFACE) {
printf("uaudio_identify_ac: skip desc type=0x%02x\n",
dp->bDescriptorType);
continue;
}
i = ((const struct usb_audio_input_terminal *)dp)->bTerminalId;
iot[i].d.desc = dp;
if (i > ndps)
ndps = i;
}
ndps++;
/* construct io_terminal */
for (i = 0; i < ndps; i++) {
dp = iot[i].d.desc;
if (dp == NULL)
continue;
if (dp->bDescriptorSubtype != UDESCSUB_AC_OUTPUT)
continue;
pot = iot[i].d.ot;
tml = uaudio_io_terminaltype(UGETW(pot->wTerminalType), iot, i);
if (tml != NULL)
free(tml, M_TEMP);
}
#ifdef USB_DEBUG
for (i = 0; i < 256; i++) {
struct usb_audio_cluster cluster;
if (iot[i].d.desc == NULL)
continue;
logprintf("id %d:\t", i);
switch (iot[i].d.desc->bDescriptorSubtype) {
case UDESCSUB_AC_INPUT:
logprintf("AC_INPUT type=%s\n", uaudio_get_terminal_name
(UGETW(iot[i].d.it->wTerminalType)));
logprintf("\t");
cluster = uaudio_get_cluster(i, iot);
uaudio_dump_cluster(&cluster);
logprintf("\n");
break;
case UDESCSUB_AC_OUTPUT:
logprintf("AC_OUTPUT type=%s ", uaudio_get_terminal_name
(UGETW(iot[i].d.ot->wTerminalType)));
logprintf("src=%d\n", iot[i].d.ot->bSourceId);
break;
case UDESCSUB_AC_MIXER:
logprintf("AC_MIXER src=");
for (j = 0; j < iot[i].d.mu->bNrInPins; j++)
logprintf("%d ", iot[i].d.mu->baSourceId[j]);
logprintf("\n\t");
cluster = uaudio_get_cluster(i, iot);
uaudio_dump_cluster(&cluster);
logprintf("\n");
break;
case UDESCSUB_AC_SELECTOR:
logprintf("AC_SELECTOR src=");
for (j = 0; j < iot[i].d.su->bNrInPins; j++)
logprintf("%d ", iot[i].d.su->baSourceId[j]);
logprintf("\n");
break;
case UDESCSUB_AC_FEATURE:
logprintf("AC_FEATURE src=%d\n", iot[i].d.fu->bSourceId);
break;
case UDESCSUB_AC_PROCESSING:
logprintf("AC_PROCESSING src=");
for (j = 0; j < iot[i].d.pu->bNrInPins; j++)
logprintf("%d ", iot[i].d.pu->baSourceId[j]);
logprintf("\n\t");
cluster = uaudio_get_cluster(i, iot);
uaudio_dump_cluster(&cluster);
logprintf("\n");
break;
case UDESCSUB_AC_EXTENSION:
logprintf("AC_EXTENSION src=");
for (j = 0; j < iot[i].d.eu->bNrInPins; j++)
logprintf("%d ", iot[i].d.eu->baSourceId[j]);
logprintf("\n\t");
cluster = uaudio_get_cluster(i, iot);
uaudio_dump_cluster(&cluster);
logprintf("\n");
break;
default:
logprintf("unknown audio control (subtype=%d)\n",
iot[i].d.desc->bDescriptorSubtype);
}
for (j = 0; j < iot[i].inputs_size; j++) {
int k;
logprintf("\tinput%d: ", j);
tml = iot[i].inputs[j];
if (tml == NULL) {
logprintf("NULL\n");
continue;
}
for (k = 0; k < tml->size; k++)
logprintf("%s ", uaudio_get_terminal_name
(tml->terminals[k]));
logprintf("\n");
}
logprintf("\toutput: ");
tml = iot[i].output;
for (j = 0; j < tml->size; j++)
logprintf("%s ", uaudio_get_terminal_name(tml->terminals[j]));
logprintf("\n");
}
#endif
for (i = 0; i < ndps; i++) {
dp = iot[i].d.desc;
if (dp == NULL)
continue;
DPRINTF(("uaudio_identify_ac: id=%d subtype=%d\n",
i, dp->bDescriptorSubtype));
switch (dp->bDescriptorSubtype) {
case UDESCSUB_AC_HEADER:
printf("uaudio_identify_ac: unexpected AC header\n");
break;
case UDESCSUB_AC_INPUT:
uaudio_add_input(sc, iot, i);
break;
case UDESCSUB_AC_OUTPUT:
uaudio_add_output(sc, iot, i);
break;
case UDESCSUB_AC_MIXER:
uaudio_add_mixer(sc, iot, i);
break;
case UDESCSUB_AC_SELECTOR:
uaudio_add_selector(sc, iot, i);
break;
case UDESCSUB_AC_FEATURE:
uaudio_add_feature(sc, iot, i);
break;
case UDESCSUB_AC_PROCESSING:
uaudio_add_processing(sc, iot, i);
break;
case UDESCSUB_AC_EXTENSION:
uaudio_add_extension(sc, iot, i);
break;
default:
printf("uaudio_identify_ac: bad AC desc subtype=0x%02x\n",
dp->bDescriptorSubtype);
break;
}
}
/* delete io_terminal */
for (i = 0; i < 256; i++) {
if (iot[i].d.desc == NULL)
continue;
if (iot[i].inputs != NULL) {
for (j = 0; j < iot[i].inputs_size; j++) {
if (iot[i].inputs[j] != NULL)
free(iot[i].inputs[j], M_TEMP);
}
free(iot[i].inputs, M_TEMP);
}
if (iot[i].output != NULL)
free(iot[i].output, M_TEMP);
iot[i].d.desc = NULL;
}
free(iot, M_TEMP);
return USBD_NORMAL_COMPLETION;
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int
uaudio_query_devinfo(void *addr, mixer_devinfo_t *mi)
{
struct uaudio_softc *sc;
struct mixerctl *mc;
int n, nctls, i;
sc = addr;
DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index));
if (sc->sc_dying)
return EIO;
n = mi->index;
nctls = sc->sc_nctls;
switch (n) {
case UAC_OUTPUT:
mi->type = AUDIO_MIXER_CLASS;
mi->mixer_class = UAC_OUTPUT;
mi->next = mi->prev = AUDIO_MIXER_LAST;
strlcpy(mi->label.name, AudioCoutputs, sizeof(mi->label.name));
return 0;
case UAC_INPUT:
mi->type = AUDIO_MIXER_CLASS;
mi->mixer_class = UAC_INPUT;
mi->next = mi->prev = AUDIO_MIXER_LAST;
strlcpy(mi->label.name, AudioCinputs, sizeof(mi->label.name));
return 0;
case UAC_EQUAL:
mi->type = AUDIO_MIXER_CLASS;
mi->mixer_class = UAC_EQUAL;
mi->next = mi->prev = AUDIO_MIXER_LAST;
strlcpy(mi->label.name, AudioCequalization,
sizeof(mi->label.name));
return 0;
case UAC_RECORD:
mi->type = AUDIO_MIXER_CLASS;
mi->mixer_class = UAC_RECORD;
mi->next = mi->prev = AUDIO_MIXER_LAST;
strlcpy(mi->label.name, AudioCrecord, sizeof(mi->label.name));
return 0;
default:
break;
}
n -= UAC_NCLASSES;
if (n < 0 || n >= nctls)
return ENXIO;
mc = &sc->sc_ctls[n];
strlcpy(mi->label.name, mc->ctlname, sizeof(mi->label.name));
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;
strlcpy(mi->un.e.member[0].label.name, AudioNoff,
sizeof(mi->un.e.member[0].label.name));
mi->un.e.member[0].ord = 0;
strlcpy(mi->un.e.member[1].label.name, AudioNon,
sizeof(mi->un.e.member[1].label.name));
mi->un.e.member[1].ord = 1;
break;
case MIX_SELECTOR:
mi->type = AUDIO_MIXER_ENUM;
mi->un.e.num_mem = mc->maxval - mc->minval + 1;
for (i = 0; i <= mc->maxval - mc->minval; i++) {
snprintf(mi->un.e.member[i].label.name,
sizeof(mi->un.e.member[i].label.name),
"%d", i + mc->minval);
mi->un.e.member[i].ord = i + mc->minval;
}
break;
default:
mi->type = AUDIO_MIXER_VALUE;
strlcpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN);
mi->un.v.num_channels = mc->nchan;
mi->un.v.delta = mc->delta;
break;
}
return 0;
}
static int
uaudio_open(void *addr, int flags)
{
struct uaudio_softc *sc;
sc = addr;
DPRINTF(("uaudio_open: sc=%p\n", sc));
if (sc->sc_dying)
return EIO;
if ((flags & FWRITE) && !(sc->sc_mode & AUMODE_PLAY))
return EACCES;
if ((flags & FREAD) && !(sc->sc_mode & AUMODE_RECORD))
return EACCES;
return 0;
}
/*
* Close function is called at splaudio().
*/
static void
uaudio_close(void *addr)
{
}
static int
uaudio_drain(void *addr)
{
struct uaudio_softc *sc;
sc = addr;
usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
return 0;
}
static int
uaudio_halt_out_dma(void *addr)
{
struct uaudio_softc *sc;
sc = addr;
if (sc->sc_dying)
return EIO;
DPRINTF(("uaudio_halt_out_dma: enter\n"));
if (sc->sc_playchan.pipe != NULL) {
uaudio_chan_close(sc, &sc->sc_playchan);
sc->sc_playchan.pipe = NULL;
uaudio_chan_free_buffers(sc, &sc->sc_playchan);
sc->sc_playchan.intr = NULL;
}
return 0;
}
static int
uaudio_halt_in_dma(void *addr)
{
struct uaudio_softc *sc;
DPRINTF(("uaudio_halt_in_dma: enter\n"));
sc = addr;
if (sc->sc_recchan.pipe != NULL) {
uaudio_chan_close(sc, &sc->sc_recchan);
sc->sc_recchan.pipe = NULL;
uaudio_chan_free_buffers(sc, &sc->sc_recchan);
sc->sc_recchan.intr = NULL;
}
return 0;
}
static int
uaudio_getdev(void *addr, struct audio_device *retp)
{
struct uaudio_softc *sc;
DPRINTF(("uaudio_mixer_getdev:\n"));
sc = addr;
if (sc->sc_dying)
return EIO;
*retp = uaudio_device;
return 0;
}
/*
* Make sure the block size is large enough to hold all outstanding transfers.
*/
static int
uaudio_round_blocksize(void *addr, int blk)
{
struct uaudio_softc *sc;
int b;
sc = addr;
DPRINTF(("uaudio_round_blocksize: blk=%d mode=%s\n", blk,
mode == AUMODE_PLAY ? "AUMODE_PLAY" : "AUMODE_RECORD"));
/* chan.bytes_per_frame can be 0. */
if (mode == AUMODE_PLAY || sc->sc_recchan.bytes_per_frame <= 0) {
b = param->sample_rate * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
/*
* This does not make accurate value in the case
* of b % USB_FRAMES_PER_SECOND != 0
*/
b /= USB_FRAMES_PER_SECOND;
b *= param->precision / 8 * param->channels;
} else {
/*
* use wMaxPacketSize in bytes_per_frame.
* See uaudio_set_params() and uaudio_chan_init()
*/
b = sc->sc_recchan.bytes_per_frame
* UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
}
if (b <= 0)
b = 1;
blk = blk <= b ? b : blk / b * b;
#ifdef DIAGNOSTIC
if (blk <= 0) {
printf("uaudio_round_blocksize: blk=%d\n", blk);
blk = 512;
}
#endif
DPRINTF(("uaudio_round_blocksize: resultant blk=%d\n", blk));
return blk;
}
static int
uaudio_get_props(void *addr)
{
return AUDIO_PROP_FULLDUPLEX | AUDIO_PROP_INDEPENDENT;
}
#endif /* NetBSD or OpenBSD */
static int
uaudio_get(struct uaudio_softc *sc, int which, int type, int wValue,
int wIndex, int len)
{
usb_device_request_t req;
uint8_t data[4];
usbd_status err;
int val;
#if defined(__FreeBSD__)
if (sc->sc_dying)
return EIO;
#endif
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));
#if defined(__FreeBSD__)
if (sc->async != 0)
err = usbd_do_request_async(sc->sc_udev, &req, data);
else
#endif
err = usbd_do_request(sc->sc_udev, &req, data);
if (err) {
DPRINTF(("uaudio_get: err=%s\n", usbd_errstr(err)));
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;
}
static void
uaudio_set(struct uaudio_softc *sc, int which, int type, int wValue,
int wIndex, int len, int val)
{
usb_device_request_t req;
uint8_t data[4];
usbd_status err;
#if defined(__FreeBSD__)
if (sc->sc_dying)
return;
#endif
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));
#if defined(__FreeBSD__)
if (sc->async != 0)
err = usbd_do_request_async(sc->sc_udev, &req, data);
else
#endif
err = usbd_do_request(sc->sc_udev, &req, data);
#ifdef USB_DEBUG
if (err)
DPRINTF(("uaudio_set: err=%d\n", err));
#endif
}
static int
uaudio_signext(int type, int val)
{
if (!MIX_UNSIGNED(type)) {
if (MIX_SIZE(type) == 2)
val = (int16_t)val;
else
val = (int8_t)val;
}
return val;
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int
uaudio_value2bsd(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 if (mc->type == MIX_SELECTOR) {
if (val < mc->minval || val > mc->maxval)
val = mc->minval;
} else
val = ((uaudio_signext(mc->type, val) - mc->minval) * 255
+ mc->mul/2) / mc->mul;
DPRINTFN(5, ("val'=%d\n", val));
return val;
}
#endif
int
uaudio_bsd2value(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 if (mc->type == MIX_SELECTOR) {
if (val < mc->minval || val > mc->maxval)
val = mc->minval;
} else
val = (val + mc->delta/2) * mc->mul / 255 + mc->minval;
DPRINTFN(5, ("val'=%d\n", val));
return val;
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int
uaudio_ctl_get(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);
}
#endif
static void
uaudio_ctl_set(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);
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
static int
uaudio_mixer_get_port(void *addr, mixer_ctrl_t *cp)
{
struct uaudio_softc *sc;
struct mixerctl *mc;
int i, n, vals[MIX_MAX_CHAN], val;
DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev));
sc = addr;
if (sc->sc_dying)
return EIO;
n = cp->dev - UAC_NCLASSES;
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 (mc->type == MIX_SELECTOR) {
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;
}
static int
uaudio_mixer_set_port(void *addr, mixer_ctrl_t *cp)
{
struct uaudio_softc *sc;
struct mixerctl *mc;
int i, n, vals[MIX_MAX_CHAN];
DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev));
sc = addr;
if (sc->sc_dying)
return EIO;
n = cp->dev - UAC_NCLASSES;
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 (mc->type == MIX_SELECTOR) {
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;
}
static int
uaudio_trigger_input(void *addr, void *start, void *end, int blksize,
void (*intr)(void *), void *arg,
struct audio_params *param)
{
struct uaudio_softc *sc;
struct chan *ch;
usbd_status err;
int i, s;
sc = addr;
if (sc->sc_dying)
return EIO;
DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p "
"blksize=%d\n", sc, start, end, blksize));
ch = &sc->sc_recchan;
uaudio_chan_set_param(ch, 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));
err = uaudio_chan_alloc_buffers(sc, ch);
if (err)
return EIO;
err = uaudio_chan_open(sc, ch);
if (err) {
uaudio_chan_free_buffers(sc, ch);
return EIO;
}
ch->intr = intr;
ch->arg = arg;
s = splusb();
for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
uaudio_chan_rtransfer(ch);
splx(s);
return 0;
}
static int
uaudio_trigger_output(void *addr, void *start, void *end, int blksize,
void (*intr)(void *), void *arg,
struct audio_params *param)
{
struct uaudio_softc *sc;
struct chan *ch;
usbd_status err;
int i, s;
sc = addr;
if (sc->sc_dying)
return EIO;
DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p "
"blksize=%d\n", sc, start, end, blksize));
ch = &sc->sc_playchan;
uaudio_chan_set_param(ch, 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));
err = uaudio_chan_alloc_buffers(sc, ch);
if (err)
return EIO;
err = uaudio_chan_open(sc, ch);
if (err) {
uaudio_chan_free_buffers(sc, ch);
return EIO;
}
ch->intr = intr;
ch->arg = arg;
s = splusb();
for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
uaudio_chan_ptransfer(ch);
splx(s);
return 0;
}
#endif /* NetBSD or OpenBSD */
/* Set up a pipe for a channel. */
static usbd_status
uaudio_chan_open(struct uaudio_softc *sc, struct chan *ch)
{
struct as_info *as;
int endpt;
#if defined(__FreeBSD__)
int locked;
#endif
usbd_status err;
#if defined(__FreeBSD__)
if (sc->sc_dying)
return EIO;
#endif
as = &sc->sc_alts[ch->altidx];
endpt = as->edesc->bEndpointAddress;
DPRINTF(("uaudio_chan_open: endpt=0x%02x, speed=%d, alt=%d\n",
endpt, ch->sample_rate, as->alt));
#if defined(__FreeBSD__)
locked = (ch->pcm_ch != NULL && mtx_owned(ch->pcm_ch->lock)) ? 1 : 0;
if (locked)
CHN_UNLOCK(ch->pcm_ch);
#endif
/* Set alternate interface corresponding to the mode. */
err = usbd_set_interface(as->ifaceh, as->alt);
#if defined(__FreeBSD__)
if (locked)
CHN_LOCK(ch->pcm_ch);
#endif
if (err)
return err;
/*
* If just one sampling rate is supported,
* no need to call uaudio_set_speed().
* Roland SD-90 freezes by a SAMPLING_FREQ_CONTROL request.
*/
if (as->asf1desc->bSamFreqType != 1) {
err = uaudio_set_speed(sc, endpt, ch->sample_rate);
if (err) {
DPRINTF(("uaudio_chan_open: set_speed failed err=%s\n",
usbd_errstr(err)));
}
}
ch->pipe = 0;
ch->sync_pipe = 0;
DPRINTF(("uaudio_chan_open: create pipe to 0x%02x\n", endpt));
err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->pipe);
if (err)
return err;
if (as->edesc1 != NULL) {
endpt = as->edesc1->bEndpointAddress;
DPRINTF(("uaudio_chan_open: create sync-pipe to 0x%02x\n", endpt));
err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->sync_pipe);
}
return err;
}
static void
uaudio_chan_close(struct uaudio_softc *sc, struct chan *ch)
{
struct as_info *as;
#if defined(__FreeBSD__)
int locked;
if (sc->sc_dying)
return ;
#endif
as = &sc->sc_alts[ch->altidx];
as->sc_busy = 0;
#if defined(__FreeBSD__)
locked = (ch->pcm_ch != NULL && mtx_owned(ch->pcm_ch->lock)) ? 1 : 0;
if (locked)
CHN_UNLOCK(ch->pcm_ch);
#endif
if (sc->sc_nullalt >= 0) {
DPRINTF(("uaudio_chan_close: set null alt=%d\n",
sc->sc_nullalt));
/*
* The interface will be initialized later again, so an
* error does not hurt.
*/
(void)usbd_set_interface(as->ifaceh, sc->sc_nullalt);
}
if (ch->pipe) {
usbd_abort_pipe(ch->pipe);
usbd_close_pipe(ch->pipe);
}
if (ch->sync_pipe) {
usbd_abort_pipe(ch->sync_pipe);
usbd_close_pipe(ch->sync_pipe);
}
#if defined(__FreeBSD__)
if (locked)
CHN_LOCK(ch->pcm_ch);
#endif
}
static usbd_status
uaudio_chan_alloc_buffers(struct uaudio_softc *sc, struct chan *ch)
{
usbd_xfer_handle xfer;
void *buf;
int i, size;
size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES;
for (i = 0; i < UAUDIO_NCHANBUFS; i++) {
xfer = usbd_alloc_xfer(sc->sc_udev);
if (xfer == 0)
goto bad;
ch->chanbufs[i].xfer = xfer;
buf = usbd_alloc_buffer(xfer, 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_xfer(ch->chanbufs[i].xfer);
return USBD_NOMEM;
}
static void
uaudio_chan_free_buffers(struct uaudio_softc *sc, struct chan *ch)
{
int i;
for (i = 0; i < UAUDIO_NCHANBUFS; i++)
usbd_free_xfer(ch->chanbufs[i].xfer);
}
/* Called at splusb() */
static void
uaudio_chan_ptransfer(struct chan *ch)
{
struct chanbuf *cb;
int i, n, size, residue, total;
if (ch->sc->sc_dying)
return;
/* 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) {
if ((ch->sc->sc_altflags & UA_NOFRAC) == 0)
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 USB_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 xfer=%p\n", cb->xfer));
/* Fill the request */
usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
UAUDIO_NFRAMES, USBD_NO_COPY,
uaudio_chan_pintr);
(void)usbd_transfer(cb->xfer);
}
static void
uaudio_chan_pintr(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
{
struct chanbuf *cb;
struct chan *ch;
u_int32_t count;
int s;
cb = priv;
ch = cb->chan;
/* Return if we are aborting. */
if (status == USBD_CANCELLED)
return;
usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
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;
#if defined(__FreeBSD__)
/* s = spltty(); */
s = splhigh();
chn_intr(ch->pcm_ch);
splx(s);
#else
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);
#endif
/* start next transfer */
uaudio_chan_ptransfer(ch);
}
/* Called at splusb() */
static void
uaudio_chan_rtransfer(struct chan *ch)
{
struct chanbuf *cb;
int i, size, residue, total;
if (ch->sc->sc_dying)
return;
/* 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;
cb->sizes[i] = size;
cb->offsets[i] = total;
total += size;
}
ch->residue = residue;
cb->size = total;
#ifdef USB_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 xfer=%p\n", cb->xfer));
/* Fill the request */
usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
UAUDIO_NFRAMES, USBD_NO_COPY,
uaudio_chan_rintr);
(void)usbd_transfer(cb->xfer);
}
static void
uaudio_chan_rintr(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
{
struct chanbuf *cb = priv;
struct chan *ch = cb->chan;
u_int32_t count;
int s, i, n, frsize;
/* Return if we are aborting. */
if (status == USBD_CANCELLED)
return;
usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n",
count, ch->transferred));
/* count < cb->size is normal for asynchronous source */
#ifdef DIAGNOSTIC
if (count > cb->size) {
printf("uaudio_chan_rintr: 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.
*/
for(i = 0; i < UAUDIO_NFRAMES; i++) {
frsize = cb->sizes[i];
n = min(frsize, ch->end - ch->cur);
memcpy(ch->cur, cb->buffer + cb->offsets[i], n);
ch->cur += n;
if (ch->cur >= ch->end)
ch->cur = ch->start;
if (frsize > n) {
memcpy(ch->cur, cb->buffer + cb->offsets[i] + n,
frsize - n);
ch->cur += frsize - n;
}
}
/* Call back to upper layer */
ch->transferred += count;
#if defined(__FreeBSD__)
s = spltty();
chn_intr(ch->pcm_ch);
splx(s);
#else
s = splaudio();
while (ch->transferred >= ch->blksize) {
ch->transferred -= ch->blksize;
DPRINTFN(5,("uaudio_chan_rintr: call %p(%p)\n",
ch->intr, ch->arg));
ch->intr(ch->arg);
}
splx(s);
#endif
/* start next transfer */
uaudio_chan_rtransfer(ch);
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
static void
uaudio_chan_init(struct chan *ch, int altidx, const struct audio_params *param,
int maxpktsize)
{
int samples_per_frame, sample_size;
ch->altidx = altidx;
sample_size = param->precision * param->factor * param->hw_channels / 8;
samples_per_frame = param->hw_sample_rate / USB_FRAMES_PER_SECOND;
ch->sample_size = sample_size;
ch->sample_rate = param->hw_sample_rate;
if (maxpktsize == 0) {
ch->fraction = param->hw_sample_rate % USB_FRAMES_PER_SECOND;
ch->bytes_per_frame = samples_per_frame * sample_size;
} else {
ch->fraction = 0;
ch->bytes_per_frame = maxpktsize;
}
ch->residue = 0;
}
static void
uaudio_chan_set_param(struct chan *ch, u_char *start, u_char *end, int blksize)
{
ch->start = start;
ch->end = end;
ch->cur = start;
ch->blksize = blksize;
ch->transferred = 0;
ch->curchanbuf = 0;
}
static void
uaudio_get_minmax_rates(int nalts, const struct as_info *alts,
const struct audio_params *p, int mode,
u_long *min, u_long *max)
{
const struct usb_audio_streaming_type1_descriptor *a1d;
int i, j;
*min = ULONG_MAX;
*max = 0;
for (i = 0; i < nalts; i++) {
a1d = alts[i].asf1desc;
if (alts[i].sc_busy)
continue;
if (p->hw_channels != a1d->bNrChannels)
continue;
if (p->hw_precision != a1d->bBitResolution)
continue;
if (p->hw_encoding != alts[i].encoding)
continue;
if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress))
continue;
if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
DPRINTFN(2,("uaudio_get_minmax_rates: cont %d-%d\n",
UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
if (UA_SAMP_LO(a1d) < *min)
*min = UA_SAMP_LO(a1d);
if (UA_SAMP_HI(a1d) > *max)
*max = UA_SAMP_HI(a1d);
} else {
for (j = 0; j < a1d->bSamFreqType; j++) {
DPRINTFN(2,("uaudio_get_minmax_rates: disc #%d: %d\n",
j, UA_GETSAMP(a1d, j)));
if (UA_GETSAMP(a1d, j) < *min)
*min = UA_GETSAMP(a1d, j);
if (UA_GETSAMP(a1d, j) > *max)
*max = UA_GETSAMP(a1d, j);
}
}
}
}
static int
uaudio_match_alt_sub(int nalts, const struct as_info *alts,
const struct audio_params *p, int mode, u_long rate)
{
const struct usb_audio_streaming_type1_descriptor *a1d;
int i, j;
DPRINTF(("uaudio_match_alt_sub: search for %luHz %dch\n",
rate, p->hw_channels));
for (i = 0; i < nalts; i++) {
a1d = alts[i].asf1desc;
if (alts[i].sc_busy)
continue;
if (p->hw_channels != a1d->bNrChannels)
continue;
if (p->hw_precision != a1d->bBitResolution)
continue;
if (p->hw_encoding != alts[i].encoding)
continue;
if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress))
continue;
if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
DPRINTFN(3,("uaudio_match_alt_sub: cont %d-%d\n",
UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
if (UA_SAMP_LO(a1d) <= rate && rate <= UA_SAMP_HI(a1d))
return i;
} else {
for (j = 0; j < a1d->bSamFreqType; j++) {
DPRINTFN(3,("uaudio_match_alt_sub: disc #%d: %d\n",
j, UA_GETSAMP(a1d, j)));
/* XXX allow for some slack */
if (UA_GETSAMP(a1d, j) == rate)
return i;
}
}
}
return -1;
}
static int
uaudio_match_alt_chan(int nalts, const struct as_info *alts,
struct audio_params *p, int mode)
{
int i, n;
u_long min, max;
u_long rate;
/* Exact match */
DPRINTF(("uaudio_match_alt_chan: examine %ldHz %dch %dbit.\n",
p->sample_rate, p->hw_channels, p->hw_precision));
i = uaudio_match_alt_sub(nalts, alts, p, mode, p->sample_rate);
if (i >= 0)
return i;
uaudio_get_minmax_rates(nalts, alts, p, mode, &min, &max);
DPRINTF(("uaudio_match_alt_chan: min=%lu max=%lu\n", min, max));
if (max <= 0)
return -1;
/* Search for biggers */
n = 2;
while ((rate = p->sample_rate * n++) <= max) {
i = uaudio_match_alt_sub(nalts, alts, p, mode, rate);
if (i >= 0) {
p->hw_sample_rate = rate;
return i;
}
}
if (p->sample_rate >= min) {
i = uaudio_match_alt_sub(nalts, alts, p, mode, max);
if (i >= 0) {
p->hw_sample_rate = max;
return i;
}
} else {
i = uaudio_match_alt_sub(nalts, alts, p, mode, min);
if (i >= 0) {
p->hw_sample_rate = min;
return i;
}
}
return -1;
}
static int
uaudio_match_alt(int nalts, const struct as_info *alts,
struct audio_params *p, int mode)
{
int i, n;
mode = mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN;
i = uaudio_match_alt_chan(nalts, alts, p, mode);
if (i >= 0)
return i;
for (n = p->channels + 1; n <= AUDIO_MAX_CHANNELS; n++) {
p->hw_channels = n;
i = uaudio_match_alt_chan(nalts, alts, p, mode);
if (i >= 0)
return i;
}
if (p->channels != 2)
return -1;
p->hw_channels = 1;
return uaudio_match_alt_chan(nalts, alts, p, mode);
}
static int
uaudio_set_params(void *addr, int setmode, int usemode,
struct audio_params *play, struct audio_params *rec)
{
struct uaudio_softc *sc;
int flags;
int factor;
int enc, i;
int paltidx, raltidx;
void (*swcode)(void *, u_char *buf, int cnt);
struct audio_params *p;
int mode;
sc = addr;
flags = sc->sc_altflags;
paltidx = -1;
raltidx = -1;
if (sc->sc_dying)
return EIO;
if (((usemode & AUMODE_PLAY) && sc->sc_playchan.pipe != NULL) ||
((usemode & AUMODE_RECORD) && sc->sc_recchan.pipe != NULL))
return EBUSY;
if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1)
sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 0;
if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1)
sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 0;
/* Some uaudio devices are unidirectional. Don't try to find a
matching mode for the unsupported direction. */
setmode &= sc->sc_mode;
for (mode = AUMODE_RECORD; mode != -1;
mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
if ((setmode & mode) == 0)
continue;
p = (mode == AUMODE_PLAY) ? play : rec;
factor = 1;
swcode = 0;
enc = p->encoding;
switch (enc) {
case AUDIO_ENCODING_SLINEAR_BE:
/* FALLTHROUGH */
case AUDIO_ENCODING_SLINEAR_LE:
if (enc == AUDIO_ENCODING_SLINEAR_BE
&& p->precision == 16 && (flags & HAS_16)) {
swcode = swap_bytes;
enc = AUDIO_ENCODING_SLINEAR_LE;
} else if (p->precision == 8) {
if (flags & HAS_8) {
/* No conversion */
} else if (flags & HAS_8U) {
swcode = change_sign8;
enc = AUDIO_ENCODING_ULINEAR_LE;
} else if (flags & HAS_16) {
factor = 2;
p->hw_precision = 16;
if (mode == AUMODE_PLAY)
swcode = linear8_to_linear16_le;
else
swcode = linear16_to_linear8_le;
}
}
break;
case AUDIO_ENCODING_ULINEAR_BE:
/* FALLTHROUGH */
case AUDIO_ENCODING_ULINEAR_LE:
if (p->precision == 16) {
if (enc == AUDIO_ENCODING_ULINEAR_LE)
swcode = change_sign16_le;
else if (mode == AUMODE_PLAY)
swcode = swap_bytes_change_sign16_le;
else
swcode = change_sign16_swap_bytes_le;
enc = AUDIO_ENCODING_SLINEAR_LE;
} else if (p->precision == 8) {
if (flags & HAS_8U) {
/* No conversion */
} else if (flags & HAS_8) {
swcode = change_sign8;
enc = AUDIO_ENCODING_SLINEAR_LE;
} else if (flags & HAS_16) {
factor = 2;
p->hw_precision = 16;
enc = AUDIO_ENCODING_SLINEAR_LE;
if (mode == AUMODE_PLAY)
swcode = ulinear8_to_slinear16_le;
else
swcode = slinear16_to_ulinear8_le;
}
}
break;
case AUDIO_ENCODING_ULAW:
if (flags & HAS_MULAW)
break;
if (flags & HAS_16) {
if (mode == AUMODE_PLAY)
swcode = mulaw_to_slinear16_le;
else
swcode = slinear16_to_mulaw_le;
factor = 2;
enc = AUDIO_ENCODING_SLINEAR_LE;
p->hw_precision = 16;
} else if (flags & HAS_8U) {
if (mode == AUMODE_PLAY)
swcode = mulaw_to_ulinear8;
else
swcode = ulinear8_to_mulaw;
enc = AUDIO_ENCODING_ULINEAR_LE;
} else if (flags & HAS_8) {
if (mode == AUMODE_PLAY)
swcode = mulaw_to_slinear8;
else
swcode = slinear8_to_mulaw;
enc = AUDIO_ENCODING_SLINEAR_LE;
} else
return (EINVAL);
break;
case AUDIO_ENCODING_ALAW:
if (flags & HAS_ALAW)
break;
if (mode == AUMODE_PLAY && (flags & HAS_16)) {
swcode = alaw_to_slinear16_le;
factor = 2;
enc = AUDIO_ENCODING_SLINEAR_LE;
p->hw_precision = 16;
} else if (flags & HAS_8U) {
if (mode == AUMODE_PLAY)
swcode = alaw_to_ulinear8;
else
swcode = ulinear8_to_alaw;
enc = AUDIO_ENCODING_ULINEAR_LE;
} else if (flags & HAS_8) {
if (mode == AUMODE_PLAY)
swcode = alaw_to_slinear8;
else
swcode = 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->hw_precision, enc, p->sample_rate));
p->hw_encoding = enc;
i = uaudio_match_alt(sc->sc_nalts, sc->sc_alts, p, mode);
if (i < 0)
return (EINVAL);
p->sw_code = swcode;
p->factor = factor;
if (mode == AUMODE_PLAY)
paltidx = i;
else
raltidx = i;
}
if ((setmode & AUMODE_PLAY)) {
/* XXX abort transfer if currently happening? */
uaudio_chan_init(&sc->sc_playchan, paltidx, play, 0);
}
if ((setmode & AUMODE_RECORD)) {
/* XXX abort transfer if currently happening? */
uaudio_chan_init(&sc->sc_recchan, raltidx, rec,
UGETW(sc->sc_alts[raltidx].edesc->wMaxPacketSize));
}
if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1)
sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 1;
if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1)
sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 1;
DPRINTF(("uaudio_set_params: use altidx=p%d/r%d, altno=p%d/r%d\n",
sc->sc_playchan.altidx, sc->sc_recchan.altidx,
(sc->sc_playchan.altidx >= 0)
?sc->sc_alts[sc->sc_playchan.altidx].idesc->bAlternateSetting
: -1,
(sc->sc_recchan.altidx >= 0)
? sc->sc_alts[sc->sc_recchan.altidx].idesc->bAlternateSetting
: -1));
return 0;
}
#endif /* NetBSD or OpenBSD */
static usbd_status
uaudio_set_speed(struct uaudio_softc *sc, int endpt, u_int speed)
{
usb_device_request_t req;
uint8_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;
#if defined(__FreeBSD__)
if (sc->async != 0)
return usbd_do_request_async(sc->sc_udev, &req, data);
#endif
return usbd_do_request(sc->sc_udev, &req, data);
}
#if defined(__FreeBSD__)
/************************************************************/
int
uaudio_init_params(struct uaudio_softc *sc, struct chan *ch, int mode)
{
int i, j, enc;
int samples_per_frame, sample_size;
if ((sc->sc_playchan.pipe != NULL) || (sc->sc_recchan.pipe != NULL))
return (-1);
switch(ch->format & 0x000FFFFF) {
case AFMT_U8:
enc = AUDIO_ENCODING_ULINEAR_LE;
ch->precision = 8;
break;
case AFMT_S8:
enc = AUDIO_ENCODING_SLINEAR_LE;
ch->precision = 8;
break;
case AFMT_A_LAW: /* ? */
enc = AUDIO_ENCODING_ALAW;
ch->precision = 8;
break;
case AFMT_MU_LAW: /* ? */
enc = AUDIO_ENCODING_ULAW;
ch->precision = 8;
break;
case AFMT_S16_LE:
enc = AUDIO_ENCODING_SLINEAR_LE;
ch->precision = 16;
break;
case AFMT_S16_BE:
enc = AUDIO_ENCODING_SLINEAR_BE;
ch->precision = 16;
break;
case AFMT_U16_LE:
enc = AUDIO_ENCODING_ULINEAR_LE;
ch->precision = 16;
break;
case AFMT_U16_BE:
enc = AUDIO_ENCODING_ULINEAR_BE;
ch->precision = 16;
break;
case AFMT_S24_LE:
enc = AUDIO_ENCODING_SLINEAR_LE;
ch->precision = 24;
break;
case AFMT_S24_BE:
enc = AUDIO_ENCODING_SLINEAR_BE;
ch->precision = 24;
break;
case AFMT_U24_LE:
enc = AUDIO_ENCODING_ULINEAR_LE;
ch->precision = 24;
break;
case AFMT_U24_BE:
enc = AUDIO_ENCODING_ULINEAR_BE;
ch->precision = 24;
break;
case AFMT_S32_LE:
enc = AUDIO_ENCODING_SLINEAR_LE;
ch->precision = 32;
break;
case AFMT_S32_BE:
enc = AUDIO_ENCODING_SLINEAR_BE;
ch->precision = 32;
break;
case AFMT_U32_LE:
enc = AUDIO_ENCODING_ULINEAR_LE;
ch->precision = 32;
break;
case AFMT_U32_BE:
enc = AUDIO_ENCODING_ULINEAR_BE;
ch->precision = 32;
break;
default:
enc = 0;
ch->precision = 16;
printf("Unknown format %x\n", ch->format);
}
if (ch->format & AFMT_STEREO) {
ch->channels = 2;
} else {
ch->channels = 1;
}
/* for (mode = ...... */
for (i = 0; i < sc->sc_nalts; i++) {
const struct usb_audio_streaming_type1_descriptor *a1d =
sc->sc_alts[i].asf1desc;
if (ch->channels == a1d->bNrChannels &&
ch->precision == a1d->bBitResolution &&
#if 0
enc == sc->sc_alts[i].encoding) {
#else
enc == sc->sc_alts[i].encoding &&
(mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN) ==
UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress)) {
#endif
if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
DPRINTFN(2,("uaudio_set_params: cont %d-%d\n",
UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
if (UA_SAMP_LO(a1d) <= ch->sample_rate &&
ch->sample_rate <= UA_SAMP_HI(a1d)) {
if (mode == AUMODE_PLAY)
sc->sc_playchan.altidx = i;
else
sc->sc_recchan.altidx = i;
goto found;
}
} else {
for (j = 0; j < a1d->bSamFreqType; j++) {
DPRINTFN(2,("uaudio_set_params: disc #"
"%d: %d\n", j, UA_GETSAMP(a1d, j)));
/* XXX allow for some slack */
if (UA_GETSAMP(a1d, j) ==
ch->sample_rate) {
if (mode == AUMODE_PLAY)
sc->sc_playchan.altidx = i;
else
sc->sc_recchan.altidx = i;
goto found;
}
}
}
}
}
/* return (EINVAL); */
if (mode == AUMODE_PLAY)
printf("uaudio: This device can't play in rate=%d.\n", ch->sample_rate);
else
printf("uaudio: This device can't record in rate=%d.\n", ch->sample_rate);
return (-1);
found:
#if 0 /* XXX */
p->sw_code = swcode;
p->factor = factor;
if (usemode == mode)
sc->sc_curaltidx = i;
#endif
/* } */
sample_size = ch->precision * ch->channels / 8;
samples_per_frame = ch->sample_rate / USB_FRAMES_PER_SECOND;
ch->fraction = ch->sample_rate % USB_FRAMES_PER_SECOND;
ch->sample_size = sample_size;
ch->bytes_per_frame = samples_per_frame * sample_size;
ch->residue = 0;
ch->cur = ch->start;
ch->transferred = 0;
ch->curchanbuf = 0;
return (0);
}
struct uaudio_conversion {
uint8_t uaudio_fmt;
uint8_t uaudio_prec;
uint32_t freebsd_fmt;
};
const struct uaudio_conversion const accepted_conversion[] = {
{AUDIO_ENCODING_ULINEAR_LE, 8, AFMT_U8},
{AUDIO_ENCODING_ULINEAR_LE, 16, AFMT_U16_LE},
{AUDIO_ENCODING_ULINEAR_LE, 24, AFMT_U24_LE},
{AUDIO_ENCODING_ULINEAR_LE, 32, AFMT_U32_LE},
{AUDIO_ENCODING_ULINEAR_BE, 16, AFMT_U16_BE},
{AUDIO_ENCODING_ULINEAR_BE, 24, AFMT_U24_BE},
{AUDIO_ENCODING_ULINEAR_BE, 32, AFMT_U32_BE},
{AUDIO_ENCODING_SLINEAR_LE, 8, AFMT_S8},
{AUDIO_ENCODING_SLINEAR_LE, 16, AFMT_S16_LE},
{AUDIO_ENCODING_SLINEAR_LE, 24, AFMT_S24_LE},
{AUDIO_ENCODING_SLINEAR_LE, 32, AFMT_S32_LE},
{AUDIO_ENCODING_SLINEAR_BE, 16, AFMT_S16_BE},
{AUDIO_ENCODING_SLINEAR_BE, 24, AFMT_S24_BE},
{AUDIO_ENCODING_SLINEAR_BE, 32, AFMT_S32_BE},
{AUDIO_ENCODING_ALAW, 8, AFMT_A_LAW},
{AUDIO_ENCODING_ULAW, 8, AFMT_MU_LAW},
{0,0,0}
};
unsigned
uaudio_query_formats(device_t dev, int reqdir, unsigned maxfmt, struct pcmchan_caps *cap)
{
struct uaudio_softc *sc;
const struct usb_audio_streaming_type1_descriptor *asf1d;
const struct uaudio_conversion *iterator;
unsigned fmtcount, foundcount;
u_int32_t fmt;
uint8_t format, numchan, subframesize, prec, dir, iscontinuous;
int freq, freq_min, freq_max;
char *numchannel_descr;
char freq_descr[64];
int i,r;
sc = device_get_softc(dev);
if (sc == NULL)
return 0;
cap->minspeed = cap->maxspeed = 0;
foundcount = fmtcount = 0;
for (i = 0; i < sc->sc_nalts; i++) {
dir = UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress);
if ((dir == UE_DIR_OUT) != (reqdir == PCMDIR_PLAY))
continue;
asf1d = sc->sc_alts[i].asf1desc;
format = sc->sc_alts[i].encoding;
numchan = asf1d->bNrChannels;
subframesize = asf1d->bSubFrameSize;
prec = asf1d->bBitResolution; /* precision */
iscontinuous = asf1d->bSamFreqType == UA_SAMP_CONTNUOUS;
if (iscontinuous)
snprintf(freq_descr, sizeof(freq_descr), "continous min %d max %d", UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
else
snprintf(freq_descr, sizeof(freq_descr), "fixed frequency (%d listed formats)", asf1d->bSamFreqType);
if (numchan == 1)
numchannel_descr = " (mono)";
else if (numchan == 2)
numchannel_descr = " (stereo)";
else
numchannel_descr = "";
if (bootverbose) {
device_printf(dev, "uaudio_query_formats: found a native %s channel%s %s %dbit %dbytes/subframe X %d channels = %d bytes per sample\n",
(dir==UE_DIR_OUT)?"playback":"record",
numchannel_descr, freq_descr,
prec, subframesize, numchan, subframesize*numchan);
}
/*
* Now start rejecting the ones that don't map to FreeBSD
*/
if (numchan != 1 && numchan != 2)
continue;
for (iterator = accepted_conversion ; iterator->uaudio_fmt != 0 ; iterator++)
if (iterator->uaudio_fmt == format && iterator->uaudio_prec == prec)
break;
if (iterator->uaudio_fmt == 0)
continue;
fmt = iterator->freebsd_fmt;
if (numchan == 2)
fmt |= AFMT_STEREO;
foundcount++;
if (fmtcount >= maxfmt)
continue;
cap->fmtlist[fmtcount++] = fmt;
if (iscontinuous) {
freq_min = UA_SAMP_LO(asf1d);
freq_max = UA_SAMP_HI(asf1d);
if (cap->minspeed == 0 || freq_min < cap->minspeed)
cap->minspeed = freq_min;
if (cap->maxspeed == 0)
cap->maxspeed = cap->minspeed;
if (freq_max > cap->maxspeed)
cap->maxspeed = freq_max;
} else {
for (r = 0; r < asf1d->bSamFreqType; r++) {
freq = UA_GETSAMP(asf1d, r);
if (cap->minspeed == 0 || freq < cap->minspeed)
cap->minspeed = freq;
if (cap->maxspeed == 0)
cap->maxspeed = cap->minspeed;
if (freq > cap->maxspeed)
cap->maxspeed = freq;
}
}
}
cap->fmtlist[fmtcount] = 0;
return foundcount;
}
void
uaudio_chan_set_param_pcm_dma_buff(device_t dev, u_char *start, u_char *end,
struct pcm_channel *pc, int dir)
{
struct uaudio_softc *sc;
struct chan *ch;
sc = device_get_softc(dev);
#ifndef NO_RECORDING
if (dir == PCMDIR_PLAY)
ch = &sc->sc_playchan;
else
ch = &sc->sc_recchan;
#else
ch = &sc->sc_playchan;
#endif
ch->start = start;
ch->end = end;
ch->pcm_ch = pc;
return;
}
void
uaudio_chan_set_param_blocksize(device_t dev, u_int32_t blocksize, int dir)
{
struct uaudio_softc *sc;
struct chan *ch;
sc = device_get_softc(dev);
#ifndef NO_RECORDING
if (dir == PCMDIR_PLAY)
ch = &sc->sc_playchan;
else
ch = &sc->sc_recchan;
#else
ch = &sc->sc_playchan;
#endif
ch->blksize = blocksize;
return;
}
int
uaudio_chan_set_param_speed(device_t dev, u_int32_t speed, int reqdir)
{
const struct uaudio_conversion *iterator;
struct uaudio_softc *sc;
struct chan *ch;
int i, r, score, hiscore, bestspeed;
sc = device_get_softc(dev);
#ifndef NO_RECORDING
if (reqdir == PCMDIR_PLAY)
ch = &sc->sc_playchan;
else
ch = &sc->sc_recchan;
#else
ch = &sc->sc_playchan;
#endif
/*
* We are successful if we find an endpoint that matches our selected format and it
* supports the requested speed.
*/
hiscore = 0;
bestspeed = 1;
for (i = 0; i < sc->sc_nalts; i++) {
int dir = UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress);
int format = sc->sc_alts[i].encoding;
const struct usb_audio_streaming_type1_descriptor *asf1d = sc->sc_alts[i].asf1desc;
int iscontinuous = asf1d->bSamFreqType == UA_SAMP_CONTNUOUS;
if ((dir == UE_DIR_OUT) != (reqdir == PCMDIR_PLAY))
continue;
for (iterator = accepted_conversion ; iterator->uaudio_fmt != 0 ; iterator++)
if (iterator->uaudio_fmt != format || iterator->freebsd_fmt != (ch->format&0xfffffff))
continue;
if (iscontinuous) {
if (speed >= UA_SAMP_LO(asf1d) && speed <= UA_SAMP_HI(asf1d)) {
ch->sample_rate = speed;
return speed;
} else if (speed < UA_SAMP_LO(asf1d)) {
score = 0xfff * speed / UA_SAMP_LO(asf1d);
if (score > hiscore) {
bestspeed = UA_SAMP_LO(asf1d);
hiscore = score;
}
} else if (speed > UA_SAMP_HI(asf1d)) {
score = 0xfff * UA_SAMP_HI(asf1d) / speed;
if (score > hiscore) {
bestspeed = UA_SAMP_HI(asf1d);
hiscore = score;
}
}
continue;
}
for (r = 0; r < asf1d->bSamFreqType; r++) {
if (speed == UA_GETSAMP(asf1d, r)) {
ch->sample_rate = speed;
return speed;
}
if (speed > UA_GETSAMP(asf1d, r))
score = 0xfff * UA_GETSAMP(asf1d, r) / speed;
else
score = 0xfff * speed / UA_GETSAMP(asf1d, r);
if (score > hiscore) {
bestspeed = UA_GETSAMP(asf1d, r);
hiscore = score;
}
}
}
if (bestspeed != 1) {
ch->sample_rate = bestspeed;
return bestspeed;
}
return 0;
}
int
uaudio_chan_getptr(device_t dev, int dir)
{
struct uaudio_softc *sc;
struct chan *ch;
int ptr;
sc = device_get_softc(dev);
#ifndef NO_RECORDING
if (dir == PCMDIR_PLAY)
ch = &sc->sc_playchan;
else
ch = &sc->sc_recchan;
#else
ch = &sc->sc_playchan;
#endif
ptr = ch->cur - ch->start;
return ptr;
}
void
uaudio_chan_set_param_format(device_t dev, u_int32_t format, int dir)
{
struct uaudio_softc *sc;
struct chan *ch;
sc = device_get_softc(dev);
#ifndef NO_RECORDING
if (dir == PCMDIR_PLAY)
ch = &sc->sc_playchan;
else
ch = &sc->sc_recchan;
#else
ch = &sc->sc_playchan;
#endif
ch->format = format;
return;
}
int
uaudio_halt_out_dma(device_t dev)
{
struct uaudio_softc *sc;
sc = device_get_softc(dev);
DPRINTF(("uaudio_halt_out_dma: enter\n"));
if (sc->sc_playchan.pipe != NULL) {
uaudio_chan_close(sc, &sc->sc_playchan);
sc->sc_playchan.pipe = 0;
uaudio_chan_free_buffers(sc, &sc->sc_playchan);
}
return (0);
}
int
uaudio_halt_in_dma(device_t dev)
{
struct uaudio_softc *sc;
sc = device_get_softc(dev);
if (sc->sc_dying)
return (EIO);
DPRINTF(("uaudio_halt_in_dma: enter\n"));
if (sc->sc_recchan.pipe != NULL) {
uaudio_chan_close(sc, &sc->sc_recchan);
sc->sc_recchan.pipe = NULL;
uaudio_chan_free_buffers(sc, &sc->sc_recchan);
/* sc->sc_recchan.intr = NULL; */
}
return (0);
}
int
uaudio_trigger_input(device_t dev)
{
struct uaudio_softc *sc;
struct chan *ch;
usbd_status err;
int i, s;
sc = device_get_softc(dev);
ch = &sc->sc_recchan;
if (sc->sc_dying)
return (EIO);
/* uaudio_chan_set_param(ch, start, end, blksize) */
if (uaudio_init_params(sc, ch, AUMODE_RECORD))
return (EIO);
err = uaudio_chan_alloc_buffers(sc, ch);
if (err)
return (EIO);
err = uaudio_chan_open(sc, ch);
if (err) {
uaudio_chan_free_buffers(sc, ch);
return (EIO);
}
/* ch->intr = intr;
ch->arg = arg; */
s = splusb();
for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
uaudio_chan_rtransfer(ch);
splx(s);
return (0);
}
int
uaudio_trigger_output(device_t dev)
{
struct uaudio_softc *sc;
struct chan *ch;
usbd_status err;
int i, s;
sc = device_get_softc(dev);
ch = &sc->sc_playchan;
if (sc->sc_dying)
return (EIO);
if (uaudio_init_params(sc, ch, AUMODE_PLAY))
return (EIO);
err = uaudio_chan_alloc_buffers(sc, ch);
if (err)
return (EIO);
err = uaudio_chan_open(sc, ch);
if (err) {
uaudio_chan_free_buffers(sc, ch);
return (EIO);
}
s = splusb();
for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
uaudio_chan_ptransfer(ch);
splx(s);
return (0);
}
u_int32_t
uaudio_query_mix_info(device_t dev)
{
int i;
u_int32_t mask = 0;
struct uaudio_softc *sc;
struct mixerctl *mc;
sc = device_get_softc(dev);
for (i=0; i < sc->sc_nctls; i++) {
mc = &sc->sc_ctls[i];
if (mc->ctl != SOUND_MIXER_NRDEVICES) {
/* Set device mask bits.
See /usr/include/machine/soundcard.h */
mask |= (1 << mc->ctl);
}
}
return mask;
}
u_int32_t
uaudio_query_recsrc_info(device_t dev)
{
int i, rec_selector_id;
u_int32_t mask = 0;
struct uaudio_softc *sc;
struct mixerctl *mc;
sc = device_get_softc(dev);
rec_selector_id = -1;
for (i=0; i < sc->sc_nctls; i++) {
mc = &sc->sc_ctls[i];
if (mc->ctl == SOUND_MIXER_NRDEVICES &&
mc->type == MIX_SELECTOR && mc->class == UAC_RECORD) {
if (rec_selector_id == -1) {
rec_selector_id = i;
} else {
printf("There are many selectors. Can't recognize which selector is a record source selector.\n");
return mask;
}
}
}
if (rec_selector_id == -1)
return mask;
mc = &sc->sc_ctls[rec_selector_id];
for (i = mc->minval; i <= mc->maxval; i++) {
if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
continue;
mask |= 1 << mc->slctrtype[i - 1];
}
return mask;
}
void
uaudio_mixer_set(device_t dev, unsigned type, unsigned left, unsigned right)
{
int i;
struct uaudio_softc *sc;
struct mixerctl *mc;
sc = device_get_softc(dev);
for (i=0; i < sc->sc_nctls; i++) {
mc = &sc->sc_ctls[i];
if (mc->ctl == type) {
if (mc->nchan == 2) {
/* set Right */
uaudio_ctl_set(sc, SET_CUR, mc, 1, (int)(right*255)/100);
}
/* set Left or Mono */
uaudio_ctl_set(sc, SET_CUR, mc, 0, (int)(left*255)/100);
}
}
return;
}
u_int32_t
uaudio_mixer_setrecsrc(device_t dev, u_int32_t src)
{
int i, rec_selector_id;
struct uaudio_softc *sc;
struct mixerctl *mc;
sc = device_get_softc(dev);
rec_selector_id = -1;
for (i=0; i < sc->sc_nctls; i++) {
mc = &sc->sc_ctls[i];
if (mc->ctl == SOUND_MIXER_NRDEVICES &&
mc->type == MIX_SELECTOR && mc->class == UAC_RECORD) {
if (rec_selector_id == -1) {
rec_selector_id = i;
} else {
return src; /* Can't recognize which selector is record source selector */
}
}
}
if (rec_selector_id == -1)
return src;
mc = &sc->sc_ctls[rec_selector_id];
for (i = mc->minval; i <= mc->maxval; i++) {
if (src != (1 << mc->slctrtype[i - 1]))
continue;
uaudio_ctl_set(sc, SET_CUR, mc, 0, i);
return (1 << mc->slctrtype[i - 1]);
}
uaudio_ctl_set(sc, SET_CUR, mc, 0, mc->minval);
return (1 << mc->slctrtype[mc->minval - 1]);
}
static int
uaudio_sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
{
struct snddev_info *d;
struct pcm_channel *c;
struct pcm_feeder *f;
device_t pa_dev = device_get_parent(dev);
struct uaudio_softc *sc = device_get_softc(pa_dev);
if (verbose < 1)
return 0;
d = device_get_softc(dev);
if (!d)
return ENXIO;
snd_mtxlock(d->lock);
if (CHN_EMPTY(d, channels.pcm)) {
sbuf_printf(s, " (mixer only)");
snd_mtxunlock(d->lock);
return 0;
}
sbuf_printf(s, " (%dp:%dv/%dr:%dv channels%s%s)",
d->playcount, d->pvchancount,
d->reccount, d->rvchancount,
(d->flags & SD_F_SIMPLEX)? "" : " duplex",
#ifdef USING_DEVFS
(device_get_unit(dev) == snd_unit)? " default" : ""
#else
""
#endif
);
if (sc->uaudio_sndstat_flag != 0) {
sbuf_cat(s, sbuf_data(&(sc->uaudio_sndstat)));
}
if (verbose <= 1) {
snd_mtxunlock(d->lock);
return 0;
}
CHN_FOREACH(c, d, channels.pcm) {
sbuf_printf(s, "\n\t");
KASSERT(c->bufhard != NULL && c->bufsoft != NULL,
("hosed pcm channel setup"));
/* it would be better to indent child channels */
sbuf_printf(s, "%s[%s]: ", c->parentchannel? c->parentchannel->name : "", c->name);
sbuf_printf(s, "spd %d", c->speed);
if (c->speed != sndbuf_getspd(c->bufhard))
sbuf_printf(s, "/%d", sndbuf_getspd(c->bufhard));
sbuf_printf(s, ", fmt 0x%08x", c->format);
if (c->format != sndbuf_getfmt(c->bufhard))
sbuf_printf(s, "/0x%08x", sndbuf_getfmt(c->bufhard));
sbuf_printf(s, ", flags 0x%08x, 0x%08x", c->flags, c->feederflags);
if (c->pid != -1)
sbuf_printf(s, ", pid %d", c->pid);
sbuf_printf(s, "\n\t");
sbuf_printf(s, "interrupts %d, ", c->interrupts);
if (c->direction == PCMDIR_REC)
sbuf_printf(s, "overruns %d, feed %u, hfree %d, sfree %d [b:%d/%d/%d|bs:%d/%d/%d]",
c->xruns, c->feedcount, sndbuf_getfree(c->bufhard), sndbuf_getfree(c->bufsoft),
sndbuf_getsize(c->bufhard), sndbuf_getblksz(c->bufhard),
sndbuf_getblkcnt(c->bufhard),
sndbuf_getsize(c->bufsoft), sndbuf_getblksz(c->bufsoft),
sndbuf_getblkcnt(c->bufsoft));
else
sbuf_printf(s, "underruns %d, feed %u, ready %d [b:%d/%d/%d|bs:%d/%d/%d]",
c->xruns, c->feedcount, sndbuf_getready(c->bufsoft),
sndbuf_getsize(c->bufhard), sndbuf_getblksz(c->bufhard),
sndbuf_getblkcnt(c->bufhard),
sndbuf_getsize(c->bufsoft), sndbuf_getblksz(c->bufsoft),
sndbuf_getblkcnt(c->bufsoft));
sbuf_printf(s, "\n\t");
sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "hardware" : "userland");
sbuf_printf(s, " -> ");
f = c->feeder;
while (f->source != NULL)
f = f->source;
while (f != NULL) {
sbuf_printf(s, "%s", f->class->name);
if (f->desc->type == FEEDER_FMT)
sbuf_printf(s, "(0x%08x -> 0x%08x)", f->desc->in, f->desc->out);
if (f->desc->type == FEEDER_RATE)
sbuf_printf(s, "(%d -> %d)", FEEDER_GET(f, FEEDRATE_SRC), FEEDER_GET(f, FEEDRATE_DST));
if (f->desc->type == FEEDER_ROOT || f->desc->type == FEEDER_MIXER)
sbuf_printf(s, "(0x%08x)", f->desc->out);
sbuf_printf(s, " -> ");
f = f->parent;
}
sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "userland" : "hardware");
}
snd_mtxunlock(d->lock);
return 0;
}
void
uaudio_sndstat_register(device_t dev)
{
struct snddev_info *d = device_get_softc(dev);
sndstat_register(dev, d->status, uaudio_sndstat_prepare_pcm);
}
int
uaudio_get_vendor(device_t dev)
{
struct uaudio_softc *sc = device_get_softc(dev);
if (sc == NULL)
return 0;
return sc->sc_vendor;
}
int
uaudio_get_product(device_t dev)
{
struct uaudio_softc *sc = device_get_softc(dev);
if (sc == NULL)
return 0;
return sc->sc_product;
}
int
uaudio_get_release(device_t dev)
{
struct uaudio_softc *sc = device_get_softc(dev);
if (sc == NULL)
return 0;
return sc->sc_release;
}
static int
audio_attach_mi(device_t dev)
{
device_t child;
struct sndcard_func *func;
/* Attach the children. */
/* PCM Audio */
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
if (func == NULL)
return (ENOMEM);
func->func = SCF_PCM;
child = device_add_child(dev, "pcm", -1);
device_set_ivars(child, func);
bus_generic_attach(dev);
return 0; /* XXXXX */
}
DRIVER_MODULE(uaudio, uhub, uaudio_driver, uaudio_devclass, usbd_driver_load, 0);
MODULE_VERSION(uaudio, 1);
#endif
Reference in New Issue View Git Blame Copy Permalink