From 5cfbd550fed6bf20accb452c06d6b66c01883bd1 Mon Sep 17 00:00:00 2001 From: Ed Clarke Date: Mon, 29 Oct 2018 07:20:12 +0000 Subject: [PATCH] Add initial lit ep0 cutdown versions --- lib_xua/src/core/endpoint0/xua_endpoint0.c | 424 +++++++++++++++++- lib_xua/src/core/endpoint0/xua_ep0_wrapper.xc | 21 +- 2 files changed, 418 insertions(+), 27 deletions(-) diff --git a/lib_xua/src/core/endpoint0/xua_endpoint0.c b/lib_xua/src/core/endpoint0/xua_endpoint0.c index 3bb36f55..48711656 100755 --- a/lib_xua/src/core/endpoint0/xua_endpoint0.c +++ b/lib_xua/src/core/endpoint0/xua_endpoint0.c @@ -298,6 +298,32 @@ void XUA_Endpoint0_init(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioCont } +void XUA_Endpoint0_lite_init(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, + chanend c_mix_ctl, chanend c_clk_ctl, chanend c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_) +{ + ep0_out = XUD_InitEp(c_ep0_out); + ep0_in = XUD_InitEp(c_ep0_in); + + VendorRequests_Init(VENDOR_REQUESTS_PARAMS); + +#ifdef VENDOR_AUDIO_REQS + VendorAudioRequestsInit(c_audioControl, c_mix_ctl, c_clk_ctl); +#endif + +#if (XUA_DFU_EN == 1) + /* Check if device has started in DFU mode */ + if (DFUReportResetState(null)) + { + /* Stop audio */ + outuint(c_audioControl, SET_SAMPLE_FREQ); + outuint(c_audioControl, AUDIO_STOP_FOR_DFU); + /* No Handshake */ + DFU_mode_active = 1; + } +#endif + +} + void XUA_Endpoint0_loop(XUD_Result_t result, USB_SetupPacket_t sp, chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, chanend c_mix_ctl, chanend c_clk_ctl, chanend c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_) { @@ -803,6 +829,385 @@ void XUA_Endpoint0_loop(XUD_Result_t result, USB_SetupPacket_t sp, chanend c_ep0 } } +void XUA_Endpoint0_lite_loop(XUD_Result_t result, USB_SetupPacket_t sp, chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, + chanend c_mix_ctl, chanend c_clk_ctl, chanend c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_ + , unsigned *input_interface_num, unsigned *output_interface_num) +{ + if (result == XUD_RES_OKAY) + { + result = XUD_RES_ERR; + + /* Inspect Request type and Receipient and direction */ + switch( (sp.bmRequestType.Direction << 7) | (sp.bmRequestType.Recipient ) | (sp.bmRequestType.Type << 5) ) + { + case USB_BMREQ_H2D_STANDARD_INT: + + /* Over-riding USB_StandardRequests implementation */ + if(sp.bRequest == USB_SET_INTERFACE) + { + switch (sp.wIndex) + { + /* Check for audio stream from host start/stop */ +#if (NUM_USB_CHAN_OUT > 0) && (AUDIO_CLASS == 2) + case INTERFACE_NUMBER_AUDIO_OUTPUT: + *output_interface_num = sp.wValue; + break; +#endif + +#if (NUM_USB_CHAN_IN > 0) && (AUDIO_CLASS == 2) + case INTERFACE_NUMBER_AUDIO_INPUT: + *input_interface_num = sp.wValue; + break; +#endif + default: + /* Unhandled interface */ + break; + } + } /* if(sp.bRequest == SET_INTERFACE) */ + + break; /* BMREQ_H2D_STANDARD_INT */ + + case USB_BMREQ_D2H_STANDARD_INT: + + switch(sp.bRequest) + { +#ifdef HID_CONTROLS + case USB_GET_DESCRIPTOR: + + /* Check what inteface request is for */ + if(sp.wIndex == INTERFACE_NUMBER_HID) + { + /* High byte of wValue is descriptor type */ + unsigned descriptorType = sp.wValue & 0xff00; + + switch (descriptorType) + { + case HID_HID: + /* Return HID Descriptor */ + result = XUD_DoGetRequest(ep0_out, ep0_in, hidDescriptor, + sizeof(hidDescriptor), sp.wLength); + break; + case HID_REPORT: + /* Return HID report descriptor */ + result = XUD_DoGetRequest(ep0_out, ep0_in, hidReportDescriptor, + sizeof(hidReportDescriptor), sp.wLength); + break; + } + } + break; +#endif + default: + break; + } + break; + + /* Recipient: Device */ + case USB_BMREQ_H2D_STANDARD_DEV: + + /* Inspect for actual request */ + switch( sp.bRequest ) + { + /* Standard request: SetConfiguration */ + /* Overriding implementation in USB_StandardRequests */ + case USB_SET_CONFIGURATION: + + //if(g_current_config == 1) + { + /* Consider host active with valid driver at this point */ + UserHostActive(1); + } + + /* We want to run USB_StandardsRequests() implementation also. Don't modify result + * and don't call XUD_DoSetRequestStatus() */ + break; + + default: + //Unknown device request" + break; + } + break; + + /* Audio Class 1.0 Sampling Freqency Requests go to Endpoint */ + case USB_BMREQ_H2D_CLASS_EP: + case USB_BMREQ_D2H_CLASS_EP: + { + unsigned epNum = sp.wIndex & 0xff; + + if ((epNum == ENDPOINT_ADDRESS_OUT_AUDIO) || (epNum == ENDPOINT_ADDRESS_IN_AUDIO)) + { +#if (AUDIO_CLASS == 2) && (AUDIO_CLASS_FALLBACK) + if(g_curUsbSpeed == XUD_SPEED_FS) + { + result = AudioEndpointRequests_1(ep0_out, ep0_in, &sp, c_audioControl, c_mix_ctl, c_clk_ctl); + } +#elif (AUDIO_CLASS==1) + result = AudioEndpointRequests_1(ep0_out, ep0_in, &sp, c_audioControl, c_mix_ctl, c_clk_ctl); +#endif + } + + } + break; + + case USB_BMREQ_H2D_CLASS_INT: + case USB_BMREQ_D2H_CLASS_INT: + { + unsigned interfaceNum = sp.wIndex & 0xff; + //unsigned request = (sp.bmRequestType.Recipient ) | (sp.bmRequestType.Type << 5); + + /* TODO Check on return value retval = */ +#if (XUA_DFU_EN == 1) + unsigned DFU_IF = INTERFACE_NUMBER_DFU; + + /* DFU interface number changes based on which mode we are currently running in */ + if (DFU_mode_active) + { + DFU_IF = 0; + } + + if (interfaceNum == DFU_IF) + { + int reset = 0; + + /* If running in application mode stop audio */ + /* Don't interupt audio for save and restore cmds */ + if ((DFU_IF == INTERFACE_NUMBER_DFU) && (sp.bRequest != XMOS_DFU_SAVESTATE) && + (sp.bRequest != XMOS_DFU_RESTORESTATE)) + { + // Stop audio + outuint(c_audioControl, SET_SAMPLE_FREQ); + outuint(c_audioControl, AUDIO_STOP_FOR_DFU); + // Handshake + chkct(c_audioControl, XS1_CT_END); + } + + /* This will return 1 if reset requested */ + result = DFUDeviceRequests(ep0_out, &ep0_in, &sp, null, g_interfaceAlt[sp.wIndex], dfuInterface, &reset); + + if(reset) + { + DFUDelay(50000000); + device_reboot(); + } + } +#endif + /* Check for: - Audio CONTROL interface request - always 0, note we check for DFU first + * - Audio STREAMING interface request (In or Out) + * - Audio endpoint request (Audio 1.0 Sampling freq requests are sent to the endpoint) + */ + if(((interfaceNum == 0) || (interfaceNum == 1) || (interfaceNum == 2)) +#if (XUA_DFU_EN == 1) + && !DFU_mode_active +#endif + ) + { +#if (AUDIO_CLASS == 2) && (AUDIO_CLASS_FALLBACK) + if(g_curUsbSpeed == XUD_SPEED_HS) + { + result = AudioClassRequests_2(ep0_out, ep0_in, &sp, c_audioControl, c_mix_ctl, c_clk_ctl); + } + else + { + result = AudioClassRequests_1(ep0_out, ep0_in, &sp, c_audioControl, c_mix_ctl, c_clk_ctl); + } +#elif (AUDIO_CLASS==2) + result = AudioClassRequests_2(ep0_out, ep0_in, &sp, c_audioControl, c_mix_ctl, c_clk_ctl); +#else + result = AudioClassRequests_1(ep0_out, ep0_in, &sp, c_audioControl, c_mix_ctl, c_clk_ctl); +#endif + +#ifdef VENDOR_AUDIO_REQS + /* If result is ERR at this point, then request to audio interface not handled - handle vendor audio reqs */ + if(result == XUD_RES_ERR) + { + result = VendorAudioRequests(ep0_out, ep0_in, sp.bRequest, + sp.wValue >> 8, sp.wValue & 0xff, + sp.wIndex >> 8, sp.bmRequestType.Direction, + c_audioControl, c_mix_ctl, c_clk_ctl); + } +#endif + } + } + break; + + default: + break; + } + + } /* if(result == XUD_RES_OKAY) */ + + { + if(result == XUD_RES_ERR) + { + /* Run vendor defined parsing/processing */ + /* Note, an interface might seem ideal here but this *must* be executed on the same + * core sure to shared memory depandancy */ + result = VendorRequests(ep0_out, ep0_in, &sp VENDOR_REQUESTS_PARAMS_); + } + } + + if(result == XUD_RES_ERR) + { +#if (XUA_DFU_EN == 1) + if (!DFU_mode_active) + { +#endif +#if (AUDIO_CLASS_FALLBACK) && (AUDIO_CLASS != 1) + /* Return Audio 2.0 Descriptors with Audio 1.0 as fallback */ + result = USB_StandardRequests(ep0_out, ep0_in, + (unsigned char*)&devDesc_Audio2, sizeof(devDesc_Audio2), + (unsigned char*)&cfgDesc_Audio2, sizeof(cfgDesc_Audio2), + (unsigned char*)&devDesc_Audio1, sizeof(devDesc_Audio1), + cfgDesc_Audio1, sizeof(cfgDesc_Audio1), + (char**)&g_strTable, sizeof(g_strTable)/sizeof(char *), + &sp, g_curUsbSpeed); +#elif FULL_SPEED_AUDIO_2 + /* Return Audio 2.0 Descriptors for high_speed and full-speed */ + + /* Unfortunately we need to munge the descriptors a bit between full and high-speed */ + if(g_curUsbSpeed == XUD_SPEED_HS) + { + /* Modify Audio Class 2.0 Config descriptor for High-speed operation */ +#if (NUM_USB_CHAN_OUT > 0) + cfgDesc_Audio2.Audio_CS_Control_Int.Audio_Out_InputTerminal.bNrChannels = NUM_USB_CHAN_OUT; +#if (NUM_USB_CHAN_OUT > 0) + cfgDesc_Audio2.Audio_Out_Format.bSubslotSize = HS_STREAM_FORMAT_OUTPUT_1_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_Out_Format.bBitResolution = HS_STREAM_FORMAT_OUTPUT_1_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_Out_Endpoint.wMaxPacketSize = HS_STREAM_FORMAT_OUTPUT_1_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_Out_ClassStreamInterface.bNrChannels = NUM_USB_CHAN_OUT; +#endif +#if (OUTPUT_FORMAT_COUNT > 1) + cfgDesc_Audio2.Audio_Out_Format_2.bSubslotSize = HS_STREAM_FORMAT_OUTPUT_2_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_Out_Format_2.bBitResolution = HS_STREAM_FORMAT_OUTPUT_2_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_Out_Endpoint_2.wMaxPacketSize = HS_STREAM_FORMAT_OUTPUT_2_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_Out_ClassStreamInterface_2.bNrChannels = NUM_USB_CHAN_OUT; +#endif + +#if (OUTPUT_FORMAT_COUNT > 2) + cfgDesc_Audio2.Audio_Out_Format_3.bSubslotSize = HS_STREAM_FORMAT_OUTPUT_3_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_Out_Format_3.bBitResolution = HS_STREAM_FORMAT_OUTPUT_3_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_Out_Endpoint_3.wMaxPacketSize = HS_STREAM_FORMAT_OUTPUT_3_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_Out_ClassStreamInterface_3.bNrChannels = NUM_USB_CHAN_OUT; +#endif +#endif +#if (NUM_USB_CHAN_IN > 0) + cfgDesc_Audio2.Audio_CS_Control_Int.Audio_In_InputTerminal.bNrChannels = NUM_USB_CHAN_IN; + cfgDesc_Audio2.Audio_In_Format.bSubslotSize = HS_STREAM_FORMAT_INPUT_1_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_In_Format.bBitResolution = HS_STREAM_FORMAT_INPUT_1_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_In_Endpoint.wMaxPacketSize = HS_STREAM_FORMAT_INPUT_1_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_In_ClassStreamInterface.bNrChannels = NUM_USB_CHAN_IN; +#endif + } + else + { + /* Modify Audio Class 2.0 Config descriptor for Full-speed operation */ +#if (NUM_USB_CHAN_OUT > 0) + cfgDesc_Audio2.Audio_CS_Control_Int.Audio_Out_InputTerminal.bNrChannels = NUM_USB_CHAN_OUT_FS; +#if (NUM_USB_CHAN_OUT > 0) + cfgDesc_Audio2.Audio_Out_Format.bSubslotSize = FS_STREAM_FORMAT_OUTPUT_1_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_Out_Format.bBitResolution = FS_STREAM_FORMAT_OUTPUT_1_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_Out_Endpoint.wMaxPacketSize = FS_STREAM_FORMAT_OUTPUT_1_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_Out_ClassStreamInterface.bNrChannels = NUM_USB_CHAN_OUT_FS; +#endif +#if (OUTPUT_FORMAT_COUNT > 1) + cfgDesc_Audio2.Audio_Out_Format_2.bSubslotSize = FS_STREAM_FORMAT_OUTPUT_2_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_Out_Format_2.bBitResolution = FS_STREAM_FORMAT_OUTPUT_2_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_Out_Endpoint_2.wMaxPacketSize = FS_STREAM_FORMAT_OUTPUT_2_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_Out_ClassStreamInterface_2.bNrChannels = NUM_USB_CHAN_OUT_FS; +#endif + +#if (OUTPUT_FORMAT_COUNT > 2) + cfgDesc_Audio2.Audio_Out_Format_3.bSubslotSize = FS_STREAM_FORMAT_OUTPUT_3_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_Out_Format_3.bBitResolution = FS_STREAM_FORMAT_OUTPUT_3_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_Out_Endpoint_3.wMaxPacketSize = FS_STREAM_FORMAT_OUTPUT_3_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_Out_ClassStreamInterface_3.bNrChannels = NUM_USB_CHAN_OUT_FS; +#endif +#endif +#if (NUM_USB_CHAN_IN > 0) + cfgDesc_Audio2.Audio_CS_Control_Int.Audio_In_InputTerminal.bNrChannels = NUM_USB_CHAN_IN_FS; + cfgDesc_Audio2.Audio_In_Format.bSubslotSize = FS_STREAM_FORMAT_INPUT_1_SUBSLOT_BYTES; + cfgDesc_Audio2.Audio_In_Format.bBitResolution = FS_STREAM_FORMAT_INPUT_1_RESOLUTION_BITS; + cfgDesc_Audio2.Audio_In_Endpoint.wMaxPacketSize = FS_STREAM_FORMAT_INPUT_1_MAXPACKETSIZE; + cfgDesc_Audio2.Audio_In_ClassStreamInterface.bNrChannels = NUM_USB_CHAN_IN_FS; +#endif + } + + result = USB_StandardRequests(ep0_out, ep0_in, + (unsigned char*)&devDesc_Audio2, sizeof(devDesc_Audio2), + (unsigned char*)&cfgDesc_Audio2, sizeof(cfgDesc_Audio2), + null, 0, + null, 0, +#ifdef __XC__ + g_strTable, sizeof(g_strTable), sp, null, g_curUsbSpeed); +#else + (char**)&g_strTable, sizeof(g_strTable)/sizeof(char *), &sp, g_curUsbSpeed); +#endif +#elif (AUDIO_CLASS == 1) + /* Return Audio 1.0 Descriptors in FS, should never be in HS! */ + result = USB_StandardRequests(ep0_out, ep0_in, + null, 0, + null, 0, + (unsigned char*)&devDesc_Audio1, sizeof(devDesc_Audio1), + cfgDesc_Audio1, sizeof(cfgDesc_Audio1), + (char**)&g_strTable, sizeof(g_strTable)/sizeof(char *), &sp, g_curUsbSpeed); +#else + /* Return Audio 2.0 Descriptors with Null device as fallback */ + result = USB_StandardRequests(ep0_out, ep0_in, + (unsigned char*)&devDesc_Audio2, sizeof(devDesc_Audio2), + (unsigned char*)&cfgDesc_Audio2, sizeof(cfgDesc_Audio2), + devDesc_Null, sizeof(devDesc_Null), + cfgDesc_Null, sizeof(cfgDesc_Null), + (char**)&g_strTable, sizeof(g_strTable)/sizeof(char *), &sp, g_curUsbSpeed); +#endif +#if (XUA_DFU_EN == 1) + } + + else + { + /* Running in DFU mode - always return same descs for DFU whether HS or FS */ + result = USB_StandardRequests(ep0_out, ep0_in, + DFUdevDesc, sizeof(DFUdevDesc), + DFUcfgDesc, sizeof(DFUcfgDesc), + null, 0, /* Used same descriptors for full and high-speed */ + null, 0, + (char**)&g_strTable, sizeof(g_strTable)/sizeof(char *), &sp, g_curUsbSpeed); + } +#endif + } + + if (result == XUD_RES_RST) + { +#ifdef __XC__ + g_curUsbSpeed = XUD_ResetEndpoint(ep0_out, ep0_in); +#else + g_curUsbSpeed = XUD_ResetEndpoint(ep0_out, &ep0_in); +#endif + g_currentConfig = 0; + g_curStreamAlt_Out = 0; + g_curStreamAlt_In = 0; + +#if (XUA_DFU_EN == 1) + if (DFUReportResetState(null)) + { + if (!DFU_mode_active) + { + DFU_mode_active = 1; + } + } + else + { + if (DFU_mode_active) + { + DFU_mode_active = 0; + + /* Send reboot command */ + DFUDelay(5000000); + device_reboot(); + } + } +#endif + } +} + /* Endpoint 0 function. Handles all requests to the device */ void XUA_Endpoint0(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, chanend c_mix_ctl, chanend c_clk_ctl, chanend c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_) @@ -812,27 +1217,8 @@ void XUA_Endpoint0(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, while(1) { -#if XUA_LITE - unsigned char sbuffer[120]; - unsigned length = 0; - XUD_Result_t result = XUD_RES_ERR; - - //XUD_Result_t result = XUD_GetSetupBuffer(ep0_out, sbuffer, &length); //Flattened from xud_device - result = XUD_GetSetupData(ep0_out, sbuffer, &length);//Flattened from XUD_EpFunctions.xc - - // select{ - // case XUD_GetSetupData_Select(c_ep0_out, ep0_out, &length, &result): - // break; - - if (result == XUD_RES_OKAY) - { - /* Parse data buffer end populate SetupPacket struct */ - USB_ParseSetupPacket(sbuffer, &sp); - } -#else /* Returns XUD_RES_OKAY for success, XUD_RES_RST for bus reset */ XUD_Result_t result = USB_GetSetupPacket(ep0_out, ep0_in, &sp); -#endif XUA_Endpoint0_loop(result, sp, c_ep0_out, c_ep0_in, c_audioControl, c_mix_ctl, c_clk_ctl, c_EANativeTransport_ctrl, dfuInterface); } } diff --git a/lib_xua/src/core/endpoint0/xua_ep0_wrapper.xc b/lib_xua/src/core/endpoint0/xua_ep0_wrapper.xc index 36152999..a647d458 100644 --- a/lib_xua/src/core/endpoint0/xua_ep0_wrapper.xc +++ b/lib_xua/src/core/endpoint0/xua_ep0_wrapper.xc @@ -7,11 +7,12 @@ #define DEBUG_PRINT_ENABLE_EP0_WRAPPER 1 #include "debug_print.h" -#if 1 -void XUA_Endpoint0_init(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, - chanend ?c_mix_ctl, chanend ?c_clk_ctl, chanend ?c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, ?dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_); -void XUA_Endpoint0_loop(XUD_Result_t result, USB_SetupPacket_t sp, chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, +extern "C"{ +void XUA_Endpoint0_lite_init(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, chanend ?c_mix_ctl, chanend ?c_clk_ctl, chanend ?c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, ?dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_); +void XUA_Endpoint0_lite_loop(XUD_Result_t result, USB_SetupPacket_t sp, chanend c_ep0_out, chanend c_ep0_in, chanend c_audioControl, + chanend ?c_mix_ctl, chanend ?c_clk_ctl, chanend ?c_EANativeTransport_ctrl, CLIENT_INTERFACE(i_dfu, ?dfuInterface) VENDOR_REQUESTS_PARAMS_DEC_, unsigned *input_interface_num, unsigned *output_interface_num); +} #pragma select handler void XUD_GetSetupData_Select(chanend c, XUD_ep e_out, unsigned &length, XUD_Result_t &result); @@ -24,9 +25,14 @@ void XUA_Endpoint0_select(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioCo { USB_SetupPacket_t sp; - XUA_Endpoint0_init(c_ep0_out, c_ep0_in, c_audioControl, c_mix_ctl, c_clk_ctl, c_EANativeTransport_ctrl, dfuInterface); + XUA_Endpoint0_lite_init(c_ep0_out, c_ep0_in, c_audioControl, c_mix_ctl, c_clk_ctl, c_EANativeTransport_ctrl, dfuInterface); unsigned char sbuffer[120]; XUD_SetReady_Out(ep0_out, sbuffer); + + unsigned input_interface_num = 0; + unsigned output_interface_num = 0; + + while(1){ XUD_Result_t result = XUD_RES_ERR; @@ -47,9 +53,8 @@ void XUA_Endpoint0_select(chanend c_ep0_out, chanend c_ep0_in, chanend c_audioCo } debug_printf("ep0, result: %d, length: %d\n", result, length); //-1 reset, 0 ok, 1 error - XUA_Endpoint0_loop(result, sp, c_ep0_out, c_ep0_in, c_audioControl, c_mix_ctl, c_clk_ctl, c_EANativeTransport_ctrl, dfuInterface); + XUA_Endpoint0_lite_loop(result, sp, c_ep0_out, c_ep0_in, c_audioControl, c_mix_ctl, c_clk_ctl, c_EANativeTransport_ctrl, dfuInterface, &input_interface_num, &output_interface_num); XUD_SetReady_Out(ep0_out, sbuffer); } -} -#endif \ No newline at end of file +} \ No newline at end of file