Lines Matching +full:pcm +full:- +full:interface +full:- +full:rate
3 /*-
4 * SPDX-License-Identifier: BSD-2-Clause
90 #include <dev/sound/pcm/sound.h>
95 static int uaudio_default_rate = 0; /* use rate list */
106 &uaudio_default_rate, 0, "uaudio default sample rate");
123 if (err != 0 || req->newptr == NULL || val == uaudio_buffer_ms)
149 #define UAUDIO_NFRAMES 64 /* must be factor of 8 due HS-USB */
157 #define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1)
159 #define MIX(sc) ((sc)->sc_mixer_node)
352 #define UAUDIO_SPDIF_OUT_48K 0x02 /* Out sample rate = 48K */
353 #define UAUDIO_SPDIF_OUT_96K 0x04 /* Out sample rate = 96K */
436 {UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
437 {UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
438 {UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
439 {UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
441 {UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
442 {UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
443 {UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
444 {UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
446 {UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
447 {UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
452 {UA20_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
453 {UA20_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
454 {UA20_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
455 {UA20_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
457 {UA20_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
458 {UA20_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
459 {UA20_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
460 {UA20_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
462 {UA20_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
463 {UA20_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
718 /* The following table is derived from Linux's quirks-table.h */
731 { USB_VPI(USB_VENDOR_YAMAHA, 0x100c, 0) }, /* UC-MX */
732 { USB_VPI(USB_VENDOR_YAMAHA, 0x100d, 0) }, /* UC-KX */
734 { USB_VPI(USB_VENDOR_YAMAHA, 0x100f, 0) }, /* CLP-150 */
735 { USB_VPI(USB_VENDOR_YAMAHA, 0x1010, 0) }, /* CLP-170 */
736 { USB_VPI(USB_VENDOR_YAMAHA, 0x1011, 0) }, /* P-250 */
738 { USB_VPI(USB_VENDOR_YAMAHA, 0x1013, 0) }, /* PF-500 */
740 { USB_VPI(USB_VENDOR_YAMAHA, 0x1015, 0) }, /* MOTIF-R */
741 { USB_VPI(USB_VENDOR_YAMAHA, 0x1016, 0) }, /* MDP-5 */
742 { USB_VPI(USB_VENDOR_YAMAHA, 0x1017, 0) }, /* CVP-204 */
743 { USB_VPI(USB_VENDOR_YAMAHA, 0x1018, 0) }, /* CVP-206 */
744 { USB_VPI(USB_VENDOR_YAMAHA, 0x1019, 0) }, /* CVP-208 */
745 { USB_VPI(USB_VENDOR_YAMAHA, 0x101a, 0) }, /* CVP-210 */
746 { USB_VPI(USB_VENDOR_YAMAHA, 0x101b, 0) }, /* PSR-1100 */
747 { USB_VPI(USB_VENDOR_YAMAHA, 0x101c, 0) }, /* PSR-2100 */
748 { USB_VPI(USB_VENDOR_YAMAHA, 0x101d, 0) }, /* CLP-175 */
749 { USB_VPI(USB_VENDOR_YAMAHA, 0x101e, 0) }, /* PSR-K1 */
750 { USB_VPI(USB_VENDOR_YAMAHA, 0x101f, 0) }, /* EZ-J24 */
751 { USB_VPI(USB_VENDOR_YAMAHA, 0x1020, 0) }, /* EZ-250i */
755 { USB_VPI(USB_VENDOR_YAMAHA, 0x1024, 0) }, /* CVP-301 */
756 { USB_VPI(USB_VENDOR_YAMAHA, 0x1025, 0) }, /* CVP-303 */
757 { USB_VPI(USB_VENDOR_YAMAHA, 0x1026, 0) }, /* CVP-305 */
758 { USB_VPI(USB_VENDOR_YAMAHA, 0x1027, 0) }, /* CVP-307 */
759 { USB_VPI(USB_VENDOR_YAMAHA, 0x1028, 0) }, /* CVP-309 */
760 { USB_VPI(USB_VENDOR_YAMAHA, 0x1029, 0) }, /* CVP-309GP */
761 { USB_VPI(USB_VENDOR_YAMAHA, 0x102a, 0) }, /* PSR-1500 */
762 { USB_VPI(USB_VENDOR_YAMAHA, 0x102b, 0) }, /* PSR-3000 */
763 { USB_VPI(USB_VENDOR_YAMAHA, 0x102e, 0) }, /* ELS-01/01C */
764 { USB_VPI(USB_VENDOR_YAMAHA, 0x1030, 0) }, /* PSR-295/293 */
765 { USB_VPI(USB_VENDOR_YAMAHA, 0x1031, 0) }, /* DGX-205/203 */
766 { USB_VPI(USB_VENDOR_YAMAHA, 0x1032, 0) }, /* DGX-305 */
767 { USB_VPI(USB_VENDOR_YAMAHA, 0x1033, 0) }, /* DGX-505 */
803 { USB_VPI(USB_VENDOR_YAMAHA, 0x2000, 0) }, /* DGP-7 */
804 { USB_VPI(USB_VENDOR_YAMAHA, 0x2001, 0) }, /* DGP-5 */
812 { USB_VPI(USB_VENDOR_YAMAHA, 0x5005, 0) }, /* ACU16-C */
813 { USB_VPI(USB_VENDOR_YAMAHA, 0x5006, 0) }, /* NHB32-C */
842 if (dev == sc->sc_child[i].pcm_device)
855 if ((sc->sc_play_chan + i) == ch ||
856 (sc->sc_rec_chan + i) == ch)
868 if (uaa->usb_mode != USB_MODE_HOST)
871 /* lookup non-standard device(s) */
878 if (uaa->info.bInterfaceClass != UICLASS_AUDIO) {
879 if (uaa->info.bInterfaceClass != UICLASS_VENDOR ||
884 /* check for AUDIO control interface */
886 if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) {
895 if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) {
929 if (usbd_req_set_report(sc->sc_udev, NULL,
931 sc->sc_mixer_iface_index, UHID_OUTPUT_REPORT, 0) != 0) {
950 iface = usbd_get_iface(sc->sc_udev, iface_index);
951 if (iface == NULL || iface->idesc == NULL)
955 if (iface->alt_index == 0) {
957 err = usbd_req_set_alt_interface_no(sc->sc_udev, NULL, iface_index,
958 iface->idesc->bAlternateSetting);
960 err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, 0);
974 sc->sc_udev = uaa->device;
975 sc->sc_mixer_iface_index = uaa->info.bIfaceIndex;
976 sc->sc_mixer_iface_no = uaa->info.bIfaceNum;
977 sc->sc_config_msg[0].hdr.pm_callback = &uaudio_configure_msg;
978 sc->sc_config_msg[0].sc = sc;
979 sc->sc_config_msg[1].hdr.pm_callback = &uaudio_configure_msg;
980 sc->sc_config_msg[1].sc = sc;
983 sc->sc_uq_audio_swap_lr = 1;
986 sc->sc_uq_au_inp_async = 1;
989 sc->sc_uq_au_no_xu = 1;
992 sc->sc_uq_bad_adc = 1;
995 sc->sc_uq_au_vendor_class = 1;
999 sc->sc_set_spdif_fn = uaudio_set_spdif_cm6206;
1001 sc->sc_set_spdif_fn = uaudio_set_spdif_dummy;
1007 id = usbd_get_interface_descriptor(uaa->iface);
1010 uaudio_mixer_fill_info(sc, uaa->device, id);
1013 uaudio_chan_fill_info(sc, uaa->device);
1016 sc->sc_audio_rev >> 8,
1017 sc->sc_audio_rev & 0xff);
1019 if (sc->sc_mixer_count == 0) {
1020 if (uaa->info.idVendor == USB_VENDOR_MAUDIO &&
1021 (uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA ||
1022 uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA8R)) {
1029 sc->sc_mixer_count);
1034 if (sc->sc_play_chan[i].num_alt <= 0)
1038 * Need to set a default alternate interface, else
1040 * re-enumeration loop:
1043 sc->sc_play_chan[i].usb_alt[0].iface_index);
1049 for (x = 0; x != sc->sc_play_chan[i].num_alt; x++) {
1052 sc->sc_play_chan[i].usb_alt[x].sample_rate,
1053 sc->sc_play_chan[i].usb_alt[x].channels,
1054 sc->sc_play_chan[i].usb_alt[x].p_fmt->description,
1065 if (sc->sc_rec_chan[i].num_alt <= 0)
1069 * Need to set a default alternate interface, else
1071 * re-enumeration loop:
1074 sc->sc_rec_chan[i].usb_alt[0].iface_index);
1080 for (x = 0; x != sc->sc_rec_chan[i].num_alt; x++) {
1083 sc->sc_rec_chan[i].usb_alt[x].sample_rate,
1084 sc->sc_rec_chan[i].usb_alt[x].channels,
1085 sc->sc_rec_chan[i].usb_alt[x].p_fmt->description,
1093 if (sc->sc_midi_chan.valid == 0) {
1096 sc->sc_midi_chan.iface_index =
1097 (uint8_t)uaa->driver_info;
1098 sc->sc_midi_chan.iface_alt_index = 0;
1099 sc->sc_midi_chan.valid = 1;
1103 if (sc->sc_midi_chan.valid) {
1116 sc->sc_sndcard_func.func = SCF_PCM;
1119 * Only attach a PCM device if we have a playback, recording
1123 if (sc->sc_play_chan[i].num_alt <= 0 &&
1124 sc->sc_rec_chan[i].num_alt <= 0 &&
1125 sc->sc_child[i].mix_info == 0)
1127 sc->sc_child[i].pcm_device =
1128 device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
1130 if (sc->sc_child[i].pcm_device == NULL) {
1134 device_set_ivars(sc->sc_child[i].pcm_device,
1135 &sc->sc_sndcard_func);
1152 if (sc->sc_set_spdif_fn(sc,
1178 if (sc->sc_uq_audio_swap_lr) {
1182 if (sc->sc_play_chan[i].num_alt > 0 &&
1183 (sc->sc_child[i].mix_info & SOUND_MASK_PCM) == 0) {
1187 * Emulate missing pcm mixer controller
1192 if (sc->sc_pcm_bitperfect) {
1198 sc->sc_child[i].mixer_init = 1;
1203 usb_get_manufacturer(sc->sc_udev),
1204 usb_get_product(sc->sc_udev));
1213 if (sc->sc_play_chan[i].num_alt > 0) {
1214 sc->sc_play_chan[i].priv_sc = sc;
1216 &sc->sc_play_chan[i]);
1219 if (sc->sc_rec_chan[i].num_alt > 0) {
1220 sc->sc_rec_chan[i].priv_sc = sc;
1222 &sc->sc_rec_chan[i]);
1226 sc->sc_child[i].pcm_registered = 1;
1232 "feedback_rate", CTLFLAG_RD, &sc->sc_play_chan[i].feedback_rate,
1233 0, "Feedback sample rate in Hz");
1249 if (sc->sc_child[i].pcm_registered) {
1251 } else if (sc->sc_child[i].mixer_init) {
1269 usb_proc_explore_lock(sc->sc_udev);
1271 sc->sc_play_chan[i].operation = CHAN_OP_DRAIN;
1272 sc->sc_rec_chan[i].operation = CHAN_OP_DRAIN;
1274 usb_proc_explore_mwait(sc->sc_udev,
1275 &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
1276 usb_proc_explore_unlock(sc->sc_udev);
1279 usbd_transfer_unsetup(sc->sc_play_chan[i].xfer, UAUDIO_NCHANBUFS + 1);
1280 usbd_transfer_unsetup(sc->sc_rec_chan[i].xfer, UAUDIO_NCHANBUFS + 1);
1296 (void) sc->sc_set_spdif_fn(sc, 0);
1305 /* Isochronous transfer interval is 2^(bInterval - 1) frames. */
1306 if (ed->bInterval >= 1 && ed->bInterval <= 16)
1307 frames = (1 << (ed->bInterval - 1));
1318 uint32_t fps = usbd_get_isoc_fps(sc->sc_udev);
1336 struct uaudio_chan_alt *chan_alt = &ch->usb_alt[alt];
1339 int_frames = uaudio_get_interval_frames(chan_alt->p_ed1);
1341 ms = uaudio_get_buffer_ms(ch->priv_sc, int_frames);
1342 buf_size = chan_alt->sample_size *
1343 howmany(chan_alt->sample_rate * ms, 1000);
1350 struct uaudio_chan_alt *chan_alt = &ch->usb_alt[alt];
1353 buf_size = chan_alt->sample_size *
1354 howmany(chan_alt->sample_rate * UAUDIO_BUFFER_MS_MAX, 1000);
1371 if (chan->num_alt <= 0)
1376 usb_proc_explore_lock(sc->sc_udev);
1377 operation = chan->operation;
1381 chan->operation = CHAN_OP_NONE;
1386 usb_proc_explore_unlock(sc->sc_udev);
1391 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1393 mtx_lock(chan->pcm_mtx);
1394 chan->cur_alt = CHAN_MAX_ALT;
1395 mtx_unlock(chan->pcm_mtx);
1402 err = usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, 0);
1411 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1418 mtx_lock(chan->pcm_mtx);
1419 next_alt = chan->set_alt;
1420 mtx_unlock(chan->pcm_mtx);
1422 chan_alt = chan->usb_alt + next_alt;
1424 err = usbd_set_alt_interface_index(sc->sc_udev,
1425 chan_alt->iface_index, chan_alt->iface_alt_index);
1433 * Only set the sample rate if the channel reports that it
1437 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
1439 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
1444 if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1449 if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1455 if (uaudio20_set_speed(sc->sc_udev,
1456 sc->sc_mixer_iface_no, x, chan_alt->sample_rate)) {
1461 DPRINTF("setting of sample rate failed! "
1465 } else if (chan_alt->p_sed.v1->bmAttributes & UA_SED_FREQ_CONTROL) {
1466 if (uaudio_set_speed(sc->sc_udev,
1467 chan_alt->p_ed1->bEndpointAddress, chan_alt->sample_rate)) {
1472 DPRINTF("setting of sample rate failed! "
1476 if (usbd_transfer_setup(sc->sc_udev, &chan_alt->iface_index, chan->xfer,
1477 chan_alt->usb_cfg, UAUDIO_NCHANBUFS + 1, chan, chan->pcm_mtx)) {
1482 fps = usbd_get_isoc_fps(sc->sc_udev);
1492 fps_shift = usbd_xfer_get_fps_shift(chan->xfer[0]);
1499 chan->bytes_per_frame[0] =
1500 ((chan_alt->sample_rate / fps) * chan_alt->sample_size);
1501 chan->bytes_per_frame[1] = howmany(chan_alt->sample_rate, fps) *
1502 chan_alt->sample_size;
1504 /* setup data rate dithering, if any */
1505 chan->frames_per_second = fps;
1506 chan->sample_rem = chan_alt->sample_rate % fps;
1507 chan->sample_curr = 0;
1510 buf_size = (chan->bytes_per_frame[1] * frames);
1512 if (buf_size > (chan->end - chan->start)) {
1517 chan->intr_frames = frames;
1519 DPRINTF("fps=%d sample_rem=%d\n", (int)fps, (int)chan->sample_rem);
1521 if (chan->intr_frames == 0) {
1530 mtx_lock(chan->pcm_mtx);
1531 chan->cur_alt = next_alt;
1532 usbd_transfer_start(chan->xfer[0]);
1533 usbd_transfer_start(chan->xfer[1]);
1534 mtx_unlock(chan->pcm_mtx);
1537 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1539 mtx_lock(chan->pcm_mtx);
1540 chan->cur_alt = CHAN_MAX_ALT;
1541 mtx_unlock(chan->pcm_mtx);
1547 struct uaudio_softc *sc = ((struct uaudio_configure_msg *)pm)->sc;
1550 usb_proc_explore_unlock(sc->sc_udev);
1552 uaudio_configure_msg_sub(sc, &sc->sc_play_chan[i], PCMDIR_PLAY);
1553 uaudio_configure_msg_sub(sc, &sc->sc_rec_chan[i], PCMDIR_REC);
1555 usb_proc_explore_lock(sc->sc_udev);
1559 * AS - Audio Stream - routines
1571 ed, ed->bLength, ed->bDescriptorType,
1572 ed->bEndpointAddress, ed->bmAttributes,
1573 UGETW(ed->wMaxPacketSize), ed->bInterval,
1574 UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0,
1575 UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0);
1582 * The following is a workaround for broken no-name USB audio devices
1595 mps = UGETW(ep->wMaxPacketSize);
1599 * sample rate indicates, we apply the workaround.
1612 USETW(ep->wMaxPacketSize, xps);
1622 uint8_t clockid, uint32_t rate)
1632 DPRINTFN(6, "ifaceno=%d clockid=%d rate=%u\n",
1633 iface_no, clockid, rate);
1640 * Assume there is at least one rate to begin with, else some
1654 rates = MIN(UAUDIO20_MAX_RATES, (255 - 2) / 12);
1664 DPRINTF("Need to read full rate descriptor\n");
1671 * Try to read full rate descriptor.
1686 actlen = (actlen - 2) / 12;
1711 if (rate >= min && rate <= max &&
1712 (((rate - min) % res) == 0)) {
1726 if (chan->num_alt == 0) {
1727 chan->iface_index = iface_index;
1729 } else if (chan->iface_index == iface_index)
1737 uint32_t rate, uint8_t channels, uint8_t bit_resolution)
1765 if ((desc->bDescriptorType == UDESC_INTERFACE) &&
1766 (desc->bLength >= sizeof(*id))) {
1769 if (id->bInterfaceNumber != lastidx) {
1770 lastidx = id->bInterfaceNumber;
1778 if ((!(sc->sc_hid.flags & UAUDIO_HID_VALID)) &&
1779 (id->bInterfaceClass == UICLASS_HID) &&
1780 (id->bInterfaceSubClass == 0) &&
1781 (id->bInterfaceProtocol == 0) &&
1784 DPRINTF("Found HID interface at %d\n",
1786 sc->sc_hid.flags |= UAUDIO_HID_VALID;
1787 sc->sc_hid.iface_index = curidx;
1791 ((id->bInterfaceClass == UICLASS_AUDIO) ||
1792 ((id->bInterfaceClass == UICLASS_VENDOR) &&
1793 (sc->sc_uq_au_vendor_class != 0)));
1796 (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) {
1803 (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) {
1809 if ((sc->sc_midi_chan.valid == 0) &&
1811 sc->sc_midi_chan.iface_index = curidx;
1812 sc->sc_midi_chan.iface_alt_index = alt_index;
1813 sc->sc_midi_chan.valid = 1;
1829 if (alt_index == 0 && curidx != sc->sc_mixer_iface_index &&
1830 (id->bInterfaceClass == UICLASS_AUDIO || audio_if != 0 ||
1832 usbd_set_parent_iface(sc->sc_udev, curidx,
1833 sc->sc_mixer_iface_index);
1840 (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1841 (desc->bDescriptorSubtype == UDESCSUB_AC_HEADER) &&
1842 (desc->bLength >= sizeof(*acdp))) {
1844 audio_rev = UGETW(acdp->bcdADC);
1850 if (msid->bLength >= sizeof(*msid) &&
1851 msid->bDescriptorType == UDESC_CS_ENDPOINT &&
1852 msid->bDescriptorSubtype == MS_GENERAL &&
1853 msid->bNumEmbMIDIJack > sc->sc_midi_chan.max_emb_jack) {
1854 sc->sc_midi_chan.max_emb_jack = msid->bNumEmbMIDIJack;
1859 * this is not an USB audio stream interface.
1864 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1865 (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1866 (desc->bDescriptorSubtype == AS_GENERAL) &&
1871 if (desc->bLength >= sizeof(*asid.v2)) {
1875 if (desc->bLength >= sizeof(*asid.v1)) {
1880 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1881 (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1882 (desc->bDescriptorSubtype == FORMAT_TYPE) &&
1887 if (desc->bLength >= sizeof(*asf1d.v2))
1890 if (desc->bLength >= sizeof(*asf1d.v1)) {
1893 if (asf1d.v1->bFormatType != FORMAT_TYPE_I) {
1895 asf1d.v1->bFormatType);
1899 if (desc->bLength < (sizeof(*asf1d.v1) +
1900 ((asf1d.v1->bSamFreqType == 0) ? 6 :
1901 (asf1d.v1->bSamFreqType * 3)))) {
1910 if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
1911 (desc->bLength >= UEP_MINSIZE) &&
1914 if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) {
1919 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1920 (desc->bDescriptorType == UDESC_CS_ENDPOINT) &&
1921 (desc->bDescriptorSubtype == AS_GENERAL) &&
1926 if (desc->bLength >= sizeof(*sed.v2))
1929 if (desc->bLength >= sizeof(*sed.v1))
1939 ep_dir = UE_GET_DIR(ed1->bEndpointAddress);
1948 dwFormat = UGETDW(asid.v2->bmFormats);
1949 bChannels = asid.v2->bNrChannels;
1950 bBitResolution = asf1d.v2->bSubslotSize * 8;
1959 p_fmt->wFormat != 0; p_fmt++) {
1960 if ((p_fmt->wFormat & dwFormat) &&
1961 (p_fmt->bPrecision == bBitResolution))
1965 if (p_fmt->wFormat == 0) {
1972 if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1977 if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1986 sc->sc_mixer_iface_no, x, rate)) {
1988 "rate, id=%d\n", x);
1995 wFormat = UGETW(asid.v1->wFormatTag);
1996 bChannels = UAUDIO_MAX_CHAN(asf1d.v1->bNrChannels);
1997 bBitResolution = asf1d.v1->bSubFrameSize * 8;
1999 if (asf1d.v1->bSamFreqType == 0) {
2000 DPRINTFN(16, "Sample rate: %d-%dHz\n",
2004 if ((rate >= UA_SAMP_LO(asf1d.v1)) &&
2005 (rate <= UA_SAMP_HI(asf1d.v1)))
2008 for (x = 0; x < asf1d.v1->bSamFreqType; x++) {
2009 DPRINTFN(16, "Sample rate = %dHz\n",
2012 if (rate == UA_GETSAMP(asf1d.v1, x))
2020 p_fmt->wFormat != 0; p_fmt++) {
2021 if ((p_fmt->wFormat == wFormat) &&
2022 (p_fmt->bPrecision == bBitResolution))
2025 if (p_fmt->wFormat == 0) {
2037 chan = uaudio_get_chan(sc, (ep_dir == UE_DIR_OUT) ? &sc->sc_play_chan[0] :
2038 &sc->sc_rec_chan[0], curidx);
2045 DPRINTF("Interface is not valid\n");
2048 if (chan->num_alt == CHAN_MAX_ALT) {
2052 chan->set_alt = 0;
2053 chan->cur_alt = CHAN_MAX_ALT;
2055 chan_alt = &chan->usb_alt[chan->num_alt++];
2060 DPRINTF("Sample rate = %dHz, channels = %d, "
2061 "bits = %d, format = %s, ep 0x%02x, chan %p\n", rate, channels,
2062 bit_resolution, p_fmt->description, ed1->bEndpointAddress, chan);
2064 chan_alt->sample_rate = rate;
2065 chan_alt->p_asf1d = asf1d;
2066 chan_alt->p_ed1 = ed1;
2067 chan_alt->p_fmt = p_fmt;
2068 chan_alt->p_sed = sed;
2069 chan_alt->iface_index = curidx;
2070 chan_alt->iface_alt_index = alt_index;
2073 chan_alt->usb_cfg = uaudio_cfg_record;
2075 chan_alt->usb_cfg = uaudio_cfg_play;
2077 chan_alt->sample_size = (UAUDIO_MAX_CHAN(channels) *
2078 p_fmt->bPrecision) / 8;
2079 chan_alt->channels = channels;
2084 chan_alt->sample_size * (rate / 1000),
2085 chan_alt->sample_size * (rate / 4000));
2090 format = chan_alt->p_fmt->freebsd_fmt;
2093 format = SND_FORMAT(format, chan_alt->channels, 0);
2095 switch (chan_alt->channels) {
2113 chan->num_alt--;
2116 if (chan->num_alt > 1) {
2118 if (chan->pcm_format[0] != format) {
2120 chan->num_alt--;
2123 /* ignore if duplicate sample rate entry */
2124 if (rate == chan->usb_alt[chan->num_alt - 2].sample_rate) {
2125 DPRINTF("Duplicate sample rate detected\n");
2126 chan->num_alt--;
2130 chan->pcm_cap.fmtlist = chan->pcm_format;
2131 chan->pcm_cap.fmtlist[0] = format;
2134 if (chan_alt->channels > UAUDIO_MATRIX_MAX)
2135 sc->sc_pcm_bitperfect = 1;
2137 if (rate < chan->pcm_cap.minspeed || chan->pcm_cap.minspeed == 0)
2138 chan->pcm_cap.minspeed = rate;
2139 if (rate > chan->pcm_cap.maxspeed || chan->pcm_cap.maxspeed == 0)
2140 chan->pcm_cap.maxspeed = rate;
2177 uint32_t rate = uaudio_default_rate;
2185 bits -= (bits % 8);
2198 * with HIGH-speed split transactions we
2199 * disable surround setups on FULL-speed USB
2216 for (x = channels; x; x--) {
2217 for (y = bits; y; y -= 8) {
2218 /* try user defined rate, if any */
2219 if (rate != 0)
2220 uaudio_chan_fill_info_sub(sc, udev, rate, x, y);
2222 /* try find a matching rate, if any */
2224 if (uaudio_rate_list[z] != rate)
2234 y -= 8;
2242 x--;
2261 i = uaudio_get_child_index_by_chan(ch->priv_sc, ch);
2285 /* auto-detect SYNC format */
2297 sample_rate = ch->usb_alt[ch->cur_alt].sample_rate;
2300 while (temp < (sample_rate - (sample_rate / 4)))
2313 if (ch->priv_sc->sc_rec_chan[i].num_alt == 0) {
2318 * bogus sample rate adjustments. The expected
2324 ch->jitter_curr = temp - sample_rate;
2325 if (ch->jitter_curr > jitter_max)
2326 ch->jitter_curr = jitter_max;
2327 else if (ch->jitter_curr < -jitter_max)
2328 ch->jitter_curr = -jitter_max;
2330 ch->feedback_rate = temp;
2339 if (ch->priv_sc->sc_rec_chan[i].num_alt != 0 &&
2355 uint8_t attr = ch->usb_alt[alt].p_ed1->bmAttributes;
2375 if (ch->running == 0 || ch->start == ch->end) {
2380 i = uaudio_get_child_index_by_chan(ch->priv_sc, ch);
2383 ch_rec = ch->priv_sc->sc_rec_chan + i;
2385 if (ch_rec->num_alt == 0)
2402 ch_rec->jitter_curr = 0;
2403 ch_rec->jitter_rem = 0;
2407 ch->jitter_curr = 0;
2408 ch->jitter_rem = 0;
2416 chn_intr(ch->pcm_ch);
2423 uaudio_chan_is_async(ch, ch->cur_alt) != 0) {
2424 uint32_t rec_alt = ch_rec->cur_alt;
2425 if (rec_alt < ch_rec->num_alt) {
2437 tx_jitter = ch->usb_alt[ch->cur_alt].sample_rate;
2438 tx_jitter = (tx_jitter * ch_rec->jitter_curr) +
2439 ch->jitter_rem;
2442 ch_rec->jitter_curr = 0;
2443 ch_rec->jitter_rem = 0;
2446 rx_rate = ch_rec->usb_alt[rec_alt].sample_rate;
2447 ch->jitter_curr += tx_jitter / rx_rate;
2448 ch->jitter_rem = tx_jitter % rx_rate;
2453 ch->intr_counter += ch->intr_frames;
2454 if (ch->intr_counter >= ch->frames_per_second) {
2455 ch->intr_counter -= ch->frames_per_second;
2456 usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]);
2461 if (ch->bytes_per_frame[1] > mfl) {
2464 ch->bytes_per_frame[1],
2469 blockcount = ch->intr_frames;
2475 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2484 ch->sample_curr += ch->sample_rem;
2485 if (ch->sample_curr >= ch->frames_per_second) {
2486 ch->sample_curr -= ch->frames_per_second;
2487 frame_len = ch->bytes_per_frame[1];
2489 frame_len = ch->bytes_per_frame[0];
2493 if (ch->jitter_curr > 0 &&
2496 ch->jitter_curr--;
2498 } else if (ch->jitter_curr < 0 &&
2501 ch->jitter_curr++;
2502 frame_len -= sample_size;
2514 n = (ch->end - ch->cur);
2518 usbd_copy_in(pc, offset, ch->cur, n);
2520 total -= n;
2521 ch->cur += n;
2524 if (ch->cur >= ch->end)
2525 ch->cur = ch->start;
2558 if (ch->start == ch->end) {
2573 ch->sample_curr += (ch->sample_rem * ch->intr_frames);
2576 expected_bytes = (ch->intr_frames * ch->bytes_per_frame[0]) +
2577 ((ch->sample_curr / ch->frames_per_second) *
2578 (ch->bytes_per_frame[1] - ch->bytes_per_frame[0]));
2581 ch->sample_curr %= ch->frames_per_second;
2584 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2592 len = len - (len % sample_size);
2595 expected_bytes -= len;
2598 if (ch->running == 0 || ch->cur_alt != ch->set_alt)
2603 m = (ch->end - ch->cur);
2608 usbd_copy_out(pc, offset1, ch->cur, m);
2610 len -= m;
2612 ch->cur += m;
2614 if (ch->cur >= ch->end)
2615 ch->cur = ch->start;
2622 ch->jitter_curr -= (expected_bytes / sample_size);
2625 nframes = 2 * ch->intr_frames;
2628 if (ch->jitter_curr < -nframes)
2629 ch->jitter_curr = -nframes;
2630 else if (ch->jitter_curr > nframes)
2631 ch->jitter_curr = nframes;
2634 actlen, ch->jitter_curr);
2636 if (ch->running != 0)
2637 chn_intr(ch->pcm_ch);
2641 nframes = ch->intr_frames;
2664 /* store mutex and PCM channel */
2666 ch->pcm_ch = c;
2667 ch->pcm_mtx = c->lock;
2672 for (x = 0; x != ch->num_alt; x++) {
2683 ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2684 if (sndbuf_setup(b, ch->buf, buf_size) != 0)
2687 ch->start = ch->buf;
2688 ch->end = ch->buf + buf_size;
2689 ch->cur = ch->buf;
2690 ch->pcm_buf = b;
2691 ch->max_buf = buf_size;
2693 if (ch->pcm_mtx == NULL) {
2694 DPRINTF("ERROR: PCM channels does not have a mutex!\n");
2707 if (ch->buf != NULL) {
2708 free(ch->buf, M_DEVBUF);
2709 ch->buf = NULL;
2711 usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1);
2713 ch->num_alt = 0;
2721 uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2722 sndbuf_setup(ch->pcm_buf, ch->buf, temp);
2739 sc = ch->priv_sc;
2741 for (x = 0, y = 1; y < ch->num_alt; y++) {
2742 /* prefer sample rate closer to and greater than requested */
2743 if ((ch->usb_alt[x].sample_rate < speed &&
2744 ch->usb_alt[x].sample_rate < ch->usb_alt[y].sample_rate) ||
2745 (speed <= ch->usb_alt[y].sample_rate &&
2746 ch->usb_alt[y].sample_rate < ch->usb_alt[x].sample_rate))
2750 usb_proc_explore_lock(sc->sc_udev);
2751 ch->set_alt = x;
2752 usb_proc_explore_unlock(sc->sc_udev);
2756 return (ch->usb_alt[x].sample_rate);
2762 return (ch->cur - ch->start);
2768 return (&ch->pcm_cap);
2798 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1,
2799 -1, -1, -1, -1, -1, -1, -1, -1, -1 }
2807 sc = ch->priv_sc;
2809 if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
2826 struct uaudio_softc *sc = ch->priv_sc;
2829 if (ch->operation == CHAN_OP_DRAIN)
2833 ch->operation = operation;
2840 (void)usb_proc_explore_msignal(sc->sc_udev,
2841 &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2847 return (pchan->num_alt > 0 &&
2848 pchan->running != 0 &&
2849 uaudio_chan_is_async(pchan, pchan->set_alt) != 0 &&
2850 rchan->num_alt > 0 &&
2851 rchan->running == 0);
2857 return (pchan->num_alt > 0 &&
2858 pchan->running == 0 &&
2859 rchan->num_alt > 0 &&
2860 rchan->running == 0);
2866 struct uaudio_softc *sc = ch->priv_sc;
2870 usb_proc_explore_lock(sc->sc_udev);
2873 if (ch->running == 0) {
2877 temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2880 ch->running = 1;
2883 ch->start = ch->buf;
2884 ch->end = ch->buf + temp;
2885 ch->cur = ch->buf;
2888 &sc->sc_play_chan[i],
2889 &sc->sc_rec_chan[i])) {
2894 uaudio_chan_reconfigure(&sc->sc_rec_chan[i], CHAN_OP_START);
2895 uaudio_chan_reconfigure(&sc->sc_play_chan[i], CHAN_OP_START);
2902 usb_proc_explore_unlock(sc->sc_udev);
2908 struct uaudio_softc *sc = ch->priv_sc;
2912 usb_proc_explore_lock(sc->sc_udev);
2915 if (ch->running != 0) {
2917 ch->running = 0;
2920 &sc->sc_play_chan[i],
2921 &sc->sc_rec_chan[i])) {
2927 &sc->sc_play_chan[i],
2928 &sc->sc_rec_chan[i])) {
2933 uaudio_chan_reconfigure(&sc->sc_rec_chan[i], CHAN_OP_STOP);
2934 uaudio_chan_reconfigure(&sc->sc_play_chan[i], CHAN_OP_STOP);
2941 usb_proc_explore_unlock(sc->sc_udev);
2945 * AC - Audio Controller - routines
2958 sc = (struct uaudio_softc *)oidp->oid_arg1;
2959 hint = oidp->oid_arg2;
2961 if (sc->sc_child[0].mixer_lock == NULL)
2966 mtx_lock(sc->sc_child[0].mixer_lock);
2967 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2968 for (chan = 0; chan != (int)pmc->nchan; chan++) {
2969 if (pmc->wValue[chan] != -1 &&
2970 pmc->wValue[chan] == hint) {
2971 temp = pmc->wData[chan];
2977 mtx_unlock(sc->sc_child[0].mixer_lock);
2980 if (error != 0 || req->newptr == NULL)
2985 mtx_lock(sc->sc_child[0].mixer_lock);
2987 temp >= pmc->minval &&
2988 temp <= pmc->maxval) {
2989 pmc->wData[chan] = temp;
2990 pmc->update[(chan / 8)] |= (1 << (chan % 8));
2993 usbd_transfer_start(sc->sc_mixer_xfer[0]);
2995 mtx_unlock(sc->sc_child[0].mixer_lock);
3005 while ((p_mc = sc->sc_mixer_root) != NULL) {
3006 sc->sc_mixer_root = p_mc->next;
3032 for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL;
3033 pmc = pmc->next, n++) {
3034 for (chan = 0; chan < pmc->nchan; chan++) {
3035 if (pmc->nchan > 1) {
3037 pmc->name, n, chan);
3040 pmc->name, n);
3055 sc, pmc->wValue[chan],
3060 OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
3065 OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
3070 OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
3076 /* M-Audio FastTrack Ultra Mixer Description */
3085 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3099 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3111 "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
3123 "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
3130 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3146 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3162 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3178 MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
3193 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3226 if (sc->sc_child[0].mixer_lock == NULL)
3229 mtx_lock(sc->sc_child[0].mixer_lock);
3230 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
3231 /* use reset defaults for non-oss controlled settings */
3232 if (pmc->ctl == SOUND_MIXER_NRDEVICES)
3234 for (chan = 0; chan < pmc->nchan; chan++)
3235 pmc->update[chan / 8] |= (1 << (chan % 8));
3237 usbd_transfer_start(sc->sc_mixer_xfer[0]);
3240 usbd_transfer_start(sc->sc_hid.xfer[0]);
3241 mtx_unlock(sc->sc_child[0].mixer_lock);
3252 p_mc_new->next = sc->sc_mixer_root;
3253 sc->sc_mixer_root = p_mc_new;
3254 sc->sc_mixer_count++;
3257 for (ch = 0; ch < p_mc_new->nchan; ch++) {
3258 switch (p_mc_new->val_default) {
3261 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
3265 p_mc_new->wData[ch] = p_mc_new->maxval;
3269 p_mc_new->wData[ch] = p_mc_new->minval;
3280 DPRINTF("adding %d\n", mc->ctl);
3282 if (mc->type == MIX_ON_OFF) {
3283 mc->minval = 0;
3284 mc->maxval = 1;
3285 } else if (mc->type == MIX_SELECTOR) {
3289 mc->minval = uaudio_mixer_get(sc->sc_udev,
3290 sc->sc_audio_rev, GET_MIN, mc);
3291 mc->maxval = uaudio_mixer_get(sc->sc_udev,
3292 sc->sc_audio_rev, GET_MAX, mc);
3296 if (mc->maxval < mc->minval) {
3297 res = mc->maxval;
3298 mc->maxval = mc->minval;
3299 mc->minval = res;
3303 mc->mul = mc->maxval - mc->minval;
3304 if (mc->mul == 0)
3305 mc->mul = 1;
3308 res = uaudio_mixer_get(sc->sc_udev,
3309 sc->sc_audio_rev, GET_RES, mc);
3320 for (i = 0; i < mc->nchan; i++) {
3321 DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
3325 mc->wIndex, mc->type, mc->ctl,
3326 mc->minval, mc->maxval);
3350 d0->bUnitId, d0->bNrInPins);
3355 for (i = 0; i < d0->bNrInPins; i++) {
3357 d0->baSourceId[i], iot).bNrChannels;
3360 d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3364 ochs = d1->bNrChannels;
3370 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3376 for (p = i = 0; i < d0->bNrInPins; i++) {
3378 d0->baSourceId[i], iot).bNrChannels;
3384 if (BIT_TEST(d1->bmControls, bno))
3391 /* repeat bit-scan */
3397 if (BIT_TEST(d1->bmControls, bno))
3427 d0->bUnitId, d0->bNrInPins);
3432 for (i = 0; i < d0->bNrInPins; i++) {
3434 d0->baSourceId[i], iot).bNrChannels;
3437 d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3441 ochs = d1->bNrChannels;
3447 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3453 for (p = i = 0; i < d0->bNrInPins; i++) {
3455 d0->baSourceId[i], iot).bNrChannels;
3461 if (BIT_TEST(d1->bmControls, bno))
3468 /* repeat bit-scan */
3474 if (BIT_TEST(d1->bmControls, bno))
3545 d->bUnitId, d->bNrInPins);
3547 if (d->bNrInPins == 0)
3552 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3558 MIX(sc).maxval = d->bNrInPins;
3561 i = d->baSourceId[d->bNrInPins];
3563 usbd_req_get_string_any(sc->sc_udev, NULL,
3571 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3575 uaudio_mixer_determine_class(&iot[d->baSourceId[i]]);
3592 d->bUnitId, d->bNrInPins);
3594 if (d->bNrInPins == 0)
3599 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3605 MIX(sc).maxval = d->bNrInPins;
3608 i = d->baSourceId[d->bNrInPins];
3610 usbd_req_get_string_any(sc->sc_udev, NULL,
3618 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3622 uaudio20_mixer_determine_class(&iot[d->baSourceId[i]]);
3636 uint32_t offset = (i * d->bControlSize);
3638 if (d->bControlSize > 0) {
3639 temp |= d->bmaControls[offset];
3640 if (d->bControlSize > 1) {
3641 temp |= d->bmaControls[offset + 1] << 8;
3642 if (d->bControlSize > 2) {
3643 temp |= d->bmaControls[offset + 2] << 16;
3644 if (d->bControlSize > 3) {
3645 temp |= d->bmaControls[offset + 3] << 24;
3667 if (d->bControlSize == 0)
3672 nchan = (d->bLength - 7) / d->bControlSize;
3688 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3690 i = d->bmaControls[nchan * d->bControlSize];
3692 usbd_req_get_string_any(sc->sc_udev, NULL,
3710 MIX(sc).nchan = nchan - 1;
3713 MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3715 MIX(sc).wValue[i - 1] = -1;
3805 if (UGETDW(d->bmaControls[0]) == 0)
3810 nchan = (d->bLength - 6) / 4;
3811 mmask = UGETDW(d->bmaControls[0]);
3820 cmask |= UGETDW(d->bmaControls[chan]);
3822 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3824 i = d->bmaControls[nchan][0];
3826 usbd_req_get_string_any(sc->sc_udev, NULL,
3912 MIX(sc).nchan = nchan - 1;
3914 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
3915 MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
3917 MIX(sc).wValue[i - 1] = -1;
3934 (const void *)(d0->baSourceId + d0->bNrInPins);
3936 (const void *)(d1->bmControls + d1->bControlSize);
3942 if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
3947 d0->bUnitId, ud->bNrModes);
3949 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
3955 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3960 for (i = 0; i < ud->bNrModes; i++) {
3961 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
3974 (const void *)(d0->baSourceId + d0->bNrInPins);
3979 ptype = UGETW(d0->wProcessType);
3982 "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
3984 if (d1->bControlSize == 0) {
3987 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
3988 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
4006 d0->bUnitId, ptype);
4017 (const void *)(d0->baSourceId + d0->bNrInPins);
4020 d0->bUnitId, d0->bNrInPins);
4022 if (sc->sc_uq_au_no_xu) {
4025 if (d1->bControlSize == 0) {
4028 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
4031 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
4063 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
4066 switch (u.desc->bDescriptorSubtype) {
4078 if (u.desc->bLength < len) {
4081 len += u.mu->bNrInPins;
4083 if (u.desc->bLength < len) {
4086 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4094 if (u.desc->bLength < len) {
4097 len += u.su->bNrInPins + 1;
4103 if (u.desc->bLength < len)
4106 len += u.fu->bControlSize;
4112 if (u.desc->bLength < len) {
4115 len += u.pu->bNrInPins;
4117 if (u.desc->bLength < len) {
4120 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4124 if (u.desc->bLength < len) {
4127 len += u1->bControlSize;
4134 if (u.desc->bLength < len) {
4137 len += u.eu->bNrInPins;
4139 if (u.desc->bLength < len) {
4142 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4146 if (u.desc->bLength < len) {
4149 len += e1->bControlSize;
4156 if (u.desc->bLength < len) {
4165 u.desc->bDescriptorType,
4166 u.desc->bDescriptorSubtype,
4167 u.desc->bLength, len);
4201 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
4204 switch (u.desc->bDescriptorSubtype) {
4216 if (u.desc->bLength < len)
4218 len += u.mu->bNrInPins;
4220 if (u.desc->bLength < len)
4223 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4225 len += sizeof(*d1) + d1->bNrChannels;
4231 if (u.desc->bLength < len)
4234 len += u.su->bNrInPins + 1;
4248 if (u.desc->bLength < len)
4251 len += u.pu->bNrInPins;
4253 if (u.desc->bLength < len)
4256 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4264 if (u.desc->bLength < len)
4267 len += u.eu->bNrInPins;
4269 if (u.desc->bLength < len)
4272 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4284 if (u.desc->bLength < len)
4287 len += u.csel->bNrInPins;
4289 if (u.desc->bLength < len)
4292 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4309 if (u.desc->bLength < len)
4318 u.desc->bDescriptorType,
4319 u.desc->bDescriptorSubtype,
4320 u.desc->bLength, len);
4337 switch (dp->bDescriptorSubtype) {
4339 r.bNrChannels = iot[id].u.it_v1->bNrChannels;
4340 r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
4341 r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
4342 r.iChannelNames = iot[id].u.it_v1->iChannelNames;
4346 id = iot[id].u.ot_v1->bSourceId;
4351 &iot[id].u.mu_v1->baSourceId[
4352 iot[id].u.mu_v1->bNrInPins];
4356 if (iot[id].u.su_v1->bNrInPins > 0) {
4358 id = iot[id].u.su_v1->baSourceId[0];
4363 id = iot[id].u.fu_v1->bSourceId;
4368 &iot[id].u.pu_v1->baSourceId[
4369 iot[id].u.pu_v1->bNrInPins]);
4374 &iot[id].u.eu_v1->baSourceId[
4375 iot[id].u.eu_v1->bNrInPins]);
4401 switch (dp->bDescriptorSubtype) {
4403 r.bNrChannels = iot[id].u.it_v2->bNrChannels;
4404 r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
4405 r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
4406 r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
4407 r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
4408 r.iChannelNames = iot[id].u.it_v2->iTerminal;
4412 id = iot[id].u.ot_v2->bSourceId;
4417 &iot[id].u.mu_v2->baSourceId[
4418 iot[id].u.mu_v2->bNrInPins];
4422 if (iot[id].u.su_v2->bNrInPins > 0) {
4424 id = iot[id].u.su_v2->baSourceId[0];
4429 id = iot[id].u.ru_v2->bSourceId;
4433 id = iot[id].u.ef_v2->bSourceId;
4437 id = iot[id].u.fu_v2->bSourceId;
4442 &iot[id].u.pu_v2->baSourceId[
4443 iot[id].u.pu_v2->bNrInPins]);
4448 &iot[id].u.eu_v2->baSourceId[
4449 iot[id].u.eu_v2->bNrInPins]);
4471 if (!n--)
4472 n = iot->usr.id_max;
4475 if (iot->usr.bit_input[n / 8] & (1 << (n % 8)))
4490 if (!n--)
4491 n = iot->usr.id_max;
4494 if (iot->usr.bit_output[n / 8] & (1 << (n % 8)))
4546 if (uat->terminal_type == 0) {
4561 } else if (uat->terminal_type == terminal_type) {
4562 retval = uat->feature;
4584 ptr = iot->root + i;
4585 temp = UGETW(ptr->u.it_v1->wTerminalType);
4596 ptr = iot->root + i;
4597 temp = UGETW(ptr->u.ot_v1->wTerminalType);
4643 ptr = iot->root + i;
4644 temp = UGETW(ptr->u.it_v2->wTerminalType);
4655 ptr = iot->root + i;
4656 temp = UGETW(ptr->u.ot_v2->wTerminalType);
4695 const uint8_t max = sizeof(src->bit_output) / sizeof(src->bit_output[0]);
4699 dst->bit_output[x] |= src->bit_output[x];
4714 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4719 info->recurse_level++;
4723 if (iot->u.desc == NULL)
4726 switch (iot->u.desc->bDescriptorSubtype) {
4728 uaudio_mixer_merge_outputs(&iot->usr, info);
4729 info->bit_input[i / 8] |= (1 << (i % 8));
4733 uaudio_mixer_merge_outputs(&iot->usr, info);
4735 root, &iot->u.fu_v1->bSourceId, 1, info);
4739 info->bit_output[i / 8] |= (1 << (i % 8));
4741 root, &iot->u.ot_v1->bSourceId, 1, info);
4742 info->bit_output[i / 8] &= ~(1 << (i % 8));
4746 uaudio_mixer_merge_outputs(&iot->usr, info);
4748 root, iot->u.mu_v1->baSourceId,
4749 iot->u.mu_v1->bNrInPins, info);
4753 uaudio_mixer_merge_outputs(&iot->usr, info);
4755 root, iot->u.su_v1->baSourceId,
4756 iot->u.su_v1->bNrInPins, info);
4760 uaudio_mixer_merge_outputs(&iot->usr, info);
4762 root, iot->u.pu_v1->baSourceId,
4763 iot->u.pu_v1->bNrInPins, info);
4767 uaudio_mixer_merge_outputs(&iot->usr, info);
4769 root, iot->u.eu_v1->baSourceId,
4770 iot->u.eu_v1->bNrInPins, info);
4791 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4796 info->recurse_level++;
4800 if (iot->u.desc == NULL)
4803 switch (iot->u.desc->bDescriptorSubtype) {
4805 uaudio_mixer_merge_outputs(&iot->usr, info);
4806 info->bit_input[i / 8] |= (1 << (i % 8));
4810 info->bit_output[i / 8] |= (1 << (i % 8));
4812 root, &iot->u.ot_v2->bSourceId, 1, info);
4813 info->bit_output[i / 8] &= ~(1 << (i % 8));
4817 uaudio_mixer_merge_outputs(&iot->usr, info);
4819 root, iot->u.mu_v2->baSourceId,
4820 iot->u.mu_v2->bNrInPins, info);
4824 uaudio_mixer_merge_outputs(&iot->usr, info);
4826 root, iot->u.su_v2->baSourceId,
4827 iot->u.su_v2->bNrInPins, info);
4831 uaudio_mixer_merge_outputs(&iot->usr, info);
4833 root, &iot->u.ru_v2->bSourceId,
4838 uaudio_mixer_merge_outputs(&iot->usr, info);
4840 root, &iot->u.ef_v2->bSourceId,
4845 uaudio_mixer_merge_outputs(&iot->usr, info);
4847 root, &iot->u.fu_v2->bSourceId, 1, info);
4851 uaudio_mixer_merge_outputs(&iot->usr, info);
4853 root, iot->u.pu_v2->baSourceId,
4854 iot->u.pu_v2->bNrInPins, info);
4858 uaudio_mixer_merge_outputs(&iot->usr, info);
4860 root, iot->u.eu_v2->baSourceId,
4861 iot->u.eu_v2->bNrInPins, info);
4884 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4889 info->recurse_level++;
4893 if (iot->u.desc == NULL)
4898 switch (iot->u.desc->bDescriptorSubtype) {
4900 info->is_input = 1;
4902 p_id = &iot->u.it_v2->bCSourceId;
4907 &iot->u.it_v2->bCSourceId, 1, info);
4911 info->is_input = 0;
4913 p_id = &iot->u.ot_v2->bCSourceId;
4918 &iot->u.ot_v2->bCSourceId, 1, info);
4923 p_id = iot->u.csel_v2->baCSourceId;
4924 n_id = iot->u.csel_v2->bNrInPins;
4928 iot->u.csel_v2->baCSourceId,
4929 iot->u.csel_v2->bNrInPins, info);
4934 p_id = &iot->u.cmul_v2->bCSourceId;
4939 &iot->u.cmul_v2->bCSourceId,
4945 id = iot->u.csrc_v2->bClockId;
4947 switch (info->is_input) {
4949 info->bit_output[id / 8] |= (1 << (id % 8));
4952 info->bit_input[id / 8] |= (1 << (id % 8));
4986 if ((acdp->bLength < sizeof(*acdp)) ||
4987 (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
4988 (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
4993 wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
4996 sc->sc_audio_rev = UGETW(acdp->bcdADC);
4999 sc->sc_audio_rev, wTotalLen);
5007 if (dp->bLength > wTotalLen) {
5010 wTotalLen -= dp->bLength;
5013 if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
5015 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
5021 iot[au->bUnitId].u.desc = (const void *)au;
5022 if (au->bUnitId > ID_max)
5023 ID_max = au->bUnitId;
5035 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5037 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5039 &i, 1, &((iot + i)->usr));
5041 sc->sc_mixer_clocks.is_input = 255;
5042 sc->sc_mixer_clocks.recurse_level = 0;
5045 &i, 1, &sc->sc_mixer_clocks);
5048 &i, 1, &((iot + i)->usr));
5050 } while (i--);
5056 (iot + i)->usr.id_max = ID_max;
5057 (iot + i)->root = iot;
5058 } while (i--);
5072 i, dp->bDescriptorSubtype);
5074 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5076 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5077 switch (dp->bDescriptorSubtype) {
5107 dp->bDescriptorSubtype);
5113 switch (dp->bDescriptorSubtype) {
5144 dp->bDescriptorSubtype);
5148 } while (i--);
5163 if (mc->wValue[0] == -1)
5177 uint16_t len = MIX_SIZE(mc->type);
5184 USETW(req.wValue, mc->wValue[0]);
5185 USETW(req.wIndex, mc->wIndex);
5220 val = uaudio_mixer_signext(mc->type, val);
5232 struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
5249 mc = sc->sc_mixer_root;
5250 sc->sc_mixer_curr = mc;
5251 sc->sc_mixer_chan = 0;
5255 while (sc->sc_mixer_chan < mc->nchan) {
5256 chan = sc->sc_mixer_chan;
5258 sc->sc_mixer_chan++;
5260 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
5261 (mc->wValue[chan] != -1));
5263 mc->update[chan / 8] &= ~(1 << (chan % 8));
5267 USETW(req.wValue, mc->wValue[chan]);
5268 USETW(req.wIndex, mc->wIndex);
5270 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5272 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5277 len = MIX_SIZE(mc->type);
5282 buf[0] = (mc->wData[chan] & 0xFF);
5283 buf[1] = (mc->wData[chan] >> 8) & 0xFF;
5298 mc = mc->next;
5299 sc->sc_mixer_curr = mc;
5300 sc->sc_mixer_chan = 0;
5311 /* do nothing - we are detaching */
5377 if (mc->type == MIX_ON_OFF) {
5379 } else if (mc->type != MIX_SELECTOR) {
5381 val = (val * mc->mul) / 100;
5384 val = val + mc->minval;
5387 if (val > mc->maxval)
5388 val = mc->maxval;
5389 else if (val < mc->minval)
5390 val = mc->minval;
5393 mc->type, val, mc->minval, mc->maxval, val);
5403 mc->update[chan / 8] |= (1 << (chan % 8));
5404 mc->wData[chan] = val;
5408 usbd_transfer_start(sc->sc_mixer_xfer[0]);
5419 for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5420 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5425 sc->sc_child[index].mix_info |= 1U << mc->ctl;
5427 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5428 (mc->type == MIX_SELECTOR)) {
5429 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5430 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
5432 sc->sc_child[index].recsrc_info |= 1U << mc->slctrtype[i - 1];
5445 sc->sc_child[i].mixer_lock = mixer_get_lock(m);
5446 sc->sc_child[i].mixer_dev = m;
5449 usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5450 sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5451 sc->sc_child[i].mixer_lock)) {
5456 if (sc->sc_play_chan[i].num_alt > 0 &&
5457 (sc->sc_child[i].mix_info & SOUND_MASK_VOLUME) == 0) {
5461 mix_setdevs(m, sc->sc_child[i].mix_info);
5462 mix_setrecdevs(m, sc->sc_child[i].recsrc_info);
5474 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5476 sc->sc_child[index].mixer_lock = NULL;
5491 for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5492 if (mc->ctl == type) {
5493 for (chan = 0; chan < mc->nchan; chan++) {
5512 for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5513 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5514 (mc->type == MIX_SELECTOR)) {
5518 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++)
5519 mask |= 1U << mc->slctrtype[i - 1];
5526 temp = (-temp) & temp;
5532 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5533 if (temp != (1U << mc->slctrtype[i - 1]))
5577 * Lookup sub-channel. The index is range
5580 sub = &chan->sub[cn];
5582 if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5583 (sub->read_open != 0)) {
5586 sub->fifo.fp[USB_FIFO_RX],
5589 actlen -= 4;
5627 sub->temp_0[0] = p0 | 0x0f;
5628 sub->temp_0[1] = b;
5629 sub->temp_0[2] = 0;
5630 sub->temp_0[3] = 0;
5631 sub->temp_cmd = sub->temp_0;
5637 sub->temp_1[1] = b;
5638 sub->state = UMIDI_ST_SYSEX_1;
5642 sub->temp_1[1] = b;
5643 sub->state = UMIDI_ST_1PARAM;
5646 sub->temp_1[1] = b;
5647 sub->state = UMIDI_ST_2PARAM_1;
5651 sub->state = UMIDI_ST_UNKNOWN;
5654 sub->temp_1[0] = p0 | 0x05;
5655 sub->temp_1[1] = 0xf6;
5656 sub->temp_1[2] = 0;
5657 sub->temp_1[3] = 0;
5658 sub->temp_cmd = sub->temp_1;
5659 sub->state = UMIDI_ST_UNKNOWN;
5663 switch (sub->state) {
5665 sub->temp_1[0] = p0 | 0x05;
5666 sub->temp_1[1] = 0xf7;
5667 sub->temp_1[2] = 0;
5668 sub->temp_1[3] = 0;
5669 sub->temp_cmd = sub->temp_1;
5670 sub->state = UMIDI_ST_UNKNOWN;
5673 sub->temp_1[0] = p0 | 0x06;
5674 sub->temp_1[2] = 0xf7;
5675 sub->temp_1[3] = 0;
5676 sub->temp_cmd = sub->temp_1;
5677 sub->state = UMIDI_ST_UNKNOWN;
5680 sub->temp_1[0] = p0 | 0x07;
5681 sub->temp_1[3] = 0xf7;
5682 sub->temp_cmd = sub->temp_1;
5683 sub->state = UMIDI_ST_UNKNOWN;
5686 sub->state = UMIDI_ST_UNKNOWN;
5690 sub->temp_1[1] = b;
5692 sub->state = UMIDI_ST_1PARAM;
5694 sub->state = UMIDI_ST_2PARAM_1;
5697 switch (sub->state) {
5699 if (sub->temp_1[1] < 0xf0) {
5700 p0 |= sub->temp_1[1] >> 4;
5703 sub->state = UMIDI_ST_UNKNOWN;
5705 sub->temp_1[0] = p0;
5706 sub->temp_1[2] = b;
5707 sub->temp_1[3] = 0;
5708 sub->temp_cmd = sub->temp_1;
5711 sub->temp_1[2] = b;
5712 sub->state = UMIDI_ST_2PARAM_2;
5715 if (sub->temp_1[1] < 0xf0) {
5716 p0 |= sub->temp_1[1] >> 4;
5717 sub->state = UMIDI_ST_2PARAM_1;
5720 sub->state = UMIDI_ST_UNKNOWN;
5722 sub->temp_1[0] = p0;
5723 sub->temp_1[3] = b;
5724 sub->temp_cmd = sub->temp_1;
5727 sub->temp_1[1] = b;
5728 sub->state = UMIDI_ST_SYSEX_1;
5731 sub->temp_1[2] = b;
5732 sub->state = UMIDI_ST_SYSEX_2;
5735 sub->temp_1[0] = p0 | 0x04;
5736 sub->temp_1[3] = b;
5737 sub->temp_cmd = sub->temp_1;
5738 sub->state = UMIDI_ST_SYSEX_0;
5775 start_cable = chan->curr_cable;
5780 /* round robin de-queueing */
5782 sub = &chan->sub[chan->curr_cable];
5784 if (sub->write_open) {
5785 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5795 (unsigned int)chan->curr_cable);
5797 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5799 sub->temp_cmd[0], sub->temp_cmd[1],
5800 sub->temp_cmd[2], sub->temp_cmd[3]);
5802 usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5806 if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5813 chan->curr_cable++;
5814 if (chan->curr_cable >= chan->max_emb_jack)
5815 chan->curr_cable = 0;
5817 if (chan->curr_cable == start_cable) {
5852 sub = &chan->sub[n];
5853 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5854 (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5870 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5881 sub->read_open = 0;
5883 if (--(chan->read_open_refcount) == 0) {
5897 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) {
5905 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
5917 sub->write_open = 0;
5919 if (--(chan->write_open_refcount) == 0) {
5921 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
5935 mtx_lock(&chan->mtx);
5936 chan->read_open_refcount++;
5937 sub->read_open = 1;
5938 mtx_unlock(&chan->mtx);
5945 mtx_lock(&chan->mtx);
5946 chan->write_open_refcount++;
5947 sub->write_open = 1;
5950 sub->state = UMIDI_ST_UNKNOWN;
5951 mtx_unlock(&chan->mtx);
5978 struct umidi_chan *chan = &sc->sc_midi_chan;
5980 mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5999 struct umidi_chan *chan = &sc->sc_midi_chan;
6006 chan->single_command = 1;
6008 error = usbd_set_alt_interface_index(sc->sc_udev,
6009 chan->iface_index, chan->iface_alt_index);
6015 usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
6016 sc->sc_mixer_iface_index);
6018 error = usbd_transfer_setup(uaa->device, &chan->iface_index,
6019 chan->xfer, umidi_config, UMIDI_N_TRANSFER,
6020 chan, &chan->mtx);
6025 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL &&
6026 chan->xfer[UMIDI_RX_TRANSFER] == NULL) {
6039 * Controllers are required to have support for 8-, 16-, 32-,
6040 * and 64-byte maximum packet sizes for full-speed bulk
6041 * endpoints and 512 bytes for high-speed bulk endpoints."
6043 if (chan->xfer[UMIDI_TX_TRANSFER] != NULL &&
6044 usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
6045 chan->single_command = 1;
6047 if (chan->single_command != 0)
6050 if ((chan->max_emb_jack == 0) ||
6051 (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) {
6052 chan->max_emb_jack = UMIDI_EMB_JACK_MAX;
6055 for (n = 0; n < chan->max_emb_jack; n++) {
6056 sub = &chan->sub[n];
6058 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
6059 &umidi_fifo_methods, &sub->fifo, unit, n,
6060 chan->iface_index,
6067 mtx_lock(&chan->mtx);
6075 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
6077 mtx_unlock(&chan->mtx);
6089 struct umidi_chan *chan = &sc->sc_midi_chan;
6093 usb_fifo_detach(&chan->sub[n].fifo);
6095 mtx_lock(&chan->mtx);
6097 usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
6099 mtx_unlock(&chan->mtx);
6101 usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
6103 mtx_destroy(&chan->mtx);
6124 (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
6127 actlen--;
6132 m = sc->sc_child[0].mixer_dev;
6134 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
6135 (sc->sc_hid.mute_id == id) &&
6137 &sc->sc_hid.mute_loc)) {
6143 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
6144 (sc->sc_hid.volume_up_id == id) &&
6146 &sc->sc_hid.volume_up_loc)) {
6152 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
6153 (sc->sc_hid.volume_down_id == id) &&
6155 &sc->sc_hid.volume_down_loc)) {
6158 mixer_hwvol_step_locked(m, -1, -1);
6191 if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
6192 return (-1);
6194 if (sc->sc_child[0].mixer_lock == NULL)
6195 return (-1);
6198 error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
6199 &d_len, M_TEMP, sc->sc_hid.iface_index);
6203 return (-1);
6210 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
6214 hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
6215 &sc->sc_hid.volume_up_id)) {
6217 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
6223 hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
6224 &sc->sc_hid.volume_down_id)) {
6226 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
6232 hid_input, 0, &sc->sc_hid.mute_loc, &flags,
6233 &sc->sc_hid.mute_id)) {
6235 sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
6241 if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
6245 return (-1);
6249 usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
6250 sc->sc_mixer_iface_index);
6253 error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
6254 sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
6255 sc, sc->sc_child[0].mixer_lock);
6258 return (-1);
6266 usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);