seklyuts/MotorControlModuleSDFM_TMS320F28388D
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 4 Wiki Activity

EFC_UsbDriver

Browse Source
This commit is contained in:
seklyuts 2024-06-07 11:04:32 +03:00
parent 24b3b39d9f
commit 3eec0875b0
30 changed files with 5157 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Projects/EFC_UsbDriver/.ccsproject Normal file
View File

@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8" ?>
<?ccsproject version="1.0"?>
<projectOptions>
<ccsVariant value="0:Eclipse-based"/>
<ccsVersion value="12.4.0"/>
<deviceVariant value="Cortex M.TMS320F28388D"/>
<deviceFamily value="TMS470"/>
<deviceEndianness value="little"/>
<codegenToolVersion value="20.2.7.LTS"/>
<isElfFormat value="true"/>
<createSlaveProjects value=""/>
<templateProperties value="id=com.ti.common.project.core.emptyProjectWithMainTemplate"/>
<filesToOpen value="main.c"/>
<isTargetManual value="false"/>
<origin value="D:/MotorControlModuleSDFM_TMS320F28388D/malyarenko/EFC_UsbDriver"/>
</projectOptions>

154
Projects/EFC_UsbDriver/.cproject Normal file
View File

@ -0,0 +1,154 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
<storageModule moduleId="org.eclipse.cdt.core.settings">
<cconfiguration id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.779747171">
<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.779747171" moduleId="org.eclipse.cdt.core.settings" name="Debug">
<externalSettings/>
<extensions>
<extension id="com.ti.ccstudio.binaryparser.CoffParser" point="org.eclipse.cdt.core.BinaryParser"/>
<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="com.ti.ccstudio.errorparser.CoffErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="com.ti.ccstudio.errorparser.AsmErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="com.ti.ccstudio.errorparser.LinkErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
</extensions>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<configuration artifactExtension="lib" artifactName="efc_usb_cm" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.779747171" name="Debug" parent="com.ti.ccstudio.buildDefinitions.TMS470.Debug">
<folderInfo id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.779747171." name="/" resourcePath="">
<toolChain id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.libraryDebugToolchain.367416713" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.libraryDebugToolchain" targetTool="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.librarianDebug.1344322407">
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.589415374" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
<listOptionValue builtIn="false" value="DEVICE_CONFIGURATION_ID=Cortex M.TMS320F28388D"/>
<listOptionValue builtIn="false" value="DEVICE_CORE_ID="/>
<listOptionValue builtIn="false" value="DEVICE_ENDIANNESS=little"/>
<listOptionValue builtIn="false" value="OUTPUT_FORMAT=ELF"/>
<listOptionValue builtIn="false" value="CCS_MBS_VERSION=6.1.3"/>
<listOptionValue builtIn="false" value="OUTPUT_TYPE=staticLibrary"/>
<listOptionValue builtIn="false" value="PRODUCTS=c2000ware_software_package:5.0.0.00;"/>
<listOptionValue builtIn="false" value="PRODUCT_MACRO_IMPORTS={&quot;c2000ware_software_package&quot;:[&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INCLUDE_PATH}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_LIBRARY_PATH}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_LIBRARIES}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_SYMBOLS}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_SYSCONFIG_MANIFEST}&quot;]}"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.833796757" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="20.2.7.LTS" valueType="string"/>
<targetPlatform id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.targetPlatformDebug.1115460" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.targetPlatformDebug"/>
<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.builderDebug.743774572" keepEnvironmentInBuildfile="false" name="GNU Make" parallelBuildOn="true" parallelizationNumber="optimal" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.builderDebug"/>
<tool id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.compilerDebug.1988911961" name="Arm Compiler" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.compilerDebug">
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.SILICON_VERSION.1909397293" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.SILICON_VERSION" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.SILICON_VERSION.7M4" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.CODE_STATE.2071754359" name="Designate code state, 16-bit (thumb) or 32-bit (--code_state)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.CODE_STATE" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.CODE_STATE.16" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.FLOAT_SUPPORT.1253650549" name="Specify floating point support (--float_support)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.FLOAT_SUPPORT" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.FLOAT_SUPPORT.none" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.GEN_FUNC_SUBSECTIONS.1078250721" name="Place each function in a separate subsection (--gen_func_subsections, -ms)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.GEN_FUNC_SUBSECTIONS" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.GEN_FUNC_SUBSECTIONS.on" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEBUGGING_MODEL.1572892809" name="Debugging model" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEBUGGING_MODEL" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEBUGGING_MODEL.SYMDEBUG__DWARF" valueType="enumerated"/>
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WARNING.1185956654" name="Treat diagnostic &lt;id&gt; as warning (--diag_warning, -pdsw)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WARNING" useByScannerDiscovery="false" valueType="stringList">
<listOptionValue builtIn="false" value="225"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DISPLAY_ERROR_NUMBER.660145174" name="Emit diagnostic identifier numbers (--display_error_number, -pden)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DISPLAY_ERROR_NUMBER" useByScannerDiscovery="false" value="true" valueType="boolean"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WRAP.1639153444" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WRAP" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WRAP.off" valueType="enumerated"/>
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.INCLUDE_PATH.935863231" name="Add dir to #include search path (--include_path, -I)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.INCLUDE_PATH" valueType="includePath">
<listOptionValue builtIn="false" value="${CG_TOOL_ROOT}/include"/>
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INSTALL_DIR}/driverlib/f2838x/driverlib_cm"/>
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INSTALL_DIR}/libraries/communications/usb/f2838x/include"/>
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INSTALL_DIR}/libraries/communications/usb/f2838x/include/device"/>
<listOptionValue builtIn="false" value="${PROJECT_ROOT}/include"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.LITTLE_ENDIAN.473231484" name="Little endian code [See 'General' page to edit] (--little_endian, -me)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.LITTLE_ENDIAN" useByScannerDiscovery="false" value="true" valueType="boolean"/>
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEFINE.1960491440" name="Pre-define NAME (--define, -D)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEFINE" valueType="definedSymbols">
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_SYMBOLS}"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.C_DIALECT.783059765" name="C Dialect" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.C_DIALECT" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.C_DIALECT.C11" valueType="enumerated"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__C_SRCS.65491363" name="C Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__C_SRCS"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__CPP_SRCS.737872717" name="C++ Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__CPP_SRCS"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM_SRCS.2056613617" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM_SRCS"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM2_SRCS.274557246" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM2_SRCS"/>
</tool>
<tool id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.librarianDebug.1344322407" name="Arm Archiver" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.librarianDebug">
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.OUTPUT_FILE.91858401" name="Output file" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.OUTPUT_FILE" useByScannerDiscovery="false" value="efc_usb_cm.lib" valueType="string"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.VERBOSE.298175100" name="Verbose (v)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.VERBOSE" value="true" valueType="boolean"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.PRINT_GLOBAL_SYMBOLS.202221361" name="Print symbol table contents (s)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.PRINT_GLOBAL_SYMBOLS" value="false" valueType="boolean"/>
</tool>
</toolChain>
</folderInfo>
</configuration>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
</cconfiguration>
<cconfiguration id="com.ti.ccstudio.buildDefinitions.TMS470.Release.165659480">
<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.ti.ccstudio.buildDefinitions.TMS470.Release.165659480" moduleId="org.eclipse.cdt.core.settings" name="Release">
<externalSettings/>
<extensions>
<extension id="com.ti.ccstudio.binaryparser.CoffParser" point="org.eclipse.cdt.core.BinaryParser"/>
<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="com.ti.ccstudio.errorparser.CoffErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="com.ti.ccstudio.errorparser.AsmErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="com.ti.ccstudio.errorparser.LinkErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
</extensions>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<configuration artifactExtension="lib" artifactName="efc_usb_cm" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.TMS470.Release.165659480" name="Release" parent="com.ti.ccstudio.buildDefinitions.TMS470.Release">
<folderInfo id="com.ti.ccstudio.buildDefinitions.TMS470.Release.165659480." name="/" resourcePath="">
<toolChain id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.ReleaseToolchain.1226097760" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.ReleaseToolchain" targetTool="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.librarianRelease.2062298442">
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.849892926" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
<listOptionValue builtIn="false" value="DEVICE_CONFIGURATION_ID=Cortex M.TMS320F28388D"/>
<listOptionValue builtIn="false" value="DEVICE_CORE_ID="/>
<listOptionValue builtIn="false" value="DEVICE_ENDIANNESS=little"/>
<listOptionValue builtIn="false" value="OUTPUT_FORMAT=ELF"/>
<listOptionValue builtIn="false" value="CCS_MBS_VERSION=6.1.3"/>
<listOptionValue builtIn="false" value="OUTPUT_TYPE=staticLibrary"/>
<listOptionValue builtIn="false" value="PRODUCTS=c2000ware_software_package:5.0.0.00;"/>
<listOptionValue builtIn="false" value="PRODUCT_MACRO_IMPORTS={&quot;c2000ware_software_package&quot;:[&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INCLUDE_PATH}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_LIBRARY_PATH}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_LIBRARIES}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_SYMBOLS}&quot;,&quot;${COM_TI_C2000WARE_SOFTWARE_PACKAGE_SYSCONFIG_MANIFEST}&quot;]}"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.1369294733" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="20.2.7.LTS" valueType="string"/>
<targetPlatform id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.targetPlatformRelease.779956611" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.targetPlatformRelease"/>
<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.builderRelease.1735718130" keepEnvironmentInBuildfile="false" name="GNU Make" parallelBuildOn="true" parallelizationNumber="optimal" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.builderRelease"/>
<tool id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.compilerRelease.929526181" name="Arm Compiler" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.compilerRelease">
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.SILICON_VERSION.730543322" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.SILICON_VERSION" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.SILICON_VERSION.7M4" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.CODE_STATE.2024874105" name="Designate code state, 16-bit (thumb) or 32-bit (--code_state)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.CODE_STATE" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.CODE_STATE.16" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.FLOAT_SUPPORT.1704554860" name="Specify floating point support (--float_support)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.FLOAT_SUPPORT" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.FLOAT_SUPPORT.none" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.GEN_FUNC_SUBSECTIONS.1006534814" name="Place each function in a separate subsection (--gen_func_subsections, -ms)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.GEN_FUNC_SUBSECTIONS" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.GEN_FUNC_SUBSECTIONS.on" valueType="enumerated"/>
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WARNING.1008443671" name="Treat diagnostic &lt;id&gt; as warning (--diag_warning, -pdsw)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WARNING" useByScannerDiscovery="false" valueType="stringList">
<listOptionValue builtIn="false" value="225"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DISPLAY_ERROR_NUMBER.589679653" name="Emit diagnostic identifier numbers (--display_error_number, -pden)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DISPLAY_ERROR_NUMBER" useByScannerDiscovery="false" value="true" valueType="boolean"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WRAP.1288084194" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WRAP" useByScannerDiscovery="false" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DIAG_WRAP.off" valueType="enumerated"/>
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.INCLUDE_PATH.1189118873" name="Add dir to #include search path (--include_path, -I)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.INCLUDE_PATH" valueType="includePath">
<listOptionValue builtIn="false" value="${CG_TOOL_ROOT}/include"/>
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INSTALL_DIR}/driverlib/f2838x/driverlib_cm"/>
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INSTALL_DIR}/libraries/communications/usb/f2838x/include"/>
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_INSTALL_DIR}/libraries/communications/usb/f2838x/include/device"/>
<listOptionValue builtIn="false" value="${PROJECT_ROOT}/include"/>
<listOptionValue builtIn="false" value="${PROJECT_ROOT}/include/service"/>
<listOptionValue builtIn="false" value="${PROJECT_ROOT}/include/loader"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.LITTLE_ENDIAN.1104602926" name="Little endian code [See 'General' page to edit] (--little_endian, -me)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.LITTLE_ENDIAN" useByScannerDiscovery="false" value="true" valueType="boolean"/>
<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEFINE.1119485452" name="Pre-define NAME (--define, -D)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.DEFINE" valueType="definedSymbols">
<listOptionValue builtIn="false" value="${COM_TI_C2000WARE_SOFTWARE_PACKAGE_SYMBOLS}"/>
</option>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.OPT_FOR_SPEED.1575451921" name="Speed vs. size trade-offs (--opt_for_speed, -mf)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.OPT_FOR_SPEED" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.OPT_FOR_SPEED.2" valueType="enumerated"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.C_DIALECT.1225272476" name="C Dialect" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.C_DIALECT" value="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compilerID.C_DIALECT.C11" valueType="enumerated"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__C_SRCS.684624469" name="C Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__C_SRCS"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__CPP_SRCS.710172533" name="C++ Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__CPP_SRCS"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM_SRCS.1304228572" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM_SRCS"/>
<inputType id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM2_SRCS.1951790416" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.compiler.inputType__ASM2_SRCS"/>
</tool>
<tool id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.librarianRelease.2062298442" name="Arm Archiver" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.library.librarianRelease">
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.OUTPUT_FILE.778339118" name="Output file" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.OUTPUT_FILE" useByScannerDiscovery="false" value="efc_usb_cm.lib" valueType="string"/>
<option id="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.VERBOSE.1366045598" name="Verbose (v)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_20.2.archiverID.VERBOSE" value="true" valueType="boolean"/>
</tool>
</toolChain>
</folderInfo>
</configuration>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
</cconfiguration>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<project id="EFC_UsbDriver.com.ti.ccstudio.buildDefinitions.TMS470.ProjectType.1460968617" name="TMS470" projectType="com.ti.ccstudio.buildDefinitions.TMS470.ProjectType"/>
</storageModule>
<storageModule moduleId="refreshScope" versionNumber="2">
<configuration configurationName="Debug">
<resource resourceType="PROJECT" workspacePath="/EFC_UsbDriver"/>
</configuration>
<configuration configurationName="Release">
<resource resourceType="PROJECT" workspacePath="/EFC_UsbDriver"/>
</configuration>
</storageModule>
<storageModule moduleId="scannerConfiguration"/>
<storageModule moduleId="org.eclipse.cdt.make.core.buildtargets"/>
</cproject>

8
Projects/EFC_UsbDriver/.gitignore vendored Normal file
View File

@ -0,0 +1,8 @@
/Debug/
/Release/
/doc/*
!/doc/.placeholder
/.settings/

27
Projects/EFC_UsbDriver/.project Normal file
View File

@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>EFC_UsbDriver</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
<triggers>full,incremental,</triggers>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>com.ti.ccstudio.core.ccsNature</nature>
<nature>org.eclipse.cdt.core.cnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
<nature>org.eclipse.cdt.core.ccnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
</natures>
</projectDescription>

2815
Projects/EFC_UsbDriver/Doxyfile Normal file
View File

File diff suppressed because it is too large Load Diff

0
Projects/EFC_UsbDriver/doc/.placeholder Normal file
View File

97
Projects/EFC_UsbDriver/include/efc_usb.h Normal file
View File

@ -0,0 +1,97 @@
/*
* efc_usb.h
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#ifndef INCLUDE_EFC_USB_H_
#define INCLUDE_EFC_USB_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
#include <efc_usb/status.h>
#include <efc_usb/service.h>
#include <efc_usb/loader.h>
/**
* @defgroup Api API
*
* @{
*/
/**
* @defgroup CommonApi Общий API
*
* @{
*/
/** @brief Тип конфигурации USB драйвера */
enum efc_usb_config_type {
/** Конфигурация драйвера для работы в сервисном режиме */
EFC_USB_CONFIG_SV = 0x01,
/** Конфигурация драйвера для работы в режиме загрузчика */
EFC_USB_CONFIG_LD = 0x02,
};
/**
* @brief Описание взаимодействия с пользователем драйвера
*
* Структура содержит параметры и пользовательские обратные вызовы
* для обеспечения взаимодействия с пользовательской программой
*
* Структура должна быть проинициализирована до вызова функции @ref efc_usb_init
*
* Если какая либо конфигуарция не испоьзуется, соответствующее
* поле должно быть задано @c NULL
*/
struct efc_usb_config {
/** Конфигурация драйвера для работы в сервисном режиме */
const struct efc_usb_sv_config* sv;
const struct efc_usb_ld_config* ld;
};
/**
* @brief Инициализация USB драйвера
*
* Вызов функции инициализации должен предшествовать всем оставльным функциям драйвера
*
* @param enable_config Флаги используемых конфигураций, объединённых через побитовое ИЛИ
* @param current_config Флаг текущей конфигураций
*
* @return @c true при успешной инициализации; иначе @c false
*/
bool efc_usb_init(uint8_t enable_config, uint8_t current_config, const struct efc_usb_config* config);
/**
* @brief Денициализация USB драйвера
*
* После вызова драйвера обращения к его функциям запрещено
*
* @return @c void
*/
void efc_usb_fini();
/**
* @brief Обработчик прерываний USB драйвера
*
* Обработчик должен быть зарегистрирован на прерывание от используемого модуля USB
*
* @return void
*/
void efc_usb_int_handler();
/** @} */ /* CommonApi */
/** @} */ /* Api */
#ifdef __cplusplus
}
#endif
#endif /* INCLUDE_EFC_USB_H_ */

132
Projects/EFC_UsbDriver/include/efc_usb/loader.h Normal file
View File

@ -0,0 +1,132 @@
/*
* loader.h
*
* Created on: 14 Sep 2023
*/
#ifndef INCLUDE_EFC_USB_LOADER_H_
#define INCLUDE_EFC_USB_LOADER_H_
#include <efc_usb/status.h>
/** @brief Пакет командного интерфейса */
struct /** @cond */ __attribute__((__packed__)) /** @endcond */
efc_usb_ld_cmd_packet {
union {
struct {
/** Размер данных в поле @c data */
uint16_t size : 16;
} bits;
uint32_t all;
} header; /**< Заголовок пакета */
/** Поле данных пакета (аргументы для Rx пакета или результаты для Tx пакета) */
uint8_t* data;
};
/**
* @brief Метод чтения FIFO последнего входящего командного пакета
*
* Метод производит прямое чтение принятых данных из аппаратного FIFO буфера USB модуля.
*
* @param buffer Буфер, в который будут записаны данные входящего пакета
* @param buffer_max_size Размер буфера
* @param received_data_size Вернет количество полученных байт
* @param data_size_avail Количество байт, которое остались непрочитанным в пакете
*
* @return @c true при успешном чтении; @c false при следующих случаях: @n
* - @c NULL аргумент;
* - Данные в буфере невалидны (принят или принимается новый пакет);
* - Драйвер не инциализирован или находится не в рабочем состоянии.
*
* @warning Операция чтения очищает FIFO буфер, повторное чтение тех же данных не возможно.
*/
efc_usb_status_t efc_usb_ld_data_recv(uint8_t* buffer, size_t buffer_max_size, size_t* received_data_size, size_t* data_size_avail);
/**
* @brief Метод записи командного пакета в FIFO буфер передатчика
*
* Метод позволяет поставить запрос на отправку командного пакета.
* При очередном IN запросе от хоста данные будут отправлены и будет возможно
* оставить новый запрос на отправку.
*
* @param tx_packet Буфер, в котором находятся данные исходящего пакета
*
* @return @c true при успешном выполнении; @c false при следующих случаях: @n
* - @c NULL аргумент;
* - Буфер драйвера еще занят;
* - Драйвер не инциализирован или находится не в рабочем состоянии.
*/
efc_usb_status_t efc_usb_ld_data_send(const uint8_t* header, size_t header_size, const uint8_t* data, size_t data_size);
/**
* @brief Обработчик сброса, инициированного хостом
*
* Вызывается после выполнения процедуры сброса состояния конфигурации дарайвера. @n
* - Буферы приёмника/передатчика считаются невалидными
* - Драйвер переводится в рабочее состояние
* - Обработка командного интерфейса включёна
*
* @param param Пользовательский параметр, передаваемый при вызове со стороны драйвера
*
* @return void
*
* @note Вызов производится из контекста обработчика прерывания
*/
typedef void (*efc_usb_ld_reset_handle_t) (void* param);
/**
* @brief Обработчик входящих командных пакетов
*
* Вызывается @b после получения и буферизации в FIFO @n
*
* В рамках обратного вызова пользователю необходимо считать буфер, используя функцию @ref efc_usb_sv_cmd_read,
* иначе данные могут быть перезаписаны асинхронно следующим входящим пакетом.
*
* @param param Пользовательский параметр, передаваемый при вызове со стороны драйвера
*
* @return void
*
* @note Вызов производится из контекста обработчика прерывания
*/
typedef void (*efc_usb_ld_cmd_rx_handle_t) (void* param);
/**
* @brief Обработчик исходящих командных пакетов
*
* Вызывается @b до буферизации в FIFO и отправки пакета @n
*
* По готовности данные могут быть записаны в буфер передатчика @ref efc_usb_sv_cmd_write.
*
* @param param Пользовательский параметр, передаваемый при вызове со стороны драйвера
*
* @return void
*
* @note Вызов производится из контекста обработчика прерывания
*/
typedef void (*efc_usb_ld_cmd_tx_handle_t) (void* param);
/** @brief Параметры командного интерфейса */
struct efc_usb_ld_cmd_config {
/** Обратный вызов приёмника командных пакетов */
efc_usb_ld_cmd_rx_handle_t rx_handle;
/** Параметр приёмника командных пакетов */
void* rx_handle_param;
/** Обратный вызов передатчика командных пакетов */
efc_usb_ld_cmd_tx_handle_t tx_handle;
/** Параметр передатчика командных пакетов */
void* tx_handle_param;
};
/** @brief Параметры конфигурации usb загрузчика */
struct efc_usb_ld_config {
/** Параметры командного интерфейса */
struct efc_usb_ld_cmd_config cmd;
/** Обратный вызов события сброса */
efc_usb_ld_reset_handle_t reset_handle;
/** Параметр обратного вызова события сброса */
void* reset_handle_param;
};
#endif /* INCLUDE_EFC_USB_LOADER_H_ */

206
Projects/EFC_UsbDriver/include/efc_usb/service.h Normal file
View File

@ -0,0 +1,206 @@
/*
* service.h
*
* Created on: 25 Aug 2023
* Author: malyarenko
*/
#ifndef EFC_USB_SERVICE_H_
#define EFC_USB_SERVICE_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <efc_usb/status.h>
/**
* @addtogroup Api
*
* @{
*/
/**
* @defgroup ServiceApi API сервисного обмена
*
* @{
*/
/**
* @defgroup ServiceCmdApi API командного интерфейса
*
* @{
*/
/** @brief Максимальный размер пакета данных командного интерфейса */
#define EFC_USB_SV_CMD_PACKET_SIZE_MAX ((size_t) 256) // Обязан быть 2^N байтов
/** @brief Размер заголовка пакета командного интерфейса */
#define EFC_USB_SV_CMD_PACKET_HEADER_SIZE ((size_t) sizeof(uint32_t))
/** @brief Размер поля данных пакета командного интерфейса */
#define EFC_USB_SV_CMD_PACKET_DATA_SIZE_MAX ((size_t) (EFC_USB_SV_CMD_PACKET_SIZE_MAX - EFC_USB_SV_CMD_PACKET_HEADER_SIZE))
/** @brief Заголовок пакета командного интерфейса */
union efc_usb_sv_cmd_header {
struct {
/** Размер данных */
uint32_t size : 8;
/** Идентификатор команды */
uint32_t id : 16;
/** Зарезервированное поле */
uint32_t reserved : 4;
/** Идентификатор логического канала */
uint32_t channel_id : 4;
} bits;
uint32_t all;
};
/** @brief Идентификатор канала ошибки */
#define EFC_USB_SV_CMD_ERR_CHANNEL ((uint32_t) 0xFF)
/** @brief Заголовок общей ошибки */
#define EFC_USB_SV_CMD_ERR_HEADER \
(union efc_usb_sv_cmd_header) { \
.bits = { \
.channel_id = EFC_USB_SV_CMD_ERR_CHANNEL, \
.id = 0xFFFFU, \
.size = 0, \
} \
}
/**
* @brief Тип обработчика событий командных пакетов
*
* Обработчики данного типа предоставляются пользователем драйвера и вызываются
* при событиях запроса на приём и передачу командного пакета.
*
* Условия вызова:
* - Для **Rx** обработчик вызывается **после** получения пакета и буферизации в FIFO
* - Для **Tx** обработчик вызывается **до** буферизации в FIFO и отправки пакета
*
* @param param Пользовательский параметр, передаваемый при вызове со стороны драйвера
*
* @return void
*
* @note Вызов производится из контекста обработчика прерывания
*/
typedef void (*efc_usb_sv_cmd_handle_t) (void* param);
/**
* @brief Тип селектора буфера командного пакета
*
* Предикат данного типа предоставляется пользвателем драйвера для определения
* адреса буфера приёмника/передатчика с целью прямого копирования в FIFO модуля USB
*
* @param cpu_id Индекс ЦПУ из возможных значений @ref efc_usb_sv_cmd_header.bits.cpu_id
* @param param Пользовательский параметр, передаваемый при вызове со стороны драйвера
*
* @return Указатель на необходимый буфер; `NULL` в случае ошибки
*/
typedef uint8_t* (*efc_usb_sv_cmd_buffer_selector_t) (uint32_t cpu_id, void* param);
/** @brief Параметры командного интерфейса */
struct efc_usb_sv_cmd_config {
/** Обратный вызов приёмника командных пакетов */
efc_usb_sv_cmd_handle_t rx_handle;
/** Обратный вызов селектора буфера приёмника */
efc_usb_sv_cmd_buffer_selector_t rx_buffer_selector;
/** Параметр приёмника командных пакетов */
void* rx_param;
/** Обратный вызов передатчика командных пакетов */
efc_usb_sv_cmd_handle_t tx_handle;
/** Обратный вызов селектора буфера приёмника */
efc_usb_sv_cmd_buffer_selector_t tx_buffer_selector;
/** Параметр передатчика командных пакетов */
void* tx_param;
};
/**
* @brief Метод отправки командного пакета
*
* Функция реализует синхронный метод отправки командного пакета. @n
*
* В стандартном случае, метод вызывается в обработчике IN запроса от хоста.
* На основании предоставленного заголовка и метода селектора буфера, данные пакета
* выгружаются в FIFO модуля USB и далее отправка планируется аппаратно. @n
*
* @note Если пользовательский метод селектора буфера возвращает `NULL` во время выполнения
* операции, то запись данных не производится и метод возвращает признак ошибки.
*
* @param[in] header Заголовок командного пакета с заполненными полями
*
* @return Статус выполнения операции #efc_usb_status
*/
efc_usb_status_t efc_usb_sv_cmd_send(union efc_usb_sv_cmd_header* header);
/**
* @brief Метод приёма командного пакета
*
* Функция реализует синхронный метод приёма командного пакета. @n
*
* В стандартном случае, метод вызывается в обработчике OUT запроса от хоста.
* На основании принятого заголовка и метода селектора буфера, данные пакета
* выгружаются из FIFO модуля в предоставленную структуру заголовок и выбранный буфер. @n
*
* @note Если пользовательский метод селектора буфера возвращает `NULL` во время выполнения
* операции, то чтение не производится, данные считаются утерянными и метод возвращает признак ошибки.
*
* @param[out] header Буфер заголовка командного пакета
*
* @return Статус выполнения операции #efc_usb_status
*/
efc_usb_status_t efc_usb_sv_cmd_recv(union efc_usb_sv_cmd_header* header);
/** @} */ /* ServiceCmdApi */
/**
* @brief Тип обратного вызова к драйверу о переводе в начальное состояние
*
* Данный обработчик вывзывается со стороны пользователя после запроса на сброс от драйвера
* после всех необходимых процедур перевода в начальное состояние
*
* @return void
*/
typedef void (*efc_usb_sv_reset_ack_t) ();
/**
* @brief Обработчик сброса, инициированного хостом
*
* Вызывается после выполнения процедуры сброса состояния конфигурации дарайвера. @n
* - Буферы приёмника/передатчика считаются невалидными
* - Драйвер переводится в рабочее состояние
* - Обработка командный интерфейса включёна
* - Обработка потокового интерфейса выключена
*
* @param ack Обратный вызов уведомления о выполненном сбросе пользовательской части драйвера
* @param param Пользовательский параметр, передаваемый при вызове со стороны драйвера
*
* @return void
*
* @note Вызов производится из контекста обработчика прерывания
*/
typedef void (*efc_usb_sv_reset_handle_t) (efc_usb_sv_reset_ack_t ack, void* param);
/** @brief Параметры конфигурации сервисного обмена */
struct efc_usb_sv_config {
/** Параметры командного интерфейса */
struct efc_usb_sv_cmd_config cmd;
/** Обратный вызов события сброса */
efc_usb_sv_reset_handle_t reset_handle;
/** Параметр обратного вызова события сброса */
void* reset_handle_param;
};
/** @} */ /* ServiceApi */
/** @} */ /* Api */
#ifdef __cplusplus
}
#endif
#endif /* EFC_USB_SERVICE_H_ */

48
Projects/EFC_UsbDriver/include/efc_usb/status.h Normal file
View File

@ -0,0 +1,48 @@
/*
* status.h
*
* Created on: 28 Oct 2023
* Author: malyarenko
*/
#ifndef INCLUDE_EFC_USB_STATUS_H_
#define INCLUDE_EFC_USB_STATUS_H_
/**
* @addtogroup Api
*
* @{
*/
/**
* @addtogroup CommonApi
*
* @{
*/
/** @brief Статус операций USB драйвера */
enum efc_usb_status {
/** Успешное выполнение операции */
EFC_USB_OK = 0,
/** Обобщённая ошибка */
EFC_USB_ERR = -1,
/** Некорректные входные данные */
EFC_USB_EARG = -2,
/** Операция в данный момент недоступна */
EFC_USB_EBUSY = -3,
/** Операция не может быть выполнена в текущем состоянии */
EFC_USB_ENOOP = -4,
/** Обнаружен некорректный формат данных */
EFC_USB_EFORMAT = -5,
/** Ошибка логического канала */
EFC_USB_ECHANNEL = -6,
};
typedef enum efc_usb_status efc_usb_status_t;
/** @} */ /* CommonApi */
/** @} */ /* Api */
#endif /* INCLUDE_EFC_USB_STATUS_H_ */

112
Projects/EFC_UsbDriver/src/device.c Normal file
View File

@ -0,0 +1,112 @@
/*
* efc_usb.c
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include <usbdevice.h>
#include <efc_usb.h>
#include "loader/ld_device.h"
#include "service/sv_device.h"
#include "device_desc.h"
#include "device.h"
/** Статический экземпляр дескриптора устройства */
static struct efc_usb_device_handler device_handler;
bool device_validate_config(uint8_t enable_config, uint8_t current_config, const struct efc_usb_config* config) {
if (config == NULL) return false;
if ((enable_config & current_config) == 0) return false;
const bool is_valid_enable_config = 0
|| (enable_config & (uint8_t) EFC_USB_CONFIG_SV)
|| (enable_config & (uint8_t) EFC_USB_CONFIG_LD);
const bool is_valid_current_config = 0
|| (current_config == (uint8_t) EFC_USB_CONFIG_SV)
|| (current_config == (uint8_t) EFC_USB_CONFIG_LD);
if (!is_valid_enable_config || !is_valid_current_config) return false;
if (enable_config & (uint8_t) EFC_USB_CONFIG_SV) {
if (!sv_device_validate_config(config->sv)) return false;
}
if (enable_config & (uint8_t) EFC_USB_CONFIG_LD) {
// TODO Валидация параметров конфигурации
}
return true;
}
bool efc_usb_init(uint8_t enable_config, uint8_t current_config, const struct efc_usb_config* config) {
if (config == NULL) return false;
/* Для смены конфигурации драйвера его необходимо деинициализировать */
if (device_handler.initialized) return false;
/* Валидация активированных и текущей конфигураций */
if (!device_validate_config(enable_config, current_config, config)) return false;
/* Инициализация включенных конфигураций конфигурации */
{
device_handler.current_config = current_config;
device_handler.enabled_config = enable_config;
if (device_handler.enabled_config & EFC_USB_CONFIG_SV) {
const bool status = sv_device_init(&device_handler.config_handler.sv, config->sv);
if (!status) { efc_usb_fini(); return false; }
}
if (device_handler.enabled_config & EFC_USB_CONFIG_LD) {
const bool status = ld_device_init(&device_handler.config_handler.ld, config->ld);
if (!status) { efc_usb_fini(); return false; }
}
}
/* Режим работы Device без функции OTG */
USBStackModeSet(0, eUSBModeForceDevice, NULL);
/* Инициализация USB стека */
USBDCDInit(0, &EFC_USB_DEVICE_INFO, (void*) &device_handler);
device_handler.initialized = true;
return true;
}
void efc_usb_fini() {
if (!device_handler.initialized) return;
device_handler.initialized = false;
/* Деактивация выбранной конфигурации */
{
if (device_handler.enabled_config & EFC_USB_CONFIG_SV) {
sv_device_fini(&device_handler.config_handler.sv);
}
if (device_handler.enabled_config & EFC_USB_CONFIG_LD) {
ld_device_fini(&device_handler.config_handler.ld);
}
}
/* Деактивация стека */
USBDCDTerm(0);
}
void efc_usb_int_handler() {
USB0DeviceIntHandler();
}

33
Projects/EFC_UsbDriver/src/device.h Normal file
View File

@ -0,0 +1,33 @@
/*
* device.h
*
* Created on: 28 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_DEVICE_H_
#define SRC_DEVICE_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "service/sv_device.h"
#include "loader/ld_device.h"
/** Дескриптор устройства на уровне приложения */
struct efc_usb_device_handler {
uint8_t current_config : 4; /**< Текущая конфигурация */
uint8_t enabled_config : 4; /**< Битовое поле включённых конфигуарций */
bool initialized; /**< Признак готовности драйвера */
struct {
struct sv_device sv; /**< Дескриптор конфигурации сервисного обмена */
struct ld_device ld; /**< Дескриптор конфигурации загрузчика */
} config_handler; /**< Дескриптор конфигурации */
};
bool device_validate_config(uint8_t enable_config, uint8_t current_config, const struct efc_usb_config* config);
#endif /* SRC_DEVICE_H_ */

128
Projects/EFC_UsbDriver/src/device_desc.c Normal file
View File

@ -0,0 +1,128 @@
/*
* descriptors.c
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include <usbdevice.h>
#include "device_handle.h"
#include "device_desc.h"
#include "loader/ld_device_desc.h"
#include "service/sv_device_desc.h"
const uint8_t EFC_USB_LANG_DESCRIPTOR[] = {
4,
USB_DTYPE_STRING,
USBShort(USB_LANG_EN_US),
};
const uint8_t EFC_USB_MANUFACTURER_STRING[] = {
2 + (7 * 2),
USB_DTYPE_STRING,
'D', 0, 'i', 0, 'a', 0, 'k', 0, 'o', 0, 'n', 0, 't', 0,
};
const uint8_t EFC_USB_PRODUCT_STRING[] = {
2 + (21 * 2),
USB_DTYPE_STRING,
'E', 0, 'F', 0, 'C', 0, ' ', 0,
'(', 0,
'D', 0, 'D', 0, 'I', 0, 'A', 0, '.', 0,
'6', 0, '5', 0, '6', 0, '1', 0, '2', 0, '1', 0, '.', 0,
'0', 0, '0', 0, '6', 0,
')', 0,
};
const uint8_t EFC_USB_SERIAL_NUMBER_STRING[] = {
2 + (4 * 2),
USB_DTYPE_STRING,
'0', 0, '0', 0, '0', 0, '1', 0,
};
/**
* @ingroup EfcUsbDeviceInfo
* @brief Стандартный дескриптор USB устройства
*/
static const uint8_t EFC_USB_DEVICE_DESCRIPTOR[] = {
18, /* bLength */
USB_DTYPE_DEVICE, /* bDescriptorType */
USBShort(0x0110), /* bcdUSB */ /* USB 1.1 для активации FS режима */
USB_CLASS_VEND_SPECIFIC, /* bDeviceClass */
USB_SUBCLASS_UNDEFINED, /* bDeviceSubClass */
USB_PROTOCOL_UNDEFINED, /* bDeviceProtocol */
64, /* bMaxPacketSize0 */
USBShort(EFC_USB_VENDOR_ID), /* idVendor */
USBShort(EFC_USB_PRODUCT_ID), /* idProduct */
USBShort(EFC_USB_DEVICE_RELEASE), /* bcdDevice */
EFC_USB_MANUFACTURER_STRING_ID, /* iManufacturer */
EFC_USB_PRODUCT_STRING_ID, /* idProduct */
EFC_USB_SERIAL_NUMBER_STRING_ID, /* iSerialNumber */
EFC_USB_CONFIG_NUM, /* bNumConfigurations */
};
/**
* @ingroup EfcUsbDeviceInfo
* @brief Массив заголовков дескриторов конфигуарций
*/
static const tConfigHeader* const EFC_USB_CONFIG_DESCRIPTORS[] = {
&EFC_USB_SV_CONFIG_HEADER,
&EFC_USB_LD_CONFIG_HEADER,
};
/**
* @ingroup EfcUsbDeviceInfo
* @brief Стандартный блок строковых дескрипторов
*/
const uint8_t* const EFC_USB_STRING_DESCRIPTORS[] = {
EFC_USB_LANG_DESCRIPTOR,
EFC_USB_MANUFACTURER_STRING,
EFC_USB_PRODUCT_STRING,
EFC_USB_SERIAL_NUMBER_STRING,
EFC_USB_SV_CONFIG_STRING,
EFC_USB_SV_INTERFACE_CMD_STRING,
EFC_USB_SV_INTERFACE_STR_STRING,
EFC_USB_LD_CONFIG_STRING,
EFC_USB_LD_INTERFACE_STRING,
};
#define EFC_USB_STRING_DESCRIPTORS_NUM (sizeof(EFC_USB_STRING_DESCRIPTORS) / sizeof(EFC_USB_STRING_DESCRIPTORS[0]))
/**
* @ingroup EfcUsbDeviceInfo
* @brief Обратные вызовы обработки событий
*/
static const tCustomHandlers EFC_USB_HANDLERS = (tCustomHandlers) {
.pfnResetHandler = efc_usb_device_handle_reset,
.pfnSuspendHandler = efc_usb_device_handle_suspend,
.pfnResumeHandler = efc_usb_device_handle_resume,
.pfnDisconnectHandler = efc_usb_device_handle_disconnect,
.pfnConfigChange = efc_usb_device_handle_config_change,
.pfnGetDescriptor = efc_usb_device_handle_descriptor,
.pfnRequestHandler = efc_usb_device_handle_request,
.pfnInterfaceChange = NULL,
.pfnDataReceived = NULL,
.pfnDataSent = NULL,
.pfnEndpointHandler = efc_usb_device_handle_ep,
.pfnDeviceHandler = efc_usb_device_handle,
};
/**
* @ingroup EfcUsbDeviceInfo
* @brief Статический корневой дескриптор устройства
*/
tDeviceInfo EFC_USB_DEVICE_INFO = (tDeviceInfo) {
.psCallbacks = &EFC_USB_HANDLERS,
.pui8DeviceDescriptor = EFC_USB_DEVICE_DESCRIPTOR,
.ppsConfigDescriptors = EFC_USB_CONFIG_DESCRIPTORS,
.ppui8StringDescriptors = EFC_USB_STRING_DESCRIPTORS,
.ui32NumStringDescriptors = EFC_USB_STRING_DESCRIPTORS_NUM,
};

93
Projects/EFC_UsbDriver/src/device_desc.h Normal file
View File

@ -0,0 +1,93 @@
/*
* device_desc.h
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_DEVICE_DESC_H_
#define SRC_DEVICE_DESC_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
/**
* @defgroup EfcUsbDeviceInfo Идентификаторы USB устройства
*
* @{
*/
/** @brief Идентификатор производителя */
#define EFC_USB_VENDOR_ID ((uint16_t) 0x0D1A)
/** @brief Идентификатор изделия */
#define EFC_USB_PRODUCT_ID ((uint16_t) 0x0001)
/** @brief Идентификатор верси изделия */
#define EFC_USB_DEVICE_RELEASE ((uint16_t) 0x0001)
/** @brief Количество конфигураций устройства */
#define EFC_USB_CONFIG_NUM ((uint8_t) 0x02)
/** @brief Идентификатор конфигуарции устройства */
enum efc_usb_config_id {
/** Конфигурация сервисного обмена */
EFC_USB_SV_CONFIG_ID = 1,
/** Конфигурация загрузчика */
EFC_USB_LD_CONFIG_ID = 2,
};
extern struct tDeviceInfo EFC_USB_DEVICE_INFO;
/**
* @defgroup EfcUsbStringDesc Строковые дескрипторы USB устройства
*
* @{
*/
/** @brief #0 Язык строковых дескипторов */
extern const uint8_t EFC_USB_LANG_DESCRIPTOR[];
/** @brief #1 Название производителя */
extern const uint8_t EFC_USB_MANUFACTURER_STRING[];
/** @brief #2 Название изделия */
extern const uint8_t EFC_USB_PRODUCT_STRING[];
/** @brief #3 Серийный номер */
extern const uint8_t EFC_USB_SERIAL_NUMBER_STRING[];
/** @brief #4 Название конфигурации сервисного обмена */
extern const uint8_t EFC_USB_SV_CONFIG_STRING[];
/** @brief #5 Название интерфейса сервисного обмена (управление) */
extern const uint8_t EFC_USB_SV_INTERFACE_CMD_STRING[];
/** @brief #6 Название интерфейса сервисного обмена (потоковые данные) */
extern const uint8_t EFC_USB_SV_INTERFACE_STR_STRING[];
/** @brief #7 Название конфигуарции загрузчика */
extern const uint8_t EFC_USB_LD_CONFIG_STRING[];
/** @brief #8 Название интерфейса загрузчика */
extern const uint8_t EFC_USB_LD_INTERFACE_STRING[];
/** @brief Идентификатор строкового дескриптора */
enum efc_usb_device_string_id {
EFC_USB_LANG_DESCRIPTOR_ID,
EFC_USB_MANUFACTURER_STRING_ID,
EFC_USB_PRODUCT_STRING_ID,
EFC_USB_SERIAL_NUMBER_STRING_ID,
EFC_USB_SV_CONFIG_STRING_ID,
EFC_USB_SV_INTERFACE_CMD_STRING_ID,
EFC_USB_SV_INTERFACE_STR_STRING_ID,
EFC_USB_LD_CONFIG_STRING_ID,
EFC_USB_LD_INTERFACE_STRING_ID,
};
/** @} */ /* EfcUsbStringDesc */
/** @} */ /* EfcUsbDeviceInfo */
#endif /* SRC_DEVICE_DESC_H_ */

139
Projects/EFC_UsbDriver/src/device_handle.c Normal file
View File

@ -0,0 +1,139 @@
/*
* device_handle.c
*
* Created on: 25 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include <usbdevice.h>
#include <efc_usb.h>
#include "service/sv_device_handle.h"
#include "loader/ld_device_handle.h"
#include "device.h"
#include "device_desc.h"
#include "device_handle.h"
struct {
uint32_t reset;
uint32_t suspend;
uint32_t resume;
uint32_t disconnect;
uint32_t config;
uint32_t descriptor;
uint32_t request;
uint32_t ep;
uint32_t device;
} debug_handler_count = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
void efc_usb_device_handle_reset(void* instance) {
debug_handler_count.reset += 1;
if (instance == NULL) return;
struct efc_usb_device_handler* const device_handler = instance;
if (device_handler->current_config & EFC_USB_CONFIG_SV) {
sv_device_handle_reset(&device_handler->config_handler.sv);
return;
}
if (device_handler->current_config & EFC_USB_CONFIG_LD) {
ld_device_handle_reset(&device_handler->config_handler.ld);
return;
}
}
void efc_usb_device_handle_suspend(void* instance) {
debug_handler_count.suspend += 1;
}
void efc_usb_device_handle_resume(void* instance) {
debug_handler_count.resume += 1;
}
void efc_usb_device_handle_disconnect(void* instance) {
debug_handler_count.disconnect += 1;
if (instance == NULL) return;
struct efc_usb_device_handler* const device_handler = instance;
if (device_handler->current_config == EFC_USB_CONFIG_SV) {
sv_device_handle_disconnect(&device_handler->config_handler.sv);
return;
}
if (device_handler->current_config & EFC_USB_CONFIG_LD) {
device_handler->config_handler.ld.flags.connected = false;
return;
}
}
void efc_usb_device_handle_config_change(void* instance, uint32_t info) {
debug_handler_count.config += 1;
if (instance == NULL) return;
struct efc_usb_device_handler* const device_handler = instance;
/* Получить и обработать идентификатор новой конфигурации */
{
const uint8_t new_config_id = (info & 0x0FU);
const uint8_t new_config = (uint8_t) 0x01U << (new_config_id - 1);
/* Некорректный идентификатор конфигурации */
if ((new_config_id == 0) || (new_config_id > EFC_USB_CONFIG_NUM)) return;
/* Выбранная конфигуарция не была включена при инициализации */
if ((new_config & device_handler->enabled_config) == 0) return;
}
if (device_handler->current_config == EFC_USB_CONFIG_SV) {
// TODO ld_device_handle_config_disbale(&device_handler->config_handler.ld);
sv_device_handle_config_enable(&device_handler->config_handler.sv);
return;
}
if (device_handler->current_config & EFC_USB_CONFIG_LD) {
sv_device_handle_config_disable(&device_handler->config_handler.sv);
ld_device_handle_config_change(&device_handler->config_handler.ld, info);
device_handler->config_handler.ld.flags.connected = true;
return;
}
}
void efc_usb_device_handle_descriptor(void* instance, tUSBRequest* request) {
debug_handler_count.descriptor += 1;
if (instance == NULL) return;
}
void efc_usb_device_handle_request(void* instance, tUSBRequest* request) {
debug_handler_count.request += 1;
if (instance == NULL) return;
}
void efc_usb_device_handle_ep(void* instance, uint32_t status) {
debug_handler_count.ep += 1;
if (instance == NULL) return;
struct efc_usb_device_handler* const device_handler = instance;
if (device_handler->current_config == EFC_USB_CONFIG_SV) {
sv_device_handle_ep(&device_handler->config_handler.sv, status);
return;
}
if (device_handler->current_config & EFC_USB_CONFIG_LD) {
ld_device_handle_ep(&device_handler->config_handler.ld, status);
return;
}
}
void efc_usb_device_handle(void* instance, uint32_t request, void* data) {
debug_handler_count.device += 1;
if (instance == NULL) return;
}

46
Projects/EFC_UsbDriver/src/device_handle.h Normal file
View File

@ -0,0 +1,46 @@
/*
* device_handle.h
*
* Created on: 25 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_DEVICE_HANDLE_H_
#define SRC_DEVICE_HANDLE_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include <usbdevice.h>
/* Обработчики прерываний */
void efc_usb_device_handle_reset(void* instance);
void efc_usb_device_handle_suspend(void* instance);
void efc_usb_device_handle_resume(void* instance);
void efc_usb_device_handle_disconnect(void* instance);
/* Обработчики событий измненения информации о устройстве */
void efc_usb_device_handle_config_change(void* instance, uint32_t info);
/* Обработчики нестандартных запросов */
void efc_usb_device_handle_descriptor(void* instance, tUSBRequest* request);
void efc_usb_device_handle_request(void* instance, tUSBRequest* request);
/* Обработчик событий на EP */
void efc_usb_device_handle_ep(void* instance, uint32_t status);
/* Базовый пользовательский обработчик */
void efc_usb_device_handle(void* instance, uint32_t request, void* data);
#endif /* SRC_DEVICE_HANDLE_H_ */

162
Projects/EFC_UsbDriver/src/loader/ld_device.c Normal file
View File

@ -0,0 +1,162 @@
/*
* ld_device.c
*
* Created on: 22 авг. 2023 г.
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <sysctl.h>
#include <usb.h>
#include <usblib.h>
#include <usbdevice.h>
#include "../device_desc.h"
#include "ld_device_desc.h"
#include "ld_device.h"
static struct ld_device* ld_device_handler = NULL;
static const size_t MAX_PACKAGE_SIZE = 64;
static inline bool ld_device_cmd_init(struct ld_device* handler, const struct efc_usb_ld_config* config) {
if ((handler == NULL) || (config == NULL)) return false;
handler->cmd.rx_handle = config->cmd.rx_handle;
handler->cmd.rx_handle_param = config->cmd.rx_handle_param;
atomic_flag_test_and_set(&handler->cmd.rx_lock);
handler->cmd.tx_handle = config->cmd.tx_handle;
handler->cmd.tx_handle_param = config->cmd.tx_handle_param;
atomic_flag_clear(&handler->cmd.tx_lock);
// if (!ld_cmd_dma_init(handler)) return false;
return true;
}
bool ld_device_init(struct ld_device* device_handler, const struct efc_usb_ld_config* config) {
if ((device_handler == NULL) || (config == NULL)) return false;
// TODO: валидация
//if (!ld_device_validate_config(config)) return false;
device_handler->usb_base = USB_BASE;
device_handler->flags.connected = false;
device_handler->flags.cmd_active = true;
device_handler->reset_handle = config->reset_handle;
device_handler->reset_handle_param = config->reset_handle_param;
/* Командный интерфейс */
if (!ld_device_cmd_init(device_handler, config)) return false;
ld_device_handler = device_handler;
return true;
}
void ld_device_fini(struct ld_device* device_handler) {
if (device_handler == NULL) return;
USBDCDTerm(0);
device_handler->usb_base = 0;
ld_device_handler = NULL;
}
efc_usb_status_t efc_usb_ld_data_recv(uint8_t* buffer, size_t buffer_max_size, size_t* received_data_size, size_t* data_size_avail){
const uint32_t ep_id = IndexToUSBEP(EFC_USB_LD_EP1_O_ADDR);
/* Проверка параметров вызова */
if (NULL == buffer){
return EFC_USB_EARG;
}
/* Проверка состояния драйвера */
struct ld_device* const handler = ld_device_handler;
if ((handler == NULL) || !handler->flags.connected || !handler->flags.cmd_active){
return EFC_USB_ENOOP;
}
/* Проверка статуса EP */
const uint32_t ep_status = USBEndpointStatus(handler->usb_base, ep_id);
if ((ep_status & USB_DEV_RX_PKT_RDY) == 0){
return EFC_USB_EBUSY;
}
/* Защита от повторного чтения
const bool is_locked = atomic_flag_test_and_set(&handler->cmd.rx_lock);
if (is_locked){
return EFC_USB_EBUSY;
}
*/
USBEndpointDataGet(handler->usb_base, ep_id, buffer, &buffer_max_size);
*received_data_size = buffer_max_size;
*data_size_avail = USBEndpointDataAvail(handler->usb_base, ep_id);
if(0 == *data_size_avail){
USBDevEndpointDataAck(handler->usb_base, ep_id, true);
}
return EFC_USB_OK;
}
efc_usb_status_t efc_usb_ld_data_send(const uint8_t* header, size_t header_size, const uint8_t* data, size_t data_size){
const uint32_t ep_id = IndexToUSBEP(EFC_USB_LD_EP1_I_ADDR);
// Проверка параметров вызова
if (NULL == data && 0 < data_size){
return EFC_USB_EARG;
}
// Проверка состояния драйвера
struct ld_device* const handler = ld_device_handler;
if ((handler == NULL) || !handler->flags.connected || !handler->flags.cmd_active){
return EFC_USB_ENOOP;
}
// Проверка статуса EP
const uint32_t ep_status = USBEndpointStatus(handler->usb_base, ep_id);
if ((ep_status & USB_DEV_TX_TXPKTRDY) != 0){
return EFC_USB_EBUSY;
}
uint32_t status = USBEndpointDataPut(handler->usb_base, ep_id, header, header_size);
const uint16_t DATA_MAX_SIZE = MAX_PACKAGE_SIZE;
uint16_t sending_data_bytes = 0;
do{
// Если размер данных больше максимального размера USB буфера, то в конце нам нужно записать меньшее количество байт.
uint16_t send_bytes_count = data_size + header_size - sending_data_bytes < DATA_MAX_SIZE
? data_size + header_size - sending_data_bytes
: DATA_MAX_SIZE;
if(0 < send_bytes_count){
// Добавляем данные
const uint8_t* data_sent = data + sending_data_bytes;
status = USBEndpointDataPut(handler->usb_base, ep_id, data_sent, send_bytes_count - header_size);
}
status = USBEndpointDataSend(handler->usb_base, ep_id, USB_TRANS_IN);
uint32_t send_status = USBEndpointStatus(handler->usb_base, ep_id);
while((send_status & USB_DEV_TX_FIFO_NE) != 0){
send_status = USBEndpointStatus(handler->usb_base, ep_id);
}
if(0 != status){
return EFC_USB_ERR;
}
// Заголовок отправляется только один раз.
sending_data_bytes += send_bytes_count - header_size;
header_size = 0;
} while(sending_data_bytes < data_size);
return EFC_USB_OK;
}

48
Projects/EFC_UsbDriver/src/loader/ld_device.h Normal file
View File

@ -0,0 +1,48 @@
/*
* ld_device.h
*
* Created on: 22 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_LOADER_LD_DEVICE_H_
#define SRC_LOADER_LD_DEVICE_H_
#include <stdatomic.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include <usbdevice.h>
#include <efc_usb/loader.h>
struct ld_device {
uint32_t usb_base;
/* Флаги состояния */
struct {
uint8_t connected : 1;
uint8_t cmd_active : 1;
} flags;
/* Командный интерфейс */
struct {
efc_usb_ld_cmd_rx_handle_t rx_handle;
void* rx_handle_param;
atomic_flag rx_lock;
efc_usb_ld_cmd_tx_handle_t tx_handle;
void* tx_handle_param;
atomic_flag tx_lock;
} cmd;
efc_usb_ld_reset_handle_t reset_handle;
void* reset_handle_param;
};
bool ld_device_init(struct ld_device* device_handler, const struct efc_usb_ld_config* config);
void ld_device_fini(struct ld_device* device_handler);
#endif /* SRC_LOADER_LD_DEVICE_H_ */

96
Projects/EFC_UsbDriver/src/loader/ld_device_desc.c Normal file
View File

@ -0,0 +1,96 @@
/*
* ld_config_desc.c
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include <usbdevice.h>
#include "../device_desc.h"
#include "ld_device_desc.h"
#define EFC_USB_LD_EP1_I_ADDR_BM (EFC_USB_LD_EP1_I_ADDR & 0x0FU)
#define EFC_USB_LD_EP1_O_ADDR_BM (EFC_USB_LD_EP1_O_ADDR & 0x0FU)
#define EFC_USB_LD_CONFIG_SIZE (9 + (9 * EFC_USB_LD_INREFACE_NUM) + (7 * EFC_USB_LD_EP_NUM))
const uint8_t EFC_USB_LD_CONFIG_STRING[] = {
2 + (20 * 2),
USB_DTYPE_STRING,
'L', 0, 'o', 0, 'a', 0, 'd', 0, 'e', 0, 'r', 0, ' ', 0,
'C', 0, 'o', 0, 'n', 0, 'f', 0, 'i', 0, 'g', 0, 'u', 0, 'r', 0, 'a', 0, 't', 0, 'i', 0, 'o', 0, 'n', 0,
};
const uint8_t EFC_USB_LD_INTERFACE_STRING[] = {
2 + (16 * 2),
USB_DTYPE_STRING,
'L', 0, 'o', 0, 'a', 0, 'd', 0, 'e', 0, 'r', 0, ' ', 0,
'I', 0, 'n', 0, 't', 0, 'e', 0, 'r', 0, 'f', 0, 'a', 0, 'c', 0, 'e', 0,
};
static const uint8_t EFC_USB_LD_CONFIG_MAIN_DESCRIPTOR[] = {
9, /* bLength */
USB_DTYPE_CONFIGURATION, /* bDescriptorType */
USBShort(EFC_USB_LD_CONFIG_SIZE), /* wTotalLength */
EFC_USB_LD_INREFACE_NUM, /* bNumInterfaces */
EFC_USB_LD_CONFIG_ID, /* bConfigurationValue */
EFC_USB_LD_CONFIG_STRING_ID, /* iConfiguration */
USB_CONF_ATTR_SELF_PWR, /* bmAttributes */ /* TODO Перейти на внешнее питание */
250, /* bMaxPower */ /* 250 * 2 мА = 500 мА */
};
static const uint8_t EFC_USB_LD_CONFIG_DATA_DESCRIPTOR[] = {
/* INTERFACE */
9, /* bLength */
USB_DTYPE_INTERFACE, /* bDescriptorType */
0, /* bInterfaceNumber */
0, /* bAlternateSetting */
2, /* bNumEndpoints */
USB_CLASS_VEND_SPECIFIC, /* bInterfaceClass */
USB_SUBCLASS_UNDEFINED, /* bInterfaceSubClass */
USB_PROTOCOL_UNDEFINED, /* bInterfaceProtocol */
EFC_USB_LD_INTERFACE_STRING_ID, /* iInterface */
/* INTERFACE - EP1 I */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_IN | EFC_USB_LD_EP1_I_ADDR_BM, /* bEndpointAddress */
USB_EP_ATTR_BULK, /* bmAttributes */
USBShort(EFC_USB_LD_EP1_I_SIZE), /* wMaxPacketSize */
0, /* bInterval */
/* INTERFACE - EP1 O */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_OUT | EFC_USB_LD_EP1_O_ADDR_BM, /* bEndpointAddress */
USB_EP_ATTR_BULK, /* bmAttributes */
USBShort(EFC_USB_LD_EP1_O_SIZE), /* wMaxPacketSize */
0, /* bInterval */
};
static const tConfigSection EFC_USB_LD_CONFIG_MAIN_SECTION = (tConfigSection) {
.ui16Size = sizeof(EFC_USB_LD_CONFIG_MAIN_DESCRIPTOR),
.pui8Data = EFC_USB_LD_CONFIG_MAIN_DESCRIPTOR,
};
static const tConfigSection EFC_USB_LD_CONFIG_DATA_SECTION = (tConfigSection) {
.ui16Size = sizeof(EFC_USB_LD_CONFIG_DATA_DESCRIPTOR),
.pui8Data = EFC_USB_LD_CONFIG_DATA_DESCRIPTOR,
};
static const tConfigSection* EFC_USB_LD_CONFIG_SECTIONS[] = {
&EFC_USB_LD_CONFIG_MAIN_SECTION,
&EFC_USB_LD_CONFIG_DATA_SECTION,
};
const tConfigHeader EFC_USB_LD_CONFIG_HEADER = (tConfigHeader) {
.ui8NumSections = sizeof(EFC_USB_LD_CONFIG_SECTIONS) / sizeof(EFC_USB_LD_CONFIG_SECTIONS[0]),
.psSections = EFC_USB_LD_CONFIG_SECTIONS,
};

25
Projects/EFC_UsbDriver/src/loader/ld_device_desc.h Normal file
View File

@ -0,0 +1,25 @@
/*
* ld_config_desc.h
*
* Created on: 21 авг. 2023 г.
* Author: malyarenko
*/
#ifndef SRC_LOADER_LD_DEVICE_DESC_H_
#define SRC_LOADER_LD_DEVICE_DESC_H_
#include <stdint.h>
#define EFC_USB_LD_INREFACE_NUM ((uint8_t) 1)
#define EFC_USB_LD_EP_NUM ((uint8_t) 1)
#define EFC_USB_LD_EP1_I_ADDR ((uint8_t) 1)
#define EFC_USB_LD_EP1_I_SIZE ((uint16_t) 1024)
#define EFC_USB_LD_EP1_O_ADDR ((uint8_t) 1)
#define EFC_USB_LD_EP1_O_SIZE ((uint16_t) 1024)
extern const tConfigHeader EFC_USB_LD_CONFIG_HEADER;
#endif /* SRC_LOADER_LD_DEVICE_DESC_H_ */

68
Projects/EFC_UsbDriver/src/loader/ld_device_handle.c Normal file
View File

@ -0,0 +1,68 @@
/*
* ld_device_handler.c
*
* Created on: 14 Sep 2023
* Author: malyarenko
*/
#include <stdint.h>
#include <stdbool.h>
#include <strings.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <usblib.h>
#include <usbdevice.h>
#include <usb.h>
#include <interrupt.h>
#include <efc_usb/loader.h>
#include "ld_device_desc.h"
#include "ld_device_handle.h"
#define LD_CMD_EP_I_INT_MASK ((uint32_t) 0x00000001 << EFC_USB_LD_EP1_I_ADDR)
#define LD_CMD_EP_O_INT_MASK ((uint32_t) 0x00010000 << EFC_USB_LD_EP1_O_ADDR)
inline void ld_device_handle_reset(struct ld_device* handler) {
if (handler == NULL){
return;
}
handler->flags.connected = false;
handler->flags.cmd_active = true;
USBFIFOFlush(handler->usb_base, IndexToUSBEP(EFC_USB_LD_EP1_I_ADDR), USB_EP_DEV_IN);
atomic_flag_clear(&handler->cmd.tx_lock);
USBFIFOFlush(handler->usb_base, IndexToUSBEP(EFC_USB_LD_EP1_O_ADDR), USB_EP_DEV_OUT);
USBDevEndpointDataAck(handler->usb_base, IndexToUSBEP(EFC_USB_LD_EP1_O_ADDR), true);
atomic_flag_test_and_set(&handler->cmd.rx_lock);
if (handler->reset_handle != NULL) {
handler->reset_handle(handler->reset_handle_param);
}
}
inline void ld_device_handle_config_change(struct ld_device* handler, uint32_t info) {
}
inline void ld_device_handle_ep(struct ld_device* handler, uint32_t status) {
if (status & LD_CMD_EP_I_INT_MASK) {
atomic_flag_clear(&handler->cmd.tx_lock);
if (handler->cmd.tx_handle != NULL) {
handler->cmd.tx_handle(handler->cmd.tx_handle_param);
}
}
if (status & LD_CMD_EP_O_INT_MASK) {
atomic_flag_clear(&handler->cmd.rx_lock);
if (handler->cmd.rx_handle != NULL) {
handler->cmd.rx_handle(handler->cmd.rx_handle_param);
}
}
}

23
Projects/EFC_UsbDriver/src/loader/ld_device_handle.h Normal file
View File

@ -0,0 +1,23 @@
/*
* ld_device_handler.h
*
* Created on: 14 Sep 2023
* Author: malyarenko
*/
#ifndef SRC_LOADER_LD_DEVICE_HANDLE_H_
#define SRC_LOADER_LD_DEVICE_HANDLE_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "ld_device.h"
inline void ld_device_handle_reset(struct ld_device* handle);
inline void ld_device_handle_config_change(struct ld_device* handle, uint32_t info);
inline void ld_device_handle_ep(struct ld_device* handle, uint32_t status);
#endif /* SRC_LOADER_LD_DEVICE_HANDLE_H_ */

220
Projects/EFC_UsbDriver/src/service/sv_device.c Normal file
View File

@ -0,0 +1,220 @@
/*
* sv_device.c
*
* Created on: 22 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdatomic.h>
#include <assert.h>
#include <usblib.h>
#include <usbdevice.h>
#include <sysctl.h>
#include <usb.h>
#include <efc_usb.h>
#include "sv_device_desc.h"
#include "sv_device_dma.h"
#include "sv_device.h"
static struct sv_device* sv_device_handler = NULL;
bool sv_device_validate_config(const struct efc_usb_sv_config* config) {
assert(config != NULL);
const bool is_sv_valid = true
&& (config->reset_handle != NULL);
const bool is_sv_cmd_valid = true
&& (config->cmd.rx_handle != NULL)
&& (config->cmd.rx_buffer_selector != NULL)
&& (config->cmd.tx_handle != NULL)
&& (config->cmd.tx_buffer_selector != NULL);
return is_sv_valid && is_sv_cmd_valid;
}
bool sv_device_init(struct sv_device* handler, const struct efc_usb_sv_config* config) {
if ((handler == NULL) || (config == NULL)) return false;
if (!sv_device_validate_config(config)) return false;
/* Установка общих полей дескриптора устройства */
{
handler->usb_base = USB_BASE;
handler->flags.initialized = false;
handler->flags.connected = false;
handler->flags.enabled = false;
handler->reset_handle = config->reset_handle;
handler->reset_handle_param = config->reset_handle_param;
}
/* Командный интерфейс */
if (!sv_device_cmd_init(handler, config)) { sv_device_fini(handler); return false; };
/* Инициализация завершена */
sv_device_handler = handler;
handler->flags.initialized = true;
return true;
}
void sv_device_fini(struct sv_device* handler) {
assert(handler != NULL);
handler->flags.enabled = false;
handler->flags.connected = false;
handler->flags.initialized = false;
sv_device_handler = NULL;
// TODO Процедура закрытия конфигурации
}
bool sv_device_cmd_init(struct sv_device* handler, const struct efc_usb_sv_config* config) {
if ((handler == NULL) || (config == NULL)) return false;
handler->cmd.rx_handle = config->cmd.rx_handle;
handler->cmd.rx_param = config->cmd.rx_param;
handler->cmd.rx_buffer_selector = config->cmd.rx_buffer_selector;
atomic_flag_test_and_set(&handler->cmd.rx_lock);
handler->cmd.tx_handle = config->cmd.tx_handle;
handler->cmd.tx_param = config->cmd.tx_param;
handler->cmd.tx_buffer_selector = config->cmd.tx_buffer_selector;
atomic_flag_clear(&handler->cmd.tx_lock);
return true;
}
void sv_device_cmd_fini(struct sv_device* handler) {
// TODO Процедура закрытия конфигурации
}
efc_usb_status_t efc_usb_sv_cmd_send(union efc_usb_sv_cmd_header* header) {
const uint32_t ep_id = IndexToUSBEP(EFC_USB_SV_CMD_EP_I_ADDR);
/* Проверка параметров вызова */
if (header == NULL) return EFC_USB_EARG;
/* Проверка состояния драйвера */
struct sv_device* const handler = sv_device_handler;
if (!handler->flags.initialized
|| !handler->flags.connected
|| !handler->flags.enabled)
{
return EFC_USB_ENOOP;
}
/* Проверка статуса EP */
const uint32_t ep_status = USBEndpointStatus(handler->usb_base, ep_id);
if ((ep_status & USB_DEV_TX_TXPKTRDY) != 0) return EFC_USB_EBUSY;
/* Получение и проверка буфера данных */
uint8_t* buffer = NULL;
if (header->bits.channel_id != EFC_USB_SV_CMD_ERR_CHANNEL) {
buffer = handler->cmd.tx_buffer_selector(header->bits.channel_id, handler->cmd.tx_param);
if (buffer == NULL) return EFC_USB_ECHANNEL;
}
/* Защита от перезаписи */
const bool is_locked = atomic_flag_test_and_set(&handler->cmd.tx_lock);
if (is_locked) return EFC_USB_EBUSY;
/* Заголовок пакета */
{
uint8_t* data = (uint8_t*) &header->all;
uint32_t size = EFC_USB_SV_CMD_PACKET_HEADER_SIZE;
USBEndpointDataPut(handler->usb_base, ep_id, data, size);
}
/* Данные пакета */
{
uint8_t* data = (uint8_t*) buffer;
uint32_t size = header->bits.size;
USBEndpointDataPut(handler->usb_base, ep_id, data, size);
}
USBEndpointDataSend(handler->usb_base, ep_id, USB_TRANS_IN);
return EFC_USB_OK;
}
efc_usb_status_t efc_usb_sv_cmd_recv(union efc_usb_sv_cmd_header* header) {
const uint32_t ep_id = IndexToUSBEP(EFC_USB_SV_CMD_EP_O_ADDR);
/* Проверка параметров вызова */
if (header == NULL) return EFC_USB_EARG;
/* Проверка состояния драйвера */
struct sv_device* const handler = sv_device_handler;
if (!handler->flags.initialized
|| !handler->flags.connected
|| !handler->flags.enabled)
{
return EFC_USB_ENOOP;
}
/* Проверка статуса EP */
const uint32_t ep_status = USBEndpointStatus(handler->usb_base, ep_id);
if ((ep_status & USB_DEV_RX_PKT_RDY) == 0) return EFC_USB_EBUSY;
/* Защита от повторного чтения */
const bool is_locked = atomic_flag_test_and_set(&handler->cmd.rx_lock);
if (is_locked) return EFC_USB_EBUSY;
/* Заголовок пакета */
{
const uint32_t data_size_avail = USBEndpointDataAvail(handler->usb_base, ep_id);
if (data_size_avail < EFC_USB_SV_CMD_PACKET_HEADER_SIZE) {
USBFIFOFlush(handler->usb_base, ep_id, USB_EP_HOST_OUT);
return EFC_USB_EFORMAT;
}
uint8_t* data = (uint8_t*) &header->all;
uint32_t size = EFC_USB_SV_CMD_PACKET_HEADER_SIZE;
USBEndpointDataGet(handler->usb_base, ep_id, data, &size);
}
/* Данные пакета */
{
uint8_t* const buffer = handler->cmd.rx_buffer_selector(header->bits.channel_id, handler->cmd.rx_param);
if (buffer == NULL) {
USBFIFOFlush(handler->usb_base, ep_id, USB_EP_HOST_OUT);
return EFC_USB_ECHANNEL;
}
const uint32_t data_size_avail = USBEndpointDataAvail(handler->usb_base, ep_id);
if (data_size_avail < header->bits.size) {
USBFIFOFlush(handler->usb_base, ep_id, USB_EP_HOST_OUT);
return EFC_USB_EFORMAT;
}
uint8_t* data = buffer;
uint32_t size = header->bits.size;
USBEndpointDataGet(handler->usb_base, ep_id, data, &size);
}
USBDevEndpointDataAck(handler->usb_base, ep_id, true);
return EFC_USB_OK;
}

59
Projects/EFC_UsbDriver/src/service/sv_device.h Normal file
View File

@ -0,0 +1,59 @@
/*
* sv_device.h
*
* Created on: 22 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_SERVICE_SV_DEVICE_H_
#define SRC_SERVICE_SV_DEVICE_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdatomic.h>
#include <usblib.h>
#include <usbdevice.h>
#include <efc_usb/service.h>
struct sv_device {
uint32_t usb_base;
/* Флаги состояния */
struct {
bool initialized;
bool connected;
bool enabled;
} flags;
/* Командный интерфейс */
struct {
efc_usb_sv_cmd_handle_t rx_handle;
efc_usb_sv_cmd_buffer_selector_t rx_buffer_selector;
void* rx_param;
atomic_flag rx_lock;
efc_usb_sv_cmd_handle_t tx_handle;
efc_usb_sv_cmd_buffer_selector_t tx_buffer_selector;
void* tx_param;
atomic_flag tx_lock;
} cmd;
/* Управление сбросом */
efc_usb_sv_reset_handle_t reset_handle;
void* reset_handle_param;
};
bool sv_device_validate_config(const struct efc_usb_sv_config* config);
bool sv_device_init(struct sv_device* handler, const struct efc_usb_sv_config* config);
void sv_device_fini(struct sv_device* handler);
bool sv_device_cmd_init(struct sv_device* handler, const struct efc_usb_sv_config* config);
void sv_device_cmd_fini(struct sv_device* handler);
#endif /* SRC_SERVICE_SV_DEVICE_H_ */

142
Projects/EFC_UsbDriver/src/service/sv_device_desc.c Normal file
View File

@ -0,0 +1,142 @@
/*
* sv_config_desc.c
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usblib.h>
#include "../device_desc.h"
#include "sv_device_desc.h"
#define EFC_USB_SV_CMD_EP_I_BM (EFC_USB_SV_CMD_EP_I_ADDR & 0x0FU)
#define EFC_USB_SV_CMD_EP_O_BM (EFC_USB_SV_CMD_EP_O_ADDR & 0x0FU)
#define EFC_USB_SV_OSC_EP_I_BM (EFC_USB_SV_OSC_EP_I_ADDR & 0x0FU)
#define EFC_USB_SV_STR_EP_I_BM (EFC_USB_SV_STR_EP_I_ADDR & 0x0FU)
#define EFC_USB_SV_STR_EP_O_BM (EFC_USB_SV_STR_EP_O_ADDR & 0x0FU)
#define EFC_USB_SV_CONFIG_SIZE (9 + (9 * EFC_USB_SV_INREFACE_NUM) + (7 * EFC_USB_SV_EP_NUM))
const uint8_t EFC_USB_SV_CONFIG_STRING[] = {
2 + (11 * 2),
USB_DTYPE_STRING,
'S', 0, 'e', 0, 'r', 0, 'v', 0, 'i', 0, 'c', 0, 'e', 0, ' ', 0,
'C', 0, 'f', 0, 'g', 0,
};
const uint8_t EFC_USB_SV_INTERFACE_CMD_STRING[] = {
2 + (12 * 2),
USB_DTYPE_STRING,
'C', 0, 'o', 0, 'm', 0, 'm', 0, 'a', 0, 'n', 0, 'd', 0, ' ', 0,
'I', 0, 'n', 0, 't', 0, 'f', 0,
};
const uint8_t EFC_USB_SV_INTERFACE_STR_STRING[] = {
2 + (14 * 2),
USB_DTYPE_STRING,
'S', 0, 't', 0, 'r', 0, 'e', 0, 'a', 0, 'm', 0, 'i', 0, 'n', 0, 'g', 0, ' ', 0,
'I', 0, 'n', 0, 't', 0, 'f', 0,
};
static const uint8_t EFC_USB_SV_CONFIG_MAIN_DESCRIPTOR[] = {
9, /* bLength */
USB_DTYPE_CONFIGURATION, /* bDescriptorType */
USBShort(EFC_USB_SV_CONFIG_SIZE), /* wTotalLength */
2, /* bNumInterfaces */
EFC_USB_SV_CONFIG_ID, /* bConfigurationValue */
EFC_USB_SV_CONFIG_STRING_ID, /* iConfiguration */
USB_CONF_ATTR_SELF_PWR, /* bmAttributes */
250, /* bMaxPower */ /* 250 * 2 мА = 500 мА */
};
static const uint8_t EFC_USB_SV_CONFIG_DATA_DESCRIPTOR[] = {
/* INTERFACE CMD ---------------------------------------------------*/
9, /* bLength */
USB_DTYPE_INTERFACE, /* bDescriptorType */
EFC_USB_SV_INREFACE_CMD, /* bInterfaceNumber */
0, /* bAlternateSetting */
3, /* bNumEndpoints */
USB_CLASS_VEND_SPECIFIC, /* bInterfaceClass */
USB_SUBCLASS_UNDEFINED, /* bInterfaceSubClass */
USB_PROTOCOL_UNDEFINED, /* bInterfaceProtocol */
EFC_USB_SV_INTERFACE_CMD_STRING_ID, /* iInterface */
/* INTERFACE CMD - EP1 I */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_IN | EFC_USB_SV_CMD_EP_I_BM, /* bEndpointAddress */
USB_EP_ATTR_BULK, /* bmAttributes */
USBShort(EFC_USB_SV_CMD_EP_I_SIZE), /* wMaxPacketSize */
0, /* bInterval */
/* INTERFACE CMD - EP1 O */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_OUT | EFC_USB_SV_CMD_EP_O_BM, /* bEndpointAddress */
USB_EP_ATTR_BULK, /* bmAttributes */
USBShort(EFC_USB_SV_CMD_EP_O_SIZE), /* wMaxPacketSize */
0, /* bInterval */
/* INTERFACE CMD - EP2 I */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_IN | EFC_USB_SV_OSC_EP_I_BM, /* bEndpointAddress */
USB_EP_ATTR_BULK, /* bmAttributes */
USBShort(EFC_USB_SV_OSC_EP_I_SIZE), /* wMaxPacketSize */
0, /* bInterval */
/* INTERFACE STR ---------------------------------------------------*/
9, /* bLength */
USB_DTYPE_INTERFACE, /* bDescriptorType */
EFC_USB_SV_INREFACE_STR, /* bInterfaceNumber */
0, /* bAlternateSetting */
2, /* bNumEndpoints */
USB_CLASS_VEND_SPECIFIC, /* bInterfaceClass */
USB_SUBCLASS_UNDEFINED, /* bInterfaceSubClass */
USB_PROTOCOL_UNDEFINED, /* bInterfaceProtocol */
EFC_USB_SV_INTERFACE_STR_STRING_ID, /* iInterface */
/* INTERFACE STR - EP3 I */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_IN | EFC_USB_SV_STR_EP_I_BM, /* bEndpointAddress */
USB_EP_ATTR_ISOC, /* bmAttributes */
USBShort(EFC_USB_SV_STR_EP_I_SIZE), /* wMaxPacketSize */
0, /* bInterval */
/* INTERFACE STR - EP3 O */
7, /* bLength */
USB_DTYPE_ENDPOINT, /* bDescriptorType */
USB_EP_DESC_OUT | EFC_USB_SV_STR_EP_O_BM, /* bEndpointAddress */
USB_EP_ATTR_BULK, /* bmAttributes */
USBShort(EFC_USB_SV_STR_EP_O_SIZE), /* wMaxPacketSize */
0,
};
static const tConfigSection EFC_USB_SV_CONFIG_MAIN_SECTION = (tConfigSection) {
.ui16Size = sizeof(EFC_USB_SV_CONFIG_MAIN_DESCRIPTOR),
.pui8Data = EFC_USB_SV_CONFIG_MAIN_DESCRIPTOR,
};
static const tConfigSection EFC_USB_SV_CONFIG_DATA_SECTION = (tConfigSection) {
.ui16Size = sizeof(EFC_USB_SV_CONFIG_DATA_DESCRIPTOR),
.pui8Data = EFC_USB_SV_CONFIG_DATA_DESCRIPTOR,
};
static const tConfigSection* EFC_USB_SV_CONFIG_SECTIONS[] = {
&EFC_USB_SV_CONFIG_MAIN_SECTION,
&EFC_USB_SV_CONFIG_DATA_SECTION,
};
const tConfigHeader EFC_USB_SV_CONFIG_HEADER = (tConfigHeader) {
.ui8NumSections = sizeof(EFC_USB_SV_CONFIG_SECTIONS) / sizeof(EFC_USB_SV_CONFIG_SECTIONS[0]),
.psSections = EFC_USB_SV_CONFIG_SECTIONS,
};

46
Projects/EFC_UsbDriver/src/service/sv_device_desc.h Normal file
View File

@ -0,0 +1,46 @@
/*
* sv_desc.h
*
* Created on: 21 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_SERVICE_SV_DEVICE_DESC_H_
#define SRC_SERVICE_SV_DEVICE_DESC_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <efc_usb/service.h>
#define EFC_USB_SV_INREFACE_NUM ((uint8_t) 2)
#define EFC_USB_SV_EP_NUM ((uint8_t) 5)
/** Индентификатор интерфеса сервисного обмена */
enum efc_usb_sv_interface_id {
/** Командный интерфейс (Command Interface) */
EFC_USB_SV_INREFACE_CMD,
/** Потоковый интерфейс (Streaming Interface) */
EFC_USB_SV_INREFACE_STR,
};
#define EFC_USB_SV_CMD_EP_I_ADDR ((uint8_t) 1)
#define EFC_USB_SV_CMD_EP_I_SIZE ((uint16_t) EFC_USB_SV_CMD_PACKET_SIZE_MAX)
#define EFC_USB_SV_CMD_EP_O_ADDR ((uint8_t) 1)
#define EFC_USB_SV_CMD_EP_O_SIZE ((uint16_t) EFC_USB_SV_CMD_PACKET_SIZE_MAX)
#define EFC_USB_SV_OSC_EP_I_ADDR ((uint8_t) 2)
#define EFC_USB_SV_OSC_EP_I_SIZE ((uint16_t) 1024)
#define EFC_USB_SV_STR_EP_I_ADDR ((uint8_t) 3)
#define EFC_USB_SV_STR_EP_I_SIZE ((uint16_t) 16)
#define EFC_USB_SV_STR_EP_O_ADDR ((uint8_t) 3)
#define EFC_USB_SV_STR_EP_O_SIZE ((uint16_t) 16)
extern const tConfigHeader EFC_USB_SV_CONFIG_HEADER;
#endif /* SRC_SERVICE_SV_DEVICE_DESC_H_ */

59
Projects/EFC_UsbDriver/src/service/sv_device_dma.c Normal file
View File

@ -0,0 +1,59 @@
/*
* sv_dma.c
*
* Created on: 25 Aug 2023
* Author: malyarenko
*/
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <usb.h>
#include <udma.h>
#include <efc_usb/service.h>
#include "sv_device.h"
#include "sv_device_dma.h"
/* DMA командного интерфейса */
#define SV_CMD_EP_I_DMA_TASKS_NUM 0
#define SV_CMD_EP_I_DMA_TRANSFER_SIZE 0
#define SV_CMD_EP_O_DMA_TASKS_NUM 0
#define SV_CMD_EP_O_DMA_TRANSFER_SIZE 0
static inline void sv_dma_cmd_init(struct sv_device* handler);
/* DMA потокового интерфейса */
#define SV_STR_EP_I_DMA_TASKS_NUM 1
#define SV_STR_EP_I_DMA_TRANSFER_SIZE 1 // FIXME
#define SV_STR_EP_O_DMA_TASKS_NUM 1
#define SV_STR_EP_O_DMA_TRANSFER_SIZE 1 // FIXME
static inline void sv_dma_str_init(struct sv_device* handler);
bool sv_dma_init(struct sv_device* handler) {
if (handler == NULL) return false;
sv_dma_cmd_init(handler);
sv_dma_str_init(handler);
return true;
}
void sv_dma_fini(struct sv_device* handler) {
// UDMA_disableChannel(UDMA_BASE, handler->cmd_interface.ep_o_dma_channel);
}
static inline void sv_dma_cmd_init(struct sv_device* handler) {
// TODO
}
static inline void sv_dma_str_init(struct sv_device* handler) {
// TODO
}

21
Projects/EFC_UsbDriver/src/service/sv_device_dma.h Normal file
View File

@ -0,0 +1,21 @@
/*
* sv_dma.h
*
* Created on: 25 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_SERVICE_SV_DEVICE_DMA_H_
#define SRC_SERVICE_SV_DEVICE_DMA_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "sv_device.h"
bool sv_dma_init(struct sv_device* handler);
void sv_dma_fini(struct sv_device* handler);
#endif /* SRC_SERVICE_SV_DEVICE_DMA_H_ */

107
Projects/EFC_UsbDriver/src/service/sv_device_handle.c Normal file
View File

@ -0,0 +1,107 @@
/*
* sv_device_handle.c
*
* Created on: 28 Aug 2023
* Author: malyarenko
*/
#include <stdint.h>
#include <stdbool.h>
#include <strings.h>
#include <stdatomic.h>
#include <assert.h>
#include <usblib.h>
#include <usbdevice.h>
#include <usb.h>
#include <interrupt.h>
#include <efc_usb/service.h>
#include "sv_device_desc.h"
#include "sv_device_handle.h"
#include "sv_device.h"
#define SV_CMD_EP_I_INT_MASK ((uint32_t) 0x00000001 << EFC_USB_SV_CMD_EP_I_ADDR)
#define SV_CMD_EP_O_INT_MASK ((uint32_t) 0x00010000 << EFC_USB_SV_CMD_EP_O_ADDR)
static void* reset_ack_param = NULL;
static void reset_ack();
inline void sv_device_handle_reset(struct sv_device* handler) {
assert(handler != NULL);
handler->flags.connected = false;
/* Останов командного интерфейса */
{
USBDevEndpointStall(USB_BASE, IndexToUSBEP(EFC_USB_SV_CMD_EP_I_ADDR), USB_EP_HOST_IN);
USBDevEndpointStall(USB_BASE, IndexToUSBEP(EFC_USB_SV_CMD_EP_O_ADDR), USB_EP_HOST_OUT);
}
reset_ack_param = handler;
if (handler->reset_handle != NULL) {
handler->reset_handle(reset_ack, handler->reset_handle_param);
} else {
reset_ack();
}
}
static void reset_ack() {
struct sv_device* handler = reset_ack_param;
/* Запуск командного интерфейса */
{
atomic_flag_clear(&handler->cmd.tx_lock);
USBFIFOFlush(handler->usb_base, IndexToUSBEP(EFC_USB_SV_CMD_EP_I_ADDR), USB_EP_HOST_IN);
USBDevEndpointStallClear(handler->usb_base, IndexToUSBEP(EFC_USB_SV_CMD_EP_I_ADDR), USB_EP_HOST_IN);
atomic_flag_test_and_set(&handler->cmd.rx_lock);
USBFIFOFlush(handler->usb_base, IndexToUSBEP(EFC_USB_SV_CMD_EP_O_ADDR), USB_EP_HOST_OUT);
USBDevEndpointStallClear(handler->usb_base, IndexToUSBEP(EFC_USB_SV_CMD_EP_O_ADDR), USB_EP_HOST_OUT);
}
handler->flags.connected = true;
reset_ack_param = NULL;
}
inline void sv_device_handle_disconnect(struct sv_device* handler) {
assert(handler != NULL);
handler->flags.connected = false;
}
inline void sv_device_handle_config_enable(struct sv_device* handle) {
assert(handle != NULL);
if (handle->flags.initialized) handle->flags.enabled = true;
}
inline void sv_device_handle_config_disable(struct sv_device* handle) {
assert(handle != NULL);
if (handle->flags.initialized) handle->flags.enabled = false;
}
inline void sv_device_handle_ep(struct sv_device* handler, uint32_t status) {
assert(handler != NULL);
if (status & SV_CMD_EP_I_INT_MASK) {
atomic_flag_clear(&handler->cmd.tx_lock);
if (handler->cmd.tx_handle != NULL) {
handler->cmd.tx_handle(handler->cmd.tx_param);
}
}
if (status & SV_CMD_EP_O_INT_MASK) {
atomic_flag_clear(&handler->cmd.rx_lock);
if (handler->cmd.rx_handle != NULL) {
handler->cmd.rx_handle(handler->cmd.rx_param);
}
}
}

27
Projects/EFC_UsbDriver/src/service/sv_device_handle.h Normal file
View File

@ -0,0 +1,27 @@
/*
* sv_device_handle.h
*
* Created on: 28 Aug 2023
* Author: malyarenko
*/
#ifndef SRC_SERVICE_SV_DEVICE_HANDLE_H_
#define SRC_SERVICE_SV_DEVICE_HANDLE_H_
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "sv_device.h"
inline void sv_device_handle_reset(struct sv_device* handle);
inline void sv_device_handle_disconnect(struct sv_device* handle);
inline void sv_device_handle_config_enable(struct sv_device* handle);
inline void sv_device_handle_config_disable(struct sv_device* handle);
inline void sv_device_handle_ep(struct sv_device* handle, uint32_t status);
#endif /* SRC_SERVICE_SV_DEVICE_HANDLE_H_ */