53#include <sys/stdint.h>
54#include <sys/stddef.h>
59#include <sys/kernel.h>
61#include <sys/module.h>
64#include <sys/condvar.h>
65#include <sys/sysctl.h>
67#include <sys/unistd.h>
68#include <sys/callout.h>
69#include <sys/malloc.h>
72#include <dev/hid/hid.h>
82#define USB_DEBUG_VAR uaudio_debug
87#include <sys/reboot.h>
89#ifdef HAVE_KERNEL_OPTION_HEADERS
105static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
109SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RWTUN,
111SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RWTUN,
113SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RWTUN,
122 err = sysctl_handle_int(oidp, &
val, 0,
req);
137 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0,
sizeof(
int),
139 "uaudio buffering delay from 2ms to 8ms");
144SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RWTUN,
147#define uaudio_debug 0
150#define UAUDIO_NFRAMES 64
151#define UAUDIO_NCHANBUFS 2
152#define UAUDIO_RECURSE_LIMIT 255
153#define UAUDIO_CHANNELS_MAX MIN(64, AFMT_CHANNEL_MAX)
154#define UAUDIO_MATRIX_MAX 8
156#define MAKE_WORD(h,l) (((h) << 8) | (l))
157#define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1)
158#define UAUDIO_MAX_CHAN(x) (x)
159#define MIX(sc) ((sc)->sc_mixer_node)
181#define MIX_MAX_CHAN 16
193#define MIX_SIGNED_16 2
194#define MIX_UNSIGNED_16 3
195#define MIX_SIGNED_8 4
196#define MIX_SELECTOR 5
198#define MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \
199 ((n) == MIX_UNSIGNED_16)) ? 2 : 1)
200#define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
202#define MAX_SELECTOR_INPUT_PIN 256
216#define CHAN_MAX_ALT 24
221 const usb_endpoint_descriptor_audio_t *
p_ed1;
266#define CHAN_OP_NONE 0
267#define CHAN_OP_START 1
268#define CHAN_OP_STOP 2
269#define CHAN_OP_DRAIN 3
274#define UMIDI_EMB_JACK_MAX 16
275#define UMIDI_TX_FRAMES 256
276#define UMIDI_TX_BUFFER (UMIDI_TX_FRAMES * 4)
290#define UMIDI_ST_UNKNOWN 0
291#define UMIDI_ST_1PARAM 1
292#define UMIDI_ST_2PARAM_1 2
293#define UMIDI_ST_2PARAM_2 3
294#define UMIDI_ST_SYSEX_0 4
295#define UMIDI_ST_SYSEX_1 5
296#define UMIDI_ST_SYSEX_2 6
340#define UAUDIO_HID_VALID 0x0001
341#define UAUDIO_HID_HAS_ID 0x0002
342#define UAUDIO_HID_HAS_VOLUME_UP 0x0004
343#define UAUDIO_HID_HAS_VOLUME_DOWN 0x0008
344#define UAUDIO_HID_HAS_MUTE 0x0010
351#define UAUDIO_SPDIF_OUT 0x01
352#define UAUDIO_SPDIF_OUT_48K 0x02
353#define UAUDIO_SPDIF_OUT_96K 0x04
354#define UAUDIO_SPDIF_IN_MIX 0x10
356#define UAUDIO_MAX_CHILD 2
444 {
UA_FMT_PCM, 16, AFMT_S16_LE,
"16-bit S-LE PCM"},
445 {
UA_FMT_PCM, 24, AFMT_S24_LE,
"24-bit S-LE PCM"},
446 {
UA_FMT_PCM, 32, AFMT_S32_LE,
"32-bit S-LE PCM"},
540 struct usb_device *, uint32_t, uint8_t, uint8_t);
568static void uaudio_chan_dump_ep_desc(
569 const usb_endpoint_descriptor_audio_t *);
580 .flags = {.short_xfer_ok = 1,},
590 .flags = {.short_xfer_ok = 1,},
600 .flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,},
613 .flags = {.short_xfer_ok = 1,},
623 .flags = {.short_xfer_ok = 1,},
633 .flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,},
677 .flags = {.no_pipe_ok = 1},
686 .flags = {.short_xfer_ok = 1,.proxy_buffer = 1,.no_pipe_ok = 1},
698 .flags = {.short_xfer_ok = 1,},
709 DEVMETHOD(device_suspend, bus_generic_suspend),
710 DEVMETHOD(device_resume, bus_generic_resume),
711 DEVMETHOD(device_shutdown, bus_generic_shutdown),
724 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1000, 0) },
725 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1001, 0) },
726 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1002, 0) },
727 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1003, 0) },
728 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1004, 3) },
729 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1005, 0) },
730 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1006, 0) },
731 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1007, 0) },
732 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1008, 0) },
733 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1009, 0) },
734 {
USB_VPI(USB_VENDOR_YAMAHA, 0x100a, 3) },
735 {
USB_VPI(USB_VENDOR_YAMAHA, 0x100c, 0) },
736 {
USB_VPI(USB_VENDOR_YAMAHA, 0x100d, 0) },
737 {
USB_VPI(USB_VENDOR_YAMAHA, 0x100e, 0) },
738 {
USB_VPI(USB_VENDOR_YAMAHA, 0x100f, 0) },
739 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1010, 0) },
740 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1011, 0) },
741 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1012, 0) },
742 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1013, 0) },
743 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1014, 0) },
744 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1015, 0) },
745 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1016, 0) },
746 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1017, 0) },
747 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1018, 0) },
748 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1019, 0) },
749 {
USB_VPI(USB_VENDOR_YAMAHA, 0x101a, 0) },
750 {
USB_VPI(USB_VENDOR_YAMAHA, 0x101b, 0) },
751 {
USB_VPI(USB_VENDOR_YAMAHA, 0x101c, 0) },
752 {
USB_VPI(USB_VENDOR_YAMAHA, 0x101d, 0) },
753 {
USB_VPI(USB_VENDOR_YAMAHA, 0x101e, 0) },
754 {
USB_VPI(USB_VENDOR_YAMAHA, 0x101f, 0) },
755 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1020, 0) },
756 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1021, 0) },
757 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1022, 0) },
758 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1023, 0) },
759 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1024, 0) },
760 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1025, 0) },
761 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1026, 0) },
762 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1027, 0) },
763 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1028, 0) },
764 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1029, 0) },
765 {
USB_VPI(USB_VENDOR_YAMAHA, 0x102a, 0) },
766 {
USB_VPI(USB_VENDOR_YAMAHA, 0x102b, 0) },
767 {
USB_VPI(USB_VENDOR_YAMAHA, 0x102e, 0) },
768 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1030, 0) },
769 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1031, 0) },
770 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1032, 0) },
771 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1033, 0) },
772 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1034, 0) },
773 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1035, 0) },
774 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1036, 0) },
775 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1037, 0) },
776 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1038, 0) },
777 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1039, 0) },
778 {
USB_VPI(USB_VENDOR_YAMAHA, 0x103a, 0) },
779 {
USB_VPI(USB_VENDOR_YAMAHA, 0x103b, 0) },
780 {
USB_VPI(USB_VENDOR_YAMAHA, 0x103c, 0) },
781 {
USB_VPI(USB_VENDOR_YAMAHA, 0x103d, 0) },
782 {
USB_VPI(USB_VENDOR_YAMAHA, 0x103e, 0) },
783 {
USB_VPI(USB_VENDOR_YAMAHA, 0x103f, 0) },
784 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1040, 0) },
785 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1041, 0) },
786 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1042, 0) },
787 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1043, 0) },
788 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1044, 0) },
789 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1045, 0) },
790 {
USB_VPI(USB_VENDOR_YAMAHA, 0x104e, 0) },
791 {
USB_VPI(USB_VENDOR_YAMAHA, 0x104f, 0) },
792 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1050, 0) },
793 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1051, 0) },
794 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1052, 0) },
795 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1053, 0) },
796 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1054, 0) },
797 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1055, 0) },
798 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1056, 0) },
799 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1057, 0) },
800 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1058, 0) },
801 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1059, 0) },
802 {
USB_VPI(USB_VENDOR_YAMAHA, 0x105a, 0) },
803 {
USB_VPI(USB_VENDOR_YAMAHA, 0x105b, 0) },
804 {
USB_VPI(USB_VENDOR_YAMAHA, 0x105c, 0) },
805 {
USB_VPI(USB_VENDOR_YAMAHA, 0x105d, 0) },
806 {
USB_VPI(USB_VENDOR_YAMAHA, 0x1503, 3) },
807 {
USB_VPI(USB_VENDOR_YAMAHA, 0x2000, 0) },
808 {
USB_VPI(USB_VENDOR_YAMAHA, 0x2001, 0) },
809 {
USB_VPI(USB_VENDOR_YAMAHA, 0x2002, 0) },
810 {
USB_VPI(USB_VENDOR_YAMAHA, 0x2003, 0) },
811 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5000, 0) },
812 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5001, 0) },
813 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5002, 0) },
814 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5003, 0) },
815 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5004, 0) },
816 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5005, 0) },
817 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5006, 0) },
818 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5007, 0) },
819 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5008, 0) },
820 {
USB_VPI(USB_VENDOR_YAMAHA, 0x5009, 0) },
821 {
USB_VPI(USB_VENDOR_YAMAHA, 0x500a, 0) },
822 {
USB_VPI(USB_VENDOR_YAMAHA, 0x500b, 0) },
823 {
USB_VPI(USB_VENDOR_YAMAHA, 0x500c, 0) },
824 {
USB_VPI(USB_VENDOR_YAMAHA, 0x500d, 0) },
825 {
USB_VPI(USB_VENDOR_YAMAHA, 0x500e, 0) },
826 {
USB_VPI(USB_VENDOR_YAMAHA, 0x500f, 0) },
827 {
USB_VPI(USB_VENDOR_YAMAHA, 0x7000, 0) },
828 {
USB_VPI(USB_VENDOR_YAMAHA, 0x7010, 0) },
849 panic(
"uaudio_get_child_index_dev: Invalid device: %p\n",
dev);
863 panic(
"uaudio_get_child_index_by_chan: Invalid chan: %p\n", ch);
879 return (BUS_PROBE_SPECIFIC);
894 return (BUS_PROBE_GENERIC);
903 return (BUS_PROBE_GENERIC);
915 uint8_t cmd[2][4] = {
916 {0x20, 0x20, 0x00, 0},
917 {0x20, 0x30, 0x02, 1}
932 for (i = 0; i < 2; i++) {
934 cmd[i],
sizeof(cmd[0]),
955 if (iface == NULL || iface->
idesc == NULL)
1019 DPRINTF(
"audio rev %d.%02x\n",
1025 (uaa->
info.
idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA ||
1026 uaa->
info.
idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA8R)) {
1027 DPRINTF(
"Generating mixer descriptors\n");
1032 DPRINTF(
"%d mixer controls\n",
1049 DPRINTF(
"setting of alternate index failed: %s!\n",
1054 device_printf(
dev,
"Play[%u]: %d Hz, %d ch, %s format, "
1055 "2x%dms buffer.\n", i,
1063 device_printf(
dev,
"No playback.\n");
1079 DPRINTF(
"setting of alternate index failed: %s!\n",
1084 device_printf(
dev,
"Record[%u]: %d Hz, %d ch, %s format, "
1085 "2x%dms buffer.\n", i,
1093 device_printf(
dev,
"No recording.\n");
1109 device_printf(
dev,
"MIDI sequencer.\n");
1111 device_printf(
dev,
"No MIDI sequencer.\n");
1114 DPRINTF(
"doing child attach\n");
1130 device_add_child(
dev,
"pcm", -1);
1140 if (bus_generic_attach(
dev)) {
1141 DPRINTF(
"child attach failed\n");
1147 device_printf(
dev,
"HID volume keys found.\n");
1149 device_printf(
dev,
"No HID volume keys found.\n");
1159 device_printf(
dev,
"Failed to enable S/PDIF at 48K\n");
1184 DPRINTF(
"hardware has swapped left and right\n");
1189 DPRINTF(
"software controlled main volume\n");
1198 DPRINTF(
"device needs bitperfect by default\n");
1233 SYSCTL_ADD_INT(device_get_sysctl_ctx(
dev),
1234 SYSCTL_CHILDREN(device_get_sysctl_tree(
dev)), OID_AUTO,
1236 0,
"Feedback sample rate in Hz");
1261 device_printf(
dev,
"Waiting for sound application to exit!\n");
1295 if (bus_generic_detach(
dev) != 0) {
1336 if (
chan->num_alt <= 0)
1342 operation =
chan->operation;
1343 switch (operation) {
1353 switch (operation) {
1358 mtx_lock(
chan->pcm_mtx);
1360 mtx_unlock(
chan->pcm_mtx);
1369 DPRINTF(
"setting of default alternate index failed: %s!\n",
1383 mtx_lock(
chan->pcm_mtx);
1384 next_alt =
chan->set_alt;
1385 mtx_unlock(
chan->pcm_mtx);
1387 chan_alt =
chan->usb_alt + next_alt;
1392 DPRINTF(
"setting of alternate index failed: %s!\n",
1407 for (x = 0; x != 256; x++) {
1426 DPRINTF(
"setting of sample rate failed! "
1427 "(continuing anyway)\n");
1437 DPRINTF(
"setting of sample rate failed! "
1438 "(continuing anyway)\n");
1443 DPRINTF(
"could not allocate USB transfers!\n");
1464 chan->bytes_per_frame[0] =
1470 chan->frames_per_second = fps;
1472 chan->sample_curr = 0;
1475 buf_size = (
chan->bytes_per_frame[1] *
frames);
1477 if (buf_size > (
chan->end -
chan->start)) {
1478 DPRINTF(
"buffer size is too big\n");
1484 DPRINTF(
"fps=%d sample_rem=%d\n", (
int)fps, (
int)
chan->sample_rem);
1486 if (
chan->intr_frames == 0) {
1487 DPRINTF(
"frame shift is too high!\n");
1491#if (UAUDIO_NCHANBUFS != 2)
1492#error "Please update code below!"
1495 mtx_lock(
chan->pcm_mtx);
1496 chan->cur_alt = next_alt;
1499 mtx_unlock(
chan->pcm_mtx);
1504 mtx_lock(
chan->pcm_mtx);
1506 mtx_unlock(
chan->pcm_mtx);
1529uaudio_chan_dump_ep_desc(
const usb_endpoint_descriptor_audio_t *ed)
1532 DPRINTF(
"endpoint=%p bLength=%d bDescriptorType=%d \n"
1533 "bEndpointAddress=%d bmAttributes=0x%x \n"
1534 "wMaxPacketSize=%d bInterval=%d \n"
1535 "bRefresh=%d bSynchAddress=%d\n",
1536 ed, ed->bLength, ed->bDescriptorType,
1537 ed->bEndpointAddress, ed->bmAttributes,
1538 UGETW(ed->wMaxPacketSize), ed->bInterval,
1556 uint32_t xps, uint32_t add)
1560 mps =
UGETW(ep->wMaxPacketSize);
1577 USETW(ep->wMaxPacketSize, xps);
1578 DPRINTF(
"Workaround: Updated wMaxPacketSize "
1579 "from %d to %d bytes.\n",
1580 (
int)mps, (
int)xps);
1587 uint8_t clockid, uint32_t
rate)
1591#define UAUDIO20_MAX_RATES 32
1597 DPRINTFN(6,
"ifaceno=%d clockid=%d rate=%u\n",
1598 iface_no, clockid,
rate);
1613 if (
error != 0 || actlen < 2) {
1628 }
else if (
rates > 1) {
1629 DPRINTF(
"Need to read full rate descriptor\n");
1638 actlen = (2 +
rates * 12);
1645 if (
error != 0 || actlen < 2)
1651 actlen = (actlen - 2) / 12;
1653 if (
rates > actlen) {
1654 DPRINTF(
"Too many rates truncating to %d\n", actlen);
1658 for (x = 0; x !=
rates; x++) {
1669 DPRINTF(
"Swapped max and min\n");
1677 (((
rate - min) % res) == 0)) {
1691 if (
chan->num_alt == 0) {
1702 uint32_t
rate, uint8_t channels, uint8_t bit_resolution)
1709 usb_endpoint_descriptor_audio_t *ed1 = NULL;
1717 uint16_t curidx = 0xFFFF;
1718 uint16_t lastidx = 0xFFFF;
1719 uint16_t alt_index = 0;
1720 uint16_t audio_rev = 0;
1724 uint8_t bBitResolution;
1725 uint8_t audio_if = 0;
1726 uint8_t midi_if = 0;
1727 uint8_t uma_if_class;
1731 (
desc->bLength >=
sizeof(*
id))) {
1734 if (
id->bInterfaceNumber != lastidx) {
1735 lastidx =
id->bInterfaceNumber;
1745 (
id->bInterfaceSubClass == 0) &&
1746 (
id->bInterfaceProtocol == 0) &&
1749 DPRINTF(
"Found HID interface at %d\n",
1760 if ((uma_if_class != 0) &&
1767 if ((uma_if_class != 0) &&
1802 if (audio_if == 0) {
1804 if ((acdp == NULL) &&
1807 (
desc->bLength >=
sizeof(*acdp))) {
1808 acdp = (
void *)
desc;
1812 msid = (
void *)
desc;
1815 if (msid->
bLength >=
sizeof(*msid) &&
1832 (asid.
v1 == NULL)) {
1836 if (
desc->bLength >=
sizeof(*asid.
v2)) {
1840 if (
desc->bLength >=
sizeof(*asid.
v1)) {
1848 (asf1d.
v1 == NULL)) {
1852 if (
desc->bLength >=
sizeof(*asf1d.
v2))
1855 if (
desc->bLength >=
sizeof(*asf1d.
v1)) {
1859 DPRINTFN(11,
"ignored bFormatType = %d\n",
1864 if (
desc->bLength < (
sizeof(*asf1d.
v1) +
1867 DPRINTFN(11,
"invalid descriptor, "
1891 if (
desc->bLength >=
sizeof(*sed.
v2))
1894 if (
desc->bLength >=
sizeof(*sed.
v1))
1898 if (asid.
v1 == NULL || asf1d.
v1 == NULL ||
1899 ed1 == NULL || sed.
v1 == NULL) {
1918 (bBitResolution != bit_resolution)) {
1919 DPRINTF(
"Wrong number of channels\n");
1931 DPRINTF(
"Unsupported audio format\n");
1935 for (x = 0; x != 256; x++) {
1948 DPRINTF(
"Checking clock ID=%d\n", x);
1952 DPRINTF(
"Unsupported sampling "
1953 "rate, id=%d\n", x);
1965 DPRINTFN(16,
"Sample rate: %d-%dHz\n",
1974 DPRINTFN(16,
"Sample rate = %dHz\n",
1991 DPRINTF(
"Unsupported audio format\n");
1996 (bBitResolution != bit_resolution)) {
1997 DPRINTF(
"Wrong number of channels\n");
2010 DPRINTF(
"Interface is not valid\n");
2014 DPRINTF(
"Too many alternate settings\n");
2020 chan_alt = &
chan->usb_alt[
chan->num_alt++];
2023 uaudio_chan_dump_ep_desc(ed1);
2025 DPRINTF(
"Sample rate = %dHz, channels = %d, "
2026 "bits = %d, format = %s, ep 0x%02x, chan %p\n",
rate,
channels,
2031 chan_alt->
p_ed1 = ed1;
2033 chan_alt->
p_sed = sed;
2077 DPRINTF(
"The selected audio format is not supported\n");
2081 if (
chan->num_alt > 1) {
2084 DPRINTF(
"Multiple formats is not supported\n");
2089 if (
rate ==
chan->usb_alt[
chan->num_alt - 2].sample_rate) {
2090 DPRINTF(
"Duplicate sample rate detected\n");
2095 chan->pcm_cap.fmtlist =
chan->pcm_format;
2102 if (rate < chan->pcm_cap.minspeed ||
chan->pcm_cap.minspeed == 0)
2104 if (
rate >
chan->pcm_cap.maxspeed ||
chan->pcm_cap.maxspeed == 0)
2109 "mode %d.%d:(%s) %dch, %dbit, %s, %dHz",
2111 (ep_dir ==
UE_DIR_IN) ?
"input" :
"output",
2159 if ((bits == 0) || (bits > 32)) {
2182 if (sbuf_new(&sc->
sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND))
2188 for (y = bits; y; y -= 8) {
2207 uint64_t sample_rate;
2222 DPRINTFN(6,
"transferred %d bytes\n", actlen);
2232 memset(
buf, 0,
sizeof(
buf));
2239 DPRINTF(
"Value = 0x%08x\n", (
int)temp);
2256 while (temp < (sample_rate - (sample_rate / 4)))
2259 while (temp > (sample_rate + (sample_rate / 2)))
2262 DPRINTF(
"Comparing %d Hz :: %d Hz\n",
2263 (
int)temp, (
int)sample_rate);
2270 int32_t jitter_max = howmany(sample_rate, 16000);
2332 DPRINTF(
"not running or no buffer!\n");
2349 if (ch_rec != NULL) {
2368 if (actlen < sumlen) {
2370 "%d of %d bytes\n", actlen, sumlen);
2378 if (ch_rec != NULL &&
2380 uint32_t rec_alt = ch_rec->
cur_alt;
2381 if (rec_alt < ch_rec->num_alt) {
2418 DPRINTF(
"bytes per transfer, %d, "
2419 "exceeds maximum, %d!\n",
2450 (frame_len + sample_size) <= mfl) {
2451 DPRINTFN(6,
"sending one sample more\n");
2453 frame_len += sample_size;
2455 frame_len >= sample_size) {
2456 DPRINTFN(6,
"sending one sample less\n");
2458 frame_len -= sample_size;
2464 DPRINTFN(6,
"transferring %d bytes\n", total);
2542 for (
n = 0;
n != nframes;
n++) {
2543 uint32_t offset1 = offset0;
2551 expected_bytes -=
len;
2578 ch->
jitter_curr -= (expected_bytes / sample_size);
2589 DPRINTFN(6,
"transferred %d bytes, jitter %d samples\n",
2600 for (
n = 0;
n != nframes;
n++)
2628 for (x = 0; x != ch->
num_alt; x++) {
2630 if (temp > buf_size)
2637 DPRINTF(
"Worst case buffer is %d bytes\n", (
int)buf_size);
2639 ch->
buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2640 if (ch->
buf == NULL)
2646 ch->
end = ch->
buf + buf_size;
2652 DPRINTF(
"ERROR: PCM channels does not have a mutex!\n");
2665 if (ch->
buf != NULL) {
2699 for (x = 0; x < ch->
num_alt; x++) {
2713 DPRINTF(
"Selecting alt %d\n", (
int)x);
2757 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1,
2758 -1, -1, -1, -1, -1, -1, -1, -1, -1 }
2843 ch->
end = ch->
buf + temp;
2918 hint = oidp->oid_arg2;
2938 error = sysctl_handle_int(oidp, &temp, 0,
req);
2939 if (
error != 0 ||
req->newptr == NULL)
2947 temp <= pmc->maxval) {
2966 free(p_mc, M_USBDEV);
2975 struct sysctl_oid *mixer_tree;
2976 struct sysctl_oid *control_tree;
2984 mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(
dev),
2985 SYSCTL_CHILDREN(device_get_sysctl_tree(
dev)), OID_AUTO,
"mixer",
2986 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
"");
2988 if (mixer_tree == NULL)
2992 pmc = pmc->
next,
n++) {
2994 if (pmc->
nchan > 1) {
2995 snprintf(
buf,
sizeof(
buf),
"%s_%d_%d",
2998 snprintf(
buf,
sizeof(
buf),
"%s_%d",
3002 control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(
dev),
3003 SYSCTL_CHILDREN(mixer_tree), OID_AUTO,
buf,
3004 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
3005 "Mixer control nodes");
3007 if (control_tree == NULL)
3010 SYSCTL_ADD_PROC(device_get_sysctl_ctx(
dev),
3011 SYSCTL_CHILDREN(control_tree),
3013 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
3017 SYSCTL_ADD_INT(device_get_sysctl_ctx(
dev),
3018 SYSCTL_CHILDREN(control_tree),
3019 OID_AUTO,
"min", CTLFLAG_RD, 0, pmc->
minval,
3022 SYSCTL_ADD_INT(device_get_sysctl_ctx(
dev),
3023 SYSCTL_CHILDREN(control_tree),
3024 OID_AUTO,
"max", CTLFLAG_RD, 0, pmc->
maxval,
3027 SYSCTL_ADD_STRING(device_get_sysctl_ctx(
dev),
3028 SYSCTL_CHILDREN(control_tree),
3029 OID_AUTO,
"desc", CTLFLAG_RD, pmc->
desc, 0,
3043 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3047 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3048 MIX(sc).name =
"effect";
3053 MIX(sc).update[0] = 1;
3054 strlcpy(
MIX(sc).
desc,
"Room1,2,3,Hall1,2,Plate,Delay,Echo",
sizeof(
MIX(sc).
desc));
3057 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3060 for (chx = 0; chx != 8; chx++) {
3061 for (chy = 0; chy != 8; chy++) {
3064 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3065 MIX(sc).name =
"mix_rec";
3067 MIX(sc).update[0] = 1;
3068 MIX(sc).val_default = 0;
3070 "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
3076 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3077 MIX(sc).name =
"mix_play";
3079 MIX(sc).update[0] = 1;
3080 MIX(sc).val_default = (chx == chy) ? 2 : 0;
3082 "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
3088 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3092 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3093 MIX(sc).name =
"effect_vol";
3095 MIX(sc).update[0] = 1;
3097 MIX(sc).maxval = 0x7f;
3100 MIX(sc).update[0] = 1;
3104 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3108 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3109 MIX(sc).name =
"effect_dur";
3111 MIX(sc).update[0] = 1;
3113 MIX(sc).maxval = 0x7f00;
3114 MIX(sc).mul = 0x7f00;
3116 MIX(sc).update[0] = 1;
3120 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3124 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3125 MIX(sc).name =
"effect_fb";
3127 MIX(sc).update[0] = 1;
3129 MIX(sc).maxval = 0x7f;
3132 MIX(sc).update[0] = 1;
3133 strlcpy(
MIX(sc).
desc,
"Effect Feedback Volume",
sizeof(
MIX(sc).
desc));
3136 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3138 for (chy = 0; chy != 4; chy++) {
3141 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3142 MIX(sc).name =
"effect_ret";
3144 MIX(sc).update[0] = 1;
3146 "Effect Return %d Volume", chy + 1);
3151 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3154 for (chy = 0; chy != 8; chy++) {
3157 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3158 MIX(sc).name =
"effect_send";
3160 MIX(sc).update[0] = 1;
3162 "Effect Send AIn%d Volume", chy + 1);
3168 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3169 MIX(sc).name =
"effect_send";
3171 MIX(sc).update[0] = 1;
3173 "Effect Send DIn%d Volume", chy + 1);
3191 if (pmc->
ctl == SOUND_MIXER_NRDEVICES)
3207 malloc(
sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
3210 if (p_mc_new != NULL) {
3211 memcpy(p_mc_new, mc,
sizeof(*p_mc_new));
3217 for (ch = 0; ch < p_mc_new->
nchan; ch++) {
3274 DPRINTF(
"Resolution = %d\n", (
int)res);
3283 for (i = 0; i < mc->
nchan; i++) {
3286 DPRINTF(
"[mix] wIndex=%04x type=%d ctl='%d' "
3312 DPRINTFN(3,
"bUnitId=%d bNrInPins=%d\n",
3329 DPRINTFN(3,
"ichs=%d ochs=%d\n", ichs, ochs);
3331 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3339 for (p = i = 0; i < d0->
bNrInPins; i++) {
3343 for (
c = 0;
c < chs;
c++) {
3345 for (o = 0; o < ochs; o++) {
3346 bno = ((p +
c) * ochs) + o;
3357 for (
c = 0;
c < chs;
c++) {
3358 for (o = 0; o < ochs; o++) {
3359 bno = ((p +
c) * ochs) + o;
3364 MIX(sc).nchan = chs;
3389 DPRINTFN(3,
"bUnitId=%d bNrInPins=%d\n",
3406 DPRINTFN(3,
"ichs=%d ochs=%d\n", ichs, ochs);
3408 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3416 for (p = i = 0; i < d0->
bNrInPins; i++) {
3420 for (
c = 0;
c < chs;
c++) {
3422 for (o = 0; o < ochs; o++) {
3423 bno = ((p +
c) * ochs) + o;
3434 for (
c = 0;
c < chs;
c++) {
3435 for (o = 0; o < ochs; o++) {
3436 bno = ((p +
c) * ochs) + o;
3441 MIX(sc).nchan = chs;
3451 uint8_t reserve_feature[] = {
3456 SOUND_MIXER_DIGITAL1,
3457 SOUND_MIXER_DIGITAL2,
3458 SOUND_MIXER_DIGITAL3,
3460 const uint16_t reserve_max =
3461 sizeof(reserve_feature) /
sizeof(reserve_feature[0]);
3467 for (i = 0; i <
MIX(sc).maxval; i++) {
3468 if (
MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3470 for (j = 0; j != reserve_max; j++) {
3471 if (reserve_feature[j] ==
MIX(sc).slctrtype[i])
3472 reserve_feature[j] = SOUND_MIXER_NRDEVICES;
3477 for (i = 0; i <
MIX(sc).maxval; i++) {
3478 if (
MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3480 for (j = i + 1; j <
MIX(sc).maxval; j++) {
3481 if (
MIX(sc).slctrtype[j] == SOUND_MIXER_NRDEVICES)
3483 if (
MIX(sc).slctrtype[i] !=
MIX(sc).slctrtype[j])
3485 for (
k = 0;
k != reserve_max;
k++) {
3486 if (reserve_feature[
k] == SOUND_MIXER_NRDEVICES)
3488 MIX(sc).slctrtype[j] = reserve_feature[
k];
3489 reserve_feature[
k] = SOUND_MIXER_NRDEVICES;
3492 if (
k == reserve_max) {
3493 DPRINTF(
"Selector type %d is not selectable!\n", j);
3494 MIX(sc).slctrtype[j] = SOUND_MIXER_NRDEVICES;
3507 DPRINTFN(3,
"bUnitId=%d bNrInPins=%d\n",
3513 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3519 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3522 MIX(sc).name =
"selector";
3528 MIX(sc).desc[0] = 0;
3534 MIX(sc).mul =
MIX(sc).maxval -
MIX(sc).minval;
3536 for (i = 0; i <
MIX(sc).maxval; i++) {
3537 MIX(sc).slctrtype[i] =
3541 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3554 DPRINTFN(3,
"bUnitId=%d bNrInPins=%d\n",
3560 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3566 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3569 MIX(sc).name =
"selector";
3575 MIX(sc).desc[0] = 0;
3581 MIX(sc).mul =
MIX(sc).maxval -
MIX(sc).minval;
3583 for (i = 0; i <
MIX(sc).maxval; i++) {
3584 MIX(sc).slctrtype[i] =
3588 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3624 uint16_t mixernumber;
3633 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3645 DPRINTFN(10,
"chan=%d mask=%x\n",
3657 MIX(sc).desc[0] = 0;
3666 DPRINTFN(5,
"ctl=%d fumask=0x%04x\n",
3669 if (mmask & fumask) {
3672 }
else if (cmask & fumask) {
3673 MIX(sc).nchan = nchan - 1;
3674 for (i = 1; i < nchan; i++) {
3678 MIX(sc).wValue[i - 1] = -1;
3689 MIX(sc).ctl = SOUND_MIXER_MUTE;
3690 MIX(sc).name =
"mute";
3695 MIX(sc).ctl = mixernumber;
3696 MIX(sc).name =
"vol";
3701 MIX(sc).ctl = SOUND_MIXER_BASS;
3702 MIX(sc).name =
"bass";
3707 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3708 MIX(sc).name =
"mid";
3713 MIX(sc).ctl = SOUND_MIXER_TREBLE;
3714 MIX(sc).name =
"treble";
3722 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3723 MIX(sc).name =
"agc";
3728 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3729 MIX(sc).name =
"delay";
3734 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3735 MIX(sc).name =
"boost";
3740 MIX(sc).ctl = SOUND_MIXER_LOUD;
3741 MIX(sc).name =
"loudness";
3762 uint16_t mixernumber;
3771 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3791 MIX(sc).desc[0] = 0;
3797 for (ctl = 3; ctl != 0; ctl <<= 2) {
3803 MIX(sc).ctl = SOUND_MIXER_MUTE;
3804 MIX(sc).name =
"mute";
3809 MIX(sc).ctl = mixernumber;
3810 MIX(sc).name =
"vol";
3815 MIX(sc).ctl = SOUND_MIXER_BASS;
3816 MIX(sc).name =
"bass";
3821 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3822 MIX(sc).name =
"mid";
3827 MIX(sc).ctl = SOUND_MIXER_TREBLE;
3828 MIX(sc).name =
"treble";
3833 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3834 MIX(sc).name =
"agc";
3839 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3840 MIX(sc).name =
"delay";
3845 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3846 MIX(sc).name =
"boost";
3851 MIX(sc).ctl = SOUND_MIXER_LOUD;
3852 MIX(sc).name =
"loudness";
3857 MIX(sc).ctl = mixernumber;
3858 MIX(sc).name =
"igain";
3863 MIX(sc).ctl = mixernumber;
3864 MIX(sc).name =
"igainpad";
3871 if ((mmask & ctl) == ctl) {
3874 }
else if ((cmask & ctl) == ctl) {
3875 MIX(sc).nchan = nchan - 1;
3876 for (i = 1; i < nchan; i++) {
3880 MIX(sc).wValue[i - 1] = -1;
3909 DPRINTFN(3,
"bUnitId=%d bNrModes=%d\n",
3916 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3923 for (i = 0; i < ud->
bNrModes; i++) {
3924 DPRINTFN(3,
"i=%d bm=0x%x\n", i,
UGETW(ud->
waModes[i]));
3940 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
3944 DPRINTFN(3,
"wProcessType=%d bUnitId=%d "
3968 DPRINTF(
"unit %d, type=%d is not implemented\n",
3982 DPRINTFN(3,
"bUnitId=%d bNrInPins=%d\n",
3992 memset(&
MIX(sc), 0,
sizeof(
MIX(sc)));
4023 if (u.desc == NULL) {
4029 switch (u.desc->bDescriptorSubtype) {
4031 len +=
sizeof(*u.it);
4035 len +=
sizeof(*u.ot);
4039 len +=
sizeof(*u.mu);
4041 if (u.desc->bLength <
len) {
4044 len += u.mu->bNrInPins;
4046 if (u.desc->bLength <
len) {
4049 d1 = (
const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4055 len +=
sizeof(*u.su);
4057 if (u.desc->bLength <
len) {
4060 len += u.su->bNrInPins + 1;
4064 len +=
sizeof(*u.fu) + 1;
4066 if (u.desc->bLength <
len)
4069 len += u.fu->bControlSize;
4073 len +=
sizeof(*u.pu);
4075 if (u.desc->bLength <
len) {
4078 len += u.pu->bNrInPins;
4080 if (u.desc->bLength <
len) {
4083 u1 = (
const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4087 if (u.desc->bLength <
len) {
4095 len +=
sizeof(*u.eu);
4097 if (u.desc->bLength <
len) {
4100 len += u.eu->bNrInPins;
4102 if (u.desc->bLength <
len) {
4105 e1 = (
const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4109 if (u.desc->bLength <
len) {
4119 if (u.desc->bLength <
len) {
4126 DPRINTF(
"invalid descriptor, type=%d, "
4127 "sub_type=%d, len=%d of %d bytes\n",
4128 u.desc->bDescriptorType,
4129 u.desc->bDescriptorSubtype,
4130 u.desc->bLength,
len);
4167 switch (u.desc->bDescriptorSubtype) {
4169 len +=
sizeof(*u.it);
4173 len +=
sizeof(*u.ot);
4177 len +=
sizeof(*u.mu);
4179 if (u.desc->bLength <
len)
4181 len += u.mu->bNrInPins;
4183 if (u.desc->bLength <
len)
4186 d1 = (
const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4192 len +=
sizeof(*u.su);
4194 if (u.desc->bLength <
len)
4197 len += u.su->bNrInPins + 1;
4201 len +=
sizeof(*u.fu) + 1;
4205 len +=
sizeof(*u.ef) + 4;
4209 len +=
sizeof(*u.pu);
4211 if (u.desc->bLength <
len)
4214 len += u.pu->bNrInPins;
4216 if (u.desc->bLength <
len)
4219 u1 = (
const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4225 len +=
sizeof(*u.eu);
4227 if (u.desc->bLength <
len)
4230 len += u.eu->bNrInPins;
4232 if (u.desc->bLength <
len)
4235 e1 = (
const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4241 len +=
sizeof(*u.csrc);
4245 len +=
sizeof(*u.csel);
4247 if (u.desc->bLength <
len)
4250 len += u.csel->bNrInPins;
4252 if (u.desc->bLength <
len)
4255 c1 = (
const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4261 len +=
sizeof(*u.cmul);
4265 len +=
sizeof(*u.ru);
4272 if (u.desc->bLength <
len)
4279 DPRINTF(
"invalid descriptor, type=%d, "
4280 "sub_type=%d, len=%d of %d bytes\n",
4281 u.desc->bDescriptorType,
4282 u.desc->bDescriptorSubtype,
4283 u.desc->bLength,
len);
4296 dp = iot[
id].u.desc;
4302 r.bNrChannels = iot[
id].u.it_v1->bNrChannels;
4303 r.wChannelConfig[0] = iot[
id].u.it_v1->wChannelConfig[0];
4304 r.wChannelConfig[1] = iot[
id].u.it_v1->wChannelConfig[1];
4305 r.iChannelNames = iot[
id].u.it_v1->iChannelNames;
4309 id = iot[
id].u.ot_v1->bSourceId;
4314 &iot[
id].u.mu_v1->baSourceId[
4315 iot[
id].u.mu_v1->bNrInPins];
4319 if (iot[
id].u.su_v1->bNrInPins > 0) {
4321 id = iot[
id].u.su_v1->baSourceId[0];
4326 id = iot[
id].u.fu_v1->bSourceId;
4331 &iot[
id].u.pu_v1->baSourceId[
4332 iot[
id].u.pu_v1->bNrInPins]);
4337 &iot[
id].u.eu_v1->baSourceId[
4338 iot[
id].u.eu_v1->bNrInPins]);
4347 memset(&
r, 0,
sizeof(
r));
4360 dp = iot[
id].u.desc;
4366 r.bNrChannels = iot[
id].u.it_v2->bNrChannels;
4367 r.bmChannelConfig[0] = iot[
id].u.it_v2->bmChannelConfig[0];
4368 r.bmChannelConfig[1] = iot[
id].u.it_v2->bmChannelConfig[1];
4369 r.bmChannelConfig[2] = iot[
id].u.it_v2->bmChannelConfig[2];
4370 r.bmChannelConfig[3] = iot[
id].u.it_v2->bmChannelConfig[3];
4371 r.iChannelNames = iot[
id].u.it_v2->iTerminal;
4375 id = iot[
id].u.ot_v2->bSourceId;
4380 &iot[
id].u.mu_v2->baSourceId[
4381 iot[
id].u.mu_v2->bNrInPins];
4385 if (iot[
id].u.su_v2->bNrInPins > 0) {
4387 id = iot[
id].u.su_v2->baSourceId[0];
4392 id = iot[
id].u.ru_v2->bSourceId;
4396 id = iot[
id].u.ef_v2->bSourceId;
4400 id = iot[
id].u.fu_v2->bSourceId;
4405 &iot[
id].u.pu_v2->baSourceId[
4406 iot[
id].u.pu_v2->bNrInPins]);
4411 &iot[
id].u.eu_v2->baSourceId[
4412 iot[
id].u.eu_v2->bNrInPins]);
4421 memset(&
r, 0,
sizeof(
r));
4507 retval = default_type;
4512 retval = SOUND_MIXER_RECLEV;
4515 retval = SOUND_MIXER_PCM;
4518 retval = SOUND_MIXER_PHONEIN;
4521 retval = default_type;
4531 DPRINTF(
"terminal_type=0x%04x RET=%d DEF=%d\n",
4540 uint16_t terminal_type_input = 0;
4541 uint16_t terminal_type_output = 0;
4547 ptr = iot->
root + i;
4555 terminal_type_input = temp;
4559 ptr = iot->
root + i;
4567 terminal_type_output = temp;
4570 DPRINTF(
"MATCH=%d IN=0x%04x OUT=0x%04x\n",
4571 match, terminal_type_input, terminal_type_output);
4575 if (terminal_type_output != 0) {
4577 terminal_type_output, SOUND_MIXER_MONITOR));
4580 terminal_type_input, SOUND_MIXER_MONITOR));
4583 return (SOUND_MIXER_IMIX);
4586 terminal_type_input, SOUND_MIXER_RECLEV));
4589 terminal_type_output, SOUND_MIXER_PCM));
4591 return (SOUND_MIXER_NRDEVICES);
4599 uint16_t terminal_type_input = 0;
4600 uint16_t terminal_type_output = 0;
4606 ptr = iot->
root + i;
4614 terminal_type_input = temp;
4618 ptr = iot->
root + i;
4626 terminal_type_output = temp;
4629 DPRINTF(
"MATCH=%d IN=0x%04x OUT=0x%04x\n",
4630 match, terminal_type_input, terminal_type_output);
4634 if (terminal_type_output != 0) {
4636 terminal_type_output, SOUND_MIXER_MONITOR));
4639 terminal_type_input, SOUND_MIXER_MONITOR));
4642 return (SOUND_MIXER_IMIX);
4645 terminal_type_input, SOUND_MIXER_RECLEV));
4648 terminal_type_output, SOUND_MIXER_PCM));
4650 return (SOUND_MIXER_NRDEVICES);
4658 const uint8_t
max =
sizeof(
src->bit_output) /
sizeof(
src->bit_output[0]);
4661 for (x = 0; x !=
max; x++)
4667 const uint8_t *p_id, uint8_t n_id,
4674 for (
n = 0;
n < n_id;
n++) {
4678 DPRINTF(
"avoided going into a circle at id=%d!\n", i);
4686 if (iot->
u.
desc == NULL)
4692 info->
bit_input[i / 8] |= (1 << (i % 8));
4744 const uint8_t *p_id, uint8_t n_id,
4751 for (
n = 0;
n < n_id;
n++) {
4755 DPRINTF(
"avoided going into a circle at id=%d!\n", i);
4763 if (iot->
u.
desc == NULL)
4769 info->
bit_input[i / 8] |= (1 << (i % 8));
4834 const uint8_t *p_id, uint8_t n_id,
4844 for (
n = 0;
n < n_id;
n++) {
4848 DPRINTF(
"avoided going into a circle at id=%d!\n", i);
4856 if (iot->
u.
desc == NULL)
4859 is_last = ((
n + 1) == n_id);
4915 info->
bit_input[
id / 8] |= (1 << (
id % 8));
4944 DPRINTF(
"no Audio Control header\n");
4949 if ((acdp->
bLength <
sizeof(*acdp)) ||
4952 DPRINTF(
"invalid Audio Control header\n");
4961 DPRINTFN(3,
"found AC header, vers=%03x, len=%d\n",
4970 if (dp->
bLength > wTotalLen) {
4990 DPRINTF(
"Maximum ID=%d\n", ID_max);
5002 &i, 1, &((iot + i)->
usr));
5011 &i, 1, &((iot + i)->
usr));
5020 (iot + i)->root = iot;
5034 DPRINTFN(11,
"id=%d subtype=%d\n",
5042 DPRINTF(
"unexpected AC header\n");
5069 DPRINTF(
"bad AC desc subtype=0x%02x\n",
5078 DPRINTF(
"unexpected AC header\n");
5106 DPRINTF(
"bad AC desc subtype=0x%02x\n",
5123 uint8_t
data[2 + (2 * 3)];
5185 DPRINTFN(3,
"val=%d\n",
val);
5277 goto tr_transferred;
5287 DPRINTFN(6,
"endpt=%d speed=%u\n", endpt,
speed);
5303 uint8_t clockid, uint32_t
speed)
5308 DPRINTFN(6,
"ifaceno=%d clockid=%d speed=%u\n",
5309 iface_no, clockid,
speed);
5352 else if (val < mc->minval)
5355 DPRINTFN(6,
"type=0x%03x val=%d min=%d max=%d val=%d\n",
5362 uint8_t chan,
int val)
5383 if (mc->
ctl != SOUND_MIXER_NRDEVICES) {
5390 if ((mc->
ctl == SOUND_MIXER_NRDEVICES) &&
5392 for (i = mc->
minval; (i > 0) && (i <= mc->
maxval); i++) {
5393 if (mc->
slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
5415 DPRINTFN(0,
"could not allocate USB transfer for mixer!\n");
5476 if ((mc->
ctl == SOUND_MIXER_NRDEVICES) &&
5481 for (i = mc->
minval; (i > 0) && (i <= mc->
maxval); i++)
5489 temp = (-temp) & temp;
5495 for (i = mc->
minval; (i > 0) && (i <= mc->
maxval); i++) {
5496 if (temp != (1U << mc->
slctrtype[i - 1]))
5527 DPRINTF(
"actlen=%d bytes\n", actlen);
5532 while (actlen >= 4) {
5543 sub = &
chan->sub[cn];
5545 if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5550 buf + 1, cmd_len, 1);
5587 uint8_t p0 = (cn << 4);
5590 sub->
temp_0[0] = p0 | 0x0f;
5597 }
else if (
b >= 0xf0) {
5617 sub->
temp_1[0] = p0 | 0x05;
5626 switch (sub->
state) {
5628 sub->
temp_1[0] = p0 | 0x05;
5636 sub->
temp_1[0] = p0 | 0x06;
5643 sub->
temp_1[0] = p0 | 0x07;
5652 }
else if (
b >= 0x80) {
5654 if ((
b >= 0xc0) && (
b <= 0xdf)) {
5660 switch (sub->
state) {
5662 if (sub->
temp_1[1] < 0xf0) {
5663 p0 |= sub->
temp_1[1] >> 4;
5678 if (sub->
temp_1[1] < 0xf0) {
5679 p0 |= sub->
temp_1[1] >> 4;
5698 sub->
temp_1[0] = p0 | 0x04;
5719 uint8_t start_cable;
5738 start_cable =
chan->curr_cable;
5745 sub = &
chan->sub[
chan->curr_cable];
5749 &
buf, 1, &actlen, 0);
5758 (
unsigned int)
chan->curr_cable);
5761 DPRINTF(
"sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5777 if (
chan->curr_cable >=
chan->max_emb_jack)
5778 chan->curr_cable = 0;
5780 if (
chan->curr_cable == start_cable) {
5788 DPRINTF(
"Transferring %d frames\n", (
int)nframes);
5815 sub = &
chan->sub[
n];
5822 panic(
"%s:%d cannot find usb_fifo!\n",
5823 __FILE__, __LINE__);
5846 if (--(
chan->read_open_refcount) == 0) {
5851 DPRINTF(
"(stopping read transfer)\n");
5866 }
while (actlen > 0);
5882 if (--(
chan->write_open_refcount) == 0) {
5883 DPRINTF(
"(stopping write transfer)\n");
5894 if (fflags & FREAD) {
5898 mtx_lock(&
chan->mtx);
5899 chan->read_open_refcount++;
5901 mtx_unlock(&
chan->mtx);
5903 if (fflags & FWRITE) {
5908 mtx_lock(&
chan->mtx);
5909 chan->write_open_refcount++;
5914 mtx_unlock(&
chan->mtx);
5922 if (fflags & FREAD) {
5925 if (fflags & FWRITE) {
5943 mtx_init(&
chan->mtx,
"umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5954 .basename[0] =
"umidi",
5964 int unit = device_get_unit(
dev);
5969 chan->single_command = 1;
5972 chan->iface_index,
chan->iface_alt_index);
5974 DPRINTF(
"setting of alternate index failed: %s\n",
5990 DPRINTF(
"no BULK or INTERRUPT MIDI endpoint(s) found\n");
6008 chan->single_command = 1;
6010 if (
chan->single_command != 0)
6011 device_printf(
dev,
"Single command MIDI quirk enabled\n");
6013 if ((
chan->max_emb_jack == 0) ||
6018 for (
n = 0;
n <
chan->max_emb_jack;
n++) {
6019 sub = &
chan->sub[
n];
6024 UID_ROOT, GID_OPERATOR, 0666);
6030 mtx_lock(&
chan->mtx);
6040 mtx_unlock(&
chan->mtx);
6058 mtx_lock(&
chan->mtx);
6062 mtx_unlock(&
chan->mtx);
6066 mtx_destroy(&
chan->mtx);
6084 DPRINTF(
"actlen=%d\n", actlen);
6099 hid_get_data(
buffer, actlen,
6108 hid_get_data(
buffer, actlen,
6117 hid_get_data(
buffer, actlen,
6165 DPRINTF(
"error reading report description\n");
6170 hid_report_size_max(d_ptr, d_len, hid_input, &
id);
6175 if (hid_locate(d_ptr, d_len,
6176 HID_USAGE2(HUP_CONSUMER, 0xE9 ),
6179 if (flags & HIO_VARIABLE)
6181 DPRINTFN(1,
"Found Volume Up key\n");
6184 if (hid_locate(d_ptr, d_len,
6185 HID_USAGE2(HUP_CONSUMER, 0xEA ),
6188 if (flags & HIO_VARIABLE)
6190 DPRINTFN(1,
"Found Volume Down key\n");
6193 if (hid_locate(d_ptr, d_len,
6194 HID_USAGE2(HUP_CONSUMER, 0xE2 ),
6197 if (flags & HIO_VARIABLE)
6199 DPRINTFN(1,
"Found Mute key\n");
6202 free(d_ptr, M_TEMP);
6207 DPRINTFN(1,
"Did not find any volume related keys\n");
int sndbuf_setup(struct snd_dbuf *b, void *buf, unsigned int size)
void chn_intr(struct pcm_channel *c)
struct pcmchan_matrix * m
uint32_t feeder_matrix_default_format(uint32_t)
struct pcmchan_matrix * feeder_matrix_format_map(uint32_t)
#define MUTE_CONTROL(xxx, yyy)
#define SND_CHN_T_MASK_BC
#define SND_CHN_T_MASK_FL
#define SND_CHN_T_MASK_BL
#define SND_CHN_T_MASK_LF
#define SND_CHN_T_MASK_BR
#define SND_CHN_T_MASK_FR
#define SND_CHN_T_MASK_SL
#define SND_CHN_T_MASK_FC
#define SND_CHN_T_MASK_SR
#define SND_CHN_MATRIX_DRV
void mix_setparentchild(struct snd_mixer *m, u_int32_t parent, u_int32_t childs)
void mix_setrealdev(struct snd_mixer *m, u_int32_t dev, u_int32_t realdev)
device_t mix_get_dev(struct snd_mixer *m)
struct mtx * mixer_get_lock(struct snd_mixer *m)
void mixer_hwvol_step_locked(struct snd_mixer *m, int left_step, int right_step)
int mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
int mixer_uninit(device_t dev)
int mixer_hwvol_init(device_t dev)
void mix_setdevs(struct snd_mixer *m, u_int32_t v)
void mixer_hwvol_mute_locked(struct snd_mixer *m)
void mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
Record mask of available recording devices.
void pcm_setflags(device_t dev, uint32_t val)
uint32_t pcm_getflags(device_t dev)
int pcm_setstatus(device_t dev, char *str)
int pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
int pcm_unregister(device_t dev)
int pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
#define SND_FORMAT(f, c, e)
const usb_endpoint_descriptor_audio_t * p_ed1
union uaudio_asf1d p_asf1d
const struct uaudio_format * p_fmt
const struct usb_config * usb_cfg
uint16_t bytes_per_frame[2]
uint32_t frames_per_second
struct pcmchan_caps pcm_cap
struct uaudio_chan_alt usb_alt[CHAN_MAX_ALT]
struct snd_dbuf * pcm_buf
struct uaudio_softc * priv_sc
struct usb_xfer * xfer[UAUDIO_NCHANBUFS+1]
struct pcm_channel * pcm_ch
struct hid_location volume_down_loc
struct hid_location volume_up_loc
struct hid_location mute_loc
struct usb_xfer * xfer[UAUDIO_HID_N_TRANSFER]
struct uaudio_mixer_node * next
uint8_t update[(MIX_MAX_CHAN+7)/8]
int32_t wValue[MIX_MAX_CHAN]
uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN]
uint8_t bit_input[(256+7)/8]
uint8_t bit_output[(256+7)/8]
struct snd_mixer * mixer_dev
struct umidi_chan sc_midi_chan
struct sndcard_func sc_sndcard_func
uint8_t sc_uq_au_vendor_class
uint8_t sc_pcm_bitperfect
struct uaudio_softc_child sc_child[UAUDIO_MAX_CHILD]
struct uaudio_mixer_node * sc_mixer_curr
struct uaudio_chan sc_play_chan[UAUDIO_MAX_CHILD]
uint8_t sc_mixer_iface_index
struct uaudio_search_result sc_mixer_clocks
struct uaudio_mixer_node * sc_mixer_root
int(* sc_set_spdif_fn)(struct uaudio_softc *, int)
struct uaudio_configure_msg sc_config_msg[2]
struct uaudio_chan sc_rec_chan[UAUDIO_MAX_CHILD]
uint8_t sc_uq_au_inp_async
uint8_t sc_mixer_iface_no
uint8_t sc_uq_audio_swap_lr
struct usb_device * sc_udev
struct usb_xfer * sc_mixer_xfer[1]
struct uaudio_mixer_node sc_mixer_node
const struct usb_audio_selector_unit * su_v1
const struct usb_audio20_input_terminal * it_v2
const struct usb_audio_feature_unit * fu_v1
struct uaudio_terminal_node * root
const struct usb_audio_processing_unit_0 * pu_v1
const struct usb_audio20_extension_unit_0 * eu_v2
const struct usb_audio20_clock_multiplier_unit * cmul_v2
const struct usb_audio20_clock_selector_unit_0 * csel_v2
struct uaudio_search_result usr
const struct usb_audio20_feature_unit * fu_v2
const struct usb_audio_extension_unit_0 * eu_v1
const struct usb_audio20_processing_unit_0 * pu_v2
union uaudio_terminal_node::@55 u
const struct usb_audio20_output_terminal * ot_v2
const struct usb_audio20_clock_source_unit * csrc_v2
const struct usb_audio20_sample_rate_unit * ru_v2
const struct usb_audio_output_terminal * ot_v1
const struct usb_audio20_selector_unit * su_v2
const struct usb_audio20_effect_unit * ef_v2
const struct usb_audio_input_terminal * it_v1
const struct usb_descriptor * desc
const struct usb_audio20_mixer_unit_0 * mu_v2
const struct usb_audio_mixer_unit_0 * mu_v1
uint8_t write_open_refcount
struct usb_xfer * xfer[UMIDI_N_TRANSFER]
uint8_t read_open_refcount
struct umidi_sub_chan sub[UMIDI_EMB_JACK_MAX]
enum usb_hc_mode usb_mode
unsigned long driver_info
struct usbd_lookup_info info
struct usb_interface * iface
struct usb_device * device
usb_fifo_cmd_t * f_start_read
struct usb_interface_descriptor * idesc
usb_proc_callback_t * pm_callback
uint8_t bInterfaceSubClass
static void umidi_start_write(struct usb_fifo *)
static void uaudio_mixer_fill_info(struct uaudio_softc *, struct usb_device *, void *)
void * uaudio_chan_init(struct uaudio_chan *ch, struct snd_dbuf *b, struct pcm_channel *c, int dir)
static void uaudio_mixer_reload_all(struct uaudio_softc *)
static void uaudio_mixer_register_sysctl(struct uaudio_softc *, device_t, unsigned)
static const uint32_t uaudio_rate_list[CHAN_MAX_ALT]
int uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
static struct usb_audio_cluster uaudio_mixer_get_cluster(uint8_t, const struct uaudio_terminal_node *)
static bool uaudio_mixer_foreach_input(const struct uaudio_terminal_node *iot, uint8_t *pindex)
MODULE_VERSION(uaudio, 1)
static void uaudio_pcm_setflags(device_t dev, uint32_t flags)
static usb_proc_callback_t uaudio_configure_msg
static void uaudio_chan_fill_info_sub(struct uaudio_softc *, struct usb_device *, uint32_t, uint8_t, uint8_t)
static uint16_t uaudio_mixer_determine_class(const struct uaudio_terminal_node *)
SYSCTL_BOOL(_hw_usb_uaudio, OID_AUTO, handle_hid, CTLFLAG_RWTUN, &uaudio_handle_hid, 0, "uaudio handles any HID volume/mute keys, if set")
static void uaudio20_mixer_add_selector(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static uint32_t uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *, uint8_t)
int uaudio_detach_sub(device_t dev)
static void uaudio_chan_fill_info(struct uaudio_softc *, struct usb_device *)
static usb_error_t uaudio_force_power_save(struct uaudio_softc *sc, uint8_t iface_index)
static struct usb_fifo_methods umidi_fifo_methods
#define UMIDI_ST_2PARAM_2
static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0
static int uaudio_chan_need_both(struct uaudio_chan *pchan, struct uaudio_chan *rchan)
static const STRUCT_USB_HOST_ID uaudio_vendor_midi[]
int uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
static uint16_t uaudio_mixer_get_feature_by_tt(uint16_t terminal_type, uint16_t default_type)
static uint16_t uaudio20_mixer_determine_class(const struct uaudio_terminal_node *)
static void uaudio_mixer_ctl_free(struct uaudio_softc *)
MODULE_DEPEND(uaudio, usb, 1, 1, 1)
#define UAUDIO_SPDIF_OUT_96K
static struct umidi_sub_chan * umidi_sub_by_fifo(struct usb_fifo *)
static void uaudio_mixer_add_processing_updown(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static unsigned uaudio_get_child_index_by_chan(struct uaudio_softc *sc, struct uaudio_chan *ch)
static uint32_t uaudio_get_buffer_size(struct uaudio_chan *ch, uint8_t alt)
static int uaudio_set_spdif_cm6206(struct uaudio_softc *sc, int flags)
static const void * uaudio20_mixer_verify_desc(const void *, uint32_t)
struct pcmchan_caps * uaudio_chan_getcaps(struct uaudio_chan *ch)
void uaudio_mixer_set(struct uaudio_softc *sc, struct snd_mixer *m, unsigned type, unsigned left, unsigned right)
#define UAUDIO_RECURSE_LIMIT
#define UMIDI_ST_2PARAM_1
static void uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *, const uint8_t *, uint8_t, struct uaudio_search_result *)
static void umidi_start_read(struct usb_fifo *)
static device_detach_t uaudio_detach
#define UMIDI_EMB_JACK_MAX
void uaudio_chan_start(struct uaudio_chan *ch)
static usb_callback_t uaudio_chan_record_sync_callback
int uaudio_attach_sub(device_t dev, kobj_class_t mixer_class, kobj_class_t chan_class)
static void uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep, uint32_t xps, uint32_t add)
USB_PNP_HOST_INFO(uaudio_devs)
void uaudio_chan_stop(struct uaudio_chan *ch)
static void uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root, const uint8_t *p_id, uint8_t n_id, struct uaudio_search_result *info)
static void uaudio_mixer_init(struct uaudio_softc *, unsigned)
static driver_t uaudio_driver
static int uaudio_default_rate
static void uaudio_mixer_add_ctl(struct uaudio_softc *, struct uaudio_mixer_node *)
#define UAUDIO_CHANNELS_MAX
static int uaudio_mixer_get(struct usb_device *, uint16_t, uint8_t, struct uaudio_mixer_node *)
static int uaudio_set_spdif_dummy(struct uaudio_softc *sc, int flags)
DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY)
static void umidi_init(device_t dev)
static devclass_t uaudio_devclass
static int umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int)
static const struct usb_config umidi_config[UMIDI_N_TRANSFER]
#define UAUDIO_HID_HAS_VOLUME_DOWN
static int uaudio_default_bits
static struct uaudio_chan * uaudio_get_chan(struct uaudio_softc *sc, struct uaudio_chan *chan, uint8_t iface_index)
static const struct uaudio_format uaudio10_formats[]
static bool uaudio_handle_hid
static void uaudio_hid_detach(struct uaudio_softc *sc)
static int uaudio_default_channels
static void uaudio_mixer_merge_outputs(struct uaudio_search_result *dst, const struct uaudio_search_result *src)
int uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize, uint32_t blockcount)
static void uaudio_chan_reconfigure(struct uaudio_chan *ch, uint8_t operation)
static const struct uaudio_format uaudio20_formats[]
static void uaudio_mixer_add_ctl_sub(struct uaudio_softc *, struct uaudio_mixer_node *)
static const struct usb_config uaudio_cfg_play[UAUDIO_NCHANBUFS+1]
static device_method_t uaudio_methods[]
static usb_callback_t umidi_bulk_read_callback
static void uaudio20_mixer_add_mixer(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static void uaudio_mixer_add_mixer(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static usb_callback_t uaudio_mixer_write_cfg_callback
int uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
static int uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int val)
static void umidi_stop_read(struct usb_fifo *)
#define UAUDIO_MAX_CHAN(x)
#define UAUDIO_HID_HAS_ID
uint32_t uaudio_mixer_setrecsrc(struct uaudio_softc *sc, struct snd_mixer *m, uint32_t src)
int uaudio_mixer_uninit_sub(struct uaudio_softc *sc, struct snd_mixer *m)
static const STRUCT_USB_HOST_ID __used uaudio_devs[]
static void uaudio_mixer_check_selectors(struct uaudio_softc *sc)
static usb_callback_t uaudio_chan_record_callback
static usb_callback_t uaudio_hid_rx_callback
int uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
static void uaudio_configure_msg_sub(struct uaudio_softc *sc, struct uaudio_chan *chan, int dir)
SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RWTUN, &uaudio_default_rate, 0, "uaudio default sample rate")
static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW|CTLFLAG_MPSAFE, 0, "USB uaudio")
static void uaudio_mixer_add_processing(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static uint8_t umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t)
static int uaudio_mixer_signext(uint8_t, int)
static void uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc, uint8_t chan, int val)
#define UAUDIO_HID_HAS_MUTE
static int uaudio_chan_is_async(struct uaudio_chan *ch, uint8_t alt)
int uaudio_chan_getptr(struct uaudio_chan *ch)
#define UAUDIO_HID_HAS_VOLUME_UP
static const struct usb_config uaudio_cfg_record[UAUDIO_NCHANBUFS+1]
static usb_error_t uaudio20_check_rate(struct usb_device *udev, uint8_t iface_no, uint8_t clockid, uint32_t rate)
#define MAX_SELECTOR_INPUT_PIN
#define UAUDIO_SPDIF_IN_MIX
static const struct uaudio_tt_to_feature uaudio_tt_to_feature[]
struct pcmchan_matrix * uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
int uaudio_chan_free(struct uaudio_chan *ch)
static int umidi_open(struct usb_fifo *, int)
static void umidi_close(struct usb_fifo *, int)
static void uaudio_mixer_add_selector(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static bool uaudio_mixer_foreach_output(const struct uaudio_terminal_node *iot, uint8_t *pindex)
static const uint8_t umidi_cmd_to_len[16]
static void uaudio_mixer_controls_create_ftu(struct uaudio_softc *)
static void uaudio20_mixer_add_feature(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
#define UAUDIO_SPDIF_OUT_48K
static struct usb_audio20_cluster uaudio20_mixer_get_cluster(uint8_t, const struct uaudio_terminal_node *)
#define UAUDIO_MATRIX_MAX
static int umidi_detach(device_t dev)
static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t)
SYSCTL_PROC(_hw_usb_uaudio, OID_AUTO, buffer_ms, CTLTYPE_INT|CTLFLAG_RWTUN|CTLFLAG_MPSAFE, 0, sizeof(int), uaudio_buffer_ms_sysctl, "I", "uaudio buffering delay from 2ms to 8ms")
static const struct usb_config uaudio_hid_config[UAUDIO_HID_N_TRANSFER]
static int uaudio_buffer_ms_sysctl(SYSCTL_HANDLER_ARGS)
static int uaudio_chan_need_none(struct uaudio_chan *pchan, struct uaudio_chan *rchan)
static usb_error_t uaudio20_set_speed(struct usb_device *, uint8_t, uint8_t, uint32_t)
static void umidi_stop_write(struct usb_fifo *)
static void uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *, const uint8_t *, uint8_t, struct uaudio_search_result *)
static int umidi_probe(device_t dev)
static unsigned uaudio_get_child_index_by_dev(struct uaudio_softc *sc, device_t dev)
#define BIT_TEST(bm, bno)
#define UAUDIO20_MAX_RATES
static int uaudio_hid_probe(struct uaudio_softc *sc, struct usb_attach_arg *uaa)
static usb_callback_t uaudio_chan_play_callback
static const struct usb_config uaudio_mixer_config[1]
static usb_callback_t uaudio_chan_play_sync_callback
static usb_callback_t umidi_bulk_write_callback
static void uaudio_mixer_add_extension(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static const void * uaudio_mixer_verify_desc(const void *, uint32_t)
static int uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)
static int uaudio_buffer_ms
static void uaudio_mixer_add_feature(struct uaudio_softc *, const struct uaudio_terminal_node *, int)
static device_probe_t uaudio_probe
static device_attach_t uaudio_attach
#define INPUT_GAIN_PAD_CONTROL
#define SAMPLING_FREQ_CONTROL
#define UDESCSUB_AC_CLOCK_SRC
#define UDESCSUB_AC_SELECTOR
#define UDESCSUB_AC_HEADER
#define UATI_PERSONALMICROPHONE
#define UDESC_CS_ENDPOINT
#define UDESCSUB_AC_CLOCK_SEL
#define UDESCSUB_AC_SAMPLE_RT
#define REVERBATION_PROCESS
#define UA_SED_FREQ_CONTROL
#define UATI_PROCMICROPHONEARR
#define UDESCSUB_AC_OUTPUT
#define UDESCSUB_AC_PROCESSING
#define UD_MODE_SELECT_CONTROL
#define UDESCSUB_AC_INPUT
#define XX_ENABLE_CONTROL
#define UDESCSUB_AC_EFFECT
#define UEP_HAS_SYNCADDR(ep)
#define GRAPHIC_EQUALIZER_CONTROL
#define UDESCSUB_AC_PROCESSING_V2
#define UDESCSUB_AC_FEATURE
#define UA_PROC_ENABLE_MASK
#define INPUT_GAIN_CONTROL
#define UAUDIO_VERSION_30
#define UEP_HAS_REFRESH(ep)
#define P3D_STEREO_EXTENDER_PROCESS
#define UPDOWNMIX_PROCESS
#define UDESCSUB_AC_MIXER
#define UATE_DIGITALAUIFC
#define UA20_CS_SAM_FREQ_CONTROL
#define UDESCSUB_AC_EXTENSION
#define UATI_DESKMICROPHONE
#define UDESCSUB_AC_EXTENSION_V2
#define UATF_TVTUNERAUDIO
#define DOLBY_PROLOGIC_PROCESS
#define BASS_BOOST_CONTROL
#define UA_EXT_ENABLE_MASK
#define UATF_VIDEODISCAUDIO
#define UAUDIO_VERSION_20
#define UATI_MICROPHONEARRAY
#define UDESC_CS_INTERFACE
#define UDESCSUB_AC_CLOCK_MUL
#define DYN_RANGE_COMP_PROCESS
#define UATI_OMNIMICROPHONE
const struct usb_audio20_streaming_type1_descriptor * v2
const struct usb_audio_streaming_type1_descriptor * v1
const struct usb_audio_streaming_interface_descriptor * v1
const struct usb_audio20_streaming_interface_descriptor * v2
const struct usb_audio_streaming_endpoint_descriptor * v1
const struct usb_audio20_streaming_endpoint_descriptor * v2
#define UE_GET_ISO_TYPE(a)
#define UISUBCLASS_MIDISTREAM
#define UT_READ_CLASS_INTERFACE
#define UE_GET_XFERTYPE(a)
#define UISUBCLASS_AUDIOSTREAM
#define UISUBCLASS_AUDIOCONTROL
#define UT_WRITE_CLASS_INTERFACE
#define UT_WRITE_CLASS_ENDPOINT
void usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len)
void usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len)
void * usb_proc_explore_msignal(struct usb_device *udev, void *pm1, void *pm2)
void usb_proc_explore_mwait(struct usb_device *udev, void *pm1, void *pm2)
void usb_proc_explore_unlock(struct usb_device *udev)
void usb_proc_explore_lock(struct usb_device *udev)
usb_error_t usbd_set_alt_interface_index(struct usb_device *udev, uint8_t iface_index, uint8_t alt_index)
struct usb_interface_descriptor * usbd_get_interface_descriptor(struct usb_interface *iface)
struct usb_config_descriptor * usbd_get_config_descriptor(struct usb_device *udev)
void usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index, uint8_t parent_index)
enum usb_dev_speed usbd_get_speed(struct usb_device *udev)
uint32_t usbd_get_isoc_fps(struct usb_device *udev)
struct usb_interface * usbd_get_iface(struct usb_device *udev, uint8_t iface_index)
#define USETW2(w, b1, b0)
const char * usbd_errstr(usb_error_t err)
usb_error_t usbd_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, void **descp, uint16_t *sizep, struct malloc_type *mem, uint8_t iface_index)
int usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, struct usb_attach_arg *uaa)
struct usb_descriptor * usb_desc_foreach(struct usb_config_descriptor *cd, struct usb_descriptor *_desc)
uint8_t usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk)
usb_error_t usbd_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint8_t alt_no)
usb_error_t usbd_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf, uint16_t len, uint8_t string_index)
usb_error_t usbd_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16_t len, uint8_t iface_index, uint8_t type, uint8_t id)
usb_error_t usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx, struct usb_device_request *req, void *data, uint16_t flags, uint16_t *actlen, usb_timeout_t timeout)
void usbd_transfer_submit(struct usb_xfer *xfer)
void usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n)
void usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
void usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex, usb_frlength_t len)
uint8_t usbd_xfer_get_fps_shift(struct usb_xfer *xfer)
usb_frlength_t usbd_xfer_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex)
usb_frlength_t usbd_xfer_max_framelen(struct usb_xfer *xfer)
void * usbd_xfer_get_frame_buffer(struct usb_xfer *xfer, usb_frcount_t frindex)
struct usb_page_cache * usbd_xfer_get_frame(struct usb_xfer *xfer, usb_frcount_t frindex)
uint8_t usbd_xfer_maxp_was_clamped(struct usb_xfer *xfer)
usb_error_t usbd_transfer_setup(struct usb_device *udev, const uint8_t *ifaces, struct usb_xfer **ppxfer, const struct usb_config *setup_start, uint16_t n_setup, void *priv_sc, struct mtx *xfer_mtx)
void usbd_transfer_start(struct usb_xfer *xfer)
void * usbd_xfer_softc(struct usb_xfer *xfer)
void usbd_xfer_set_stall(struct usb_xfer *xfer)
void usbd_transfer_stop(struct usb_xfer *xfer)
void usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen, int *aframes, int *nframes)
usb_frlength_t usbd_xfer_max_len(struct usb_xfer *xfer)
void device_set_usb_desc(device_t dev)
void usb_pause_mtx(struct mtx *mtx, int timo)
int usb_fifo_alloc_buffer(struct usb_fifo *f, uint32_t bufsize, uint16_t nbuf)
#define USB_DEFAULT_TIMEOUT
#define USB_IFACE_SUBCLASS(isc)
void * usb_fifo_softc(struct usb_fifo *fifo)
void() usb_proc_callback_t(struct usb_proc_msg *)
void usb_fifo_detach(struct usb_fifo_sc *f_sc)
void usb_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr, usb_size_t len, uint8_t what)
int usb_fifo_attach(struct usb_device *udev, void *priv_sc, struct mtx *priv_mtx, struct usb_fifo_methods *pm, struct usb_fifo_sc *f_sc, uint16_t unit, int16_t subunit, uint8_t iface_index, uid_t uid, gid_t gid, int mode)
void usb_fifo_free_buffer(struct usb_fifo *f)
#define USB_IFACE_CLASS(ic)
#define USB_SHORT_XFER_OK
#define USB_ST_TRANSFERRED
uint8_t usb_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr, usb_size_t len, usb_size_t *actlen, uint8_t what)
void() usb_callback_t(struct usb_xfer *, usb_error_t)
#define USB_VPI(vend, prod, info)
#define STRUCT_USB_HOST_ID
#define USB_GET_STATE(xfer)
#define usbd_do_request(u, m, r, d)
#define UHID_OUTPUT_REPORT