kopia lustrzana https://github.com/stlink-org/stlink
Formatting & style fixes.
nightwalker-87
rodzic
b72f5b5acf
commit
101d77bf7e
|
|
@ -91,7 +91,7 @@ else ()
|
|||
set(CMAKE_C_FLAGS_MINSIZEREL_INIT "/MT /O1 /Ob1 /D NDEBUG")
|
||||
set(CMAKE_C_FLAGS_RELEASE_INIT "/MT /O2 /Ob2 /D NDEBUG")
|
||||
set(CMAKE_C_FLAGS_RELWITHDEBINFO_INIT "/MT /Zi /O2 /Ob1 /D NDEBUG")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
|
||||
###
|
||||
|
|
@ -111,10 +111,10 @@ if (_stack_chk_fail_exists)
|
|||
set(SSP_LIB -static ssp)
|
||||
else ()
|
||||
set(SSP_LIB ssp)
|
||||
endif ()
|
||||
endif()
|
||||
else ()
|
||||
set(SSP_LIB "")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
CHECK_INCLUDE_FILE(sys/mman.h STLINK_HAVE_SYS_MMAN_H)
|
||||
if (STLINK_HAVE_SYS_MMAN_H)
|
||||
|
|
@ -129,17 +129,17 @@ endif()
|
|||
CHECK_INCLUDE_FILE(unistd.h STLINK_HAVE_UNISTD_H)
|
||||
if (STLINK_HAVE_UNISTD_H)
|
||||
add_definitions(-DSTLINK_HAVE_UNISTD_H)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
CHECK_INCLUDE_FILE(dirent.h STLINK_HAVE_DIRENT_H)
|
||||
if (STLINK_HAVE_DIRENT_H)
|
||||
add_definitions(-DSTLINK_HAVE_DIRENT_H)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
if (MSVC)
|
||||
# Use string.h rather than strings.h and disable annoying warnings
|
||||
add_definitions(-DHAVE_STRING_H -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS /wd4710)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
|
||||
###
|
||||
|
|
@ -164,7 +164,7 @@ if (WIN32)
|
|||
set(STLINK_INCLUDE_PATH ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "Main include install directory")
|
||||
else ()
|
||||
set(STLINK_INCLUDE_PATH ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME} CACHE PATH "Main include install directory")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
## Subordinate CMakeLists for version config & header installation
|
||||
add_subdirectory(inc)
|
||||
|
|
@ -218,7 +218,7 @@ if (WIN32)
|
|||
# Add drop-in replacement for unistd.h to sources
|
||||
include_directories(src/win32/unistd)
|
||||
set(STLINK_HEADERS "${STLINK_HEADERS};src/win32/unistd/unistd.h")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
if (NOT STLINK_HAVE_SYS_MMAN_H)
|
||||
include_directories(src/win32/mmap)
|
||||
|
|
@ -230,12 +230,12 @@ if (WIN32)
|
|||
set(STLINK_SOURCE "${STLINK_SOURCE};src/win32/sys_time.c")
|
||||
set(STLINK_HEADERS "${STLINK_HEADERS};src/win32/sys_time.h")
|
||||
endif()
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
## Include test execution for test-targets for target Debug
|
||||
if (${CMAKE_BUILD_TYPE} MATCHES "Debug")
|
||||
include(CTest)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
|
||||
###
|
||||
|
|
@ -271,7 +271,7 @@ if (WIN32) # ... with Windows libraries
|
|||
target_link_libraries(${STLINK_LIB_SHARED} ${LIBUSB_LIBRARY} ${SSP_LIB} wsock32 ws2_32)
|
||||
else ()
|
||||
target_link_libraries(${STLINK_LIB_SHARED} ${LIBUSB_LIBRARY} ${SSP_LIB})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
install(TARGETS ${STLINK_LIB_SHARED}
|
||||
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
|
||||
|
|
@ -285,7 +285,7 @@ file(COPY ${LIBUSB_WIN_OUTPUT_FOLDER}/MinGW64/dll/libusb-1.0.dll
|
|||
DESTINATION ${CMAKE_INSTALL_BINDIR})
|
||||
file(COPY ${LIBUSB_WIN_OUTPUT_FOLDER}/MinGW64/dll/libusb-1.0.dll
|
||||
DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
|
||||
###
|
||||
|
|
@ -317,7 +317,7 @@ if (WIN32) # ... with Windows libraries
|
|||
target_link_libraries(${STLINK_LIB_STATIC} ${LIBUSB_LIBRARY} ${SSP_LIB} wsock32 ws2_32)
|
||||
else ()
|
||||
target_link_libraries(${STLINK_LIB_STATIC} ${LIBUSB_LIBRARY} ${SSP_LIB})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
install(TARGETS ${STLINK_LIB_STATIC} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
|
||||
|
||||
|
|
@ -336,7 +336,7 @@ if (MSVC)
|
|||
include_directories(src/win32/getopt)
|
||||
set(ST-UTIL_SOURCES "${ST-UTIL_SOURCES};src/win32/getopt/getopt.c")
|
||||
set(ST-TRACE_SOURCES "${ST-TRACE_SOURCES};src/win32/getopt/getopt.c")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
add_executable(st-flash ${ST-FLASH_SOURCES})
|
||||
add_executable(st-info ${ST-INFO_SOURCES})
|
||||
|
|
@ -353,7 +353,7 @@ else ()
|
|||
target_link_libraries(st-info ${STLINK_LIB_SHARED} ${SSP_LIB})
|
||||
target_link_libraries(st-util ${STLINK_LIB_SHARED} ${SSP_LIB})
|
||||
target_link_libraries(st-trace ${STLINK_LIB_SHARED} ${SSP_LIB})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
install(TARGETS st-flash DESTINATION ${CMAKE_INSTALL_BINDIR})
|
||||
install(TARGETS st-info DESTINATION ${CMAKE_INSTALL_BINDIR})
|
||||
|
|
@ -374,7 +374,7 @@ if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
|
|||
set(STLINK_UDEV_RULES_DIR "/lib/udev/rules.d" CACHE PATH "udev rules directory")
|
||||
file(GLOB RULES_FILES ${CMAKE_SOURCE_DIR}/config/udev/rules.d/*.rules)
|
||||
install(FILES ${RULES_FILES} DESTINATION ${STLINK_UDEV_RULES_DIR})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
|
||||
###
|
||||
|
|
@ -386,7 +386,7 @@ if (WIN32)
|
|||
set(CMAKE_CHIPS_DIR ${CMAKE_INSTALL_PREFIX}/config/chips)
|
||||
else ()
|
||||
set(CMAKE_CHIPS_DIR ${CMAKE_INSTALL_SHAREDIR}/${PROJECT_NAME}/chips)
|
||||
endif ()
|
||||
endif()
|
||||
add_definitions( -DSTLINK_CHIPS_DIR="${CMAKE_CHIPS_DIR}" )
|
||||
file(GLOB CHIP_FILES ${CMAKE_SOURCE_DIR}/config/chips/*.chip)
|
||||
install(FILES ${CHIP_FILES} DESTINATION ${CMAKE_CHIPS_DIR})
|
||||
|
|
@ -413,4 +413,4 @@ if (NOT TARGET uninstall)
|
|||
uninstall COMMAND ${CMAKE_COMMAND}
|
||||
-P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake
|
||||
)
|
||||
endif ()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ if (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD") # FreeBSD; libusb is
|
|||
mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARY)
|
||||
if (NOT LIBUSB_FOUND)
|
||||
message(FATAL_ERROR "Expected libusb library not found on your system! Verify your system integrity.")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
elseif (CMAKE_SYSTEM_NAME STREQUAL "OpenBSD") # OpenBSD; libusb-1.0 is available from ports
|
||||
FIND_PATH(
|
||||
|
|
@ -41,7 +41,7 @@ elseif (CMAKE_SYSTEM_NAME STREQUAL "OpenBSD") # OpenBSD; libusb-1.0
|
|||
mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARY)
|
||||
if (NOT LIBUSB_FOUND)
|
||||
message(FATAL_ERROR "No libusb-1.0 library found on your system! Install libusb-1.0 from ports or packages.")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
elseif (WIN32 OR (EXISTS "/etc/debian_version" AND MINGW)) # Windows or MinGW-toolchain on Debian
|
||||
# MinGW/MSYS/MSVC: 64-bit or 32-bit?
|
||||
|
|
@ -51,7 +51,7 @@ elseif (WIN32 OR (EXISTS "/etc/debian_version" AND MINGW)) # Windows or MinGW-to
|
|||
else ()
|
||||
message(STATUS "=== Building for Windows (i686) ===")
|
||||
set(ARCH 32)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
if (WIN32 AND NOT EXISTS "/etc/debian_version") # Skip this for Debian...
|
||||
# Preparations for installing libusb library
|
||||
|
|
@ -63,7 +63,7 @@ elseif (WIN32 OR (EXISTS "/etc/debian_version" AND MINGW)) # Windows or MinGW-to
|
|||
elseif (EXISTS "/etc/debian_version" AND MINGW) # ... only for cross-building on Debian
|
||||
set(LIBUSB_WIN_ARCHIVE_PATH ${CMAKE_SOURCE_DIR}/build-mingw-${ARCH}/${LIBUSB_WIN_ARCHIVE})
|
||||
set(LIBUSB_WIN_OUTPUT_FOLDER ${CMAKE_SOURCE_DIR}/build-mingw-${ARCH}/3rdparty/libusb-${LIBUSB_WIN_VERSION})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
# Get libusb package
|
||||
if (EXISTS ${LIBUSB_WIN_ARCHIVE_PATH}) # ... should the package be already there (for whatever reason)
|
||||
|
|
@ -74,7 +74,7 @@ elseif (WIN32 OR (EXISTS "/etc/debian_version" AND MINGW)) # Windows or MinGW-to
|
|||
https://sourceforge.net/projects/libusb/files/libusb-1.0/libusb-${LIBUSB_WIN_VERSION}/libusb-${LIBUSB_WIN_VERSION}.7z/download
|
||||
${LIBUSB_WIN_ARCHIVE_PATH} EXPECTED_MD5 aabe177bde869bfad34278335eaf8955
|
||||
)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
file(MAKE_DIRECTORY ${LIBUSB_WIN_OUTPUT_FOLDER})
|
||||
|
||||
|
|
@ -110,9 +110,9 @@ elseif (WIN32 OR (EXISTS "/etc/debian_version" AND MINGW)) # Windows or MinGW-to
|
|||
NO_DEFAULT_PATH
|
||||
NO_CMAKE_FIND_ROOT_PATH
|
||||
)
|
||||
endif ()
|
||||
endif()
|
||||
message(STATUS "Missing libusb library has been installed")
|
||||
endif ()
|
||||
endif()
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(libusb DEFAULT_MSG LIBUSB_LIBRARY LIBUSB_INCLUDE_DIR)
|
||||
mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARY)
|
||||
|
||||
|
|
@ -132,5 +132,5 @@ else ()
|
|||
|
||||
if (NOT LIBUSB_FOUND)
|
||||
message(FATAL_ERROR "libusb library not found on your system! Install libusb 1.0.x from your package repository.")
|
||||
endif ()
|
||||
endif ()
|
||||
endif()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ function(add_cflag_if_supported flag)
|
|||
|
||||
if (C_SUPPORTS${flagclean})
|
||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
|
||||
endif ()
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
add_cflag_if_supported("-Wall")
|
||||
|
|
@ -38,14 +38,14 @@ add_cflag_if_supported("-Wimplicit-function-declaration")
|
|||
##
|
||||
if (NOT CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
|
||||
add_cflag_if_supported("-Wredundant-decls")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
if (NOT (WIN32 OR (EXISTS "/etc/debian_version" AND MINGW)))
|
||||
add_cflag_if_supported("-fPIC")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
if (${CMAKE_BUILD_TYPE} MATCHES "Debug")
|
||||
add_cflag_if_supported("-ggdb")
|
||||
else ()
|
||||
add_cflag_if_supported("-Werror")
|
||||
endif ()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ if (GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
|
|||
)
|
||||
if (res EQUAL 1)
|
||||
set(PROJECT_VERSION "${PROJECT_VERSION}-dirty")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
# Strip a leading v off of the version as proceeding code expects just the version numbering.
|
||||
string(REGEX REPLACE "^v" "" PROJECT_VERSION ${PROJECT_VERSION})
|
||||
|
|
@ -53,14 +53,14 @@ if (GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
|
|||
# ...the version does not match with git-version string
|
||||
if (NOT __version_str STREQUAL __version_file)
|
||||
message(STATUS "Rewrite ${PROJECT_SOURCE_DIR}/.version with ${__version_str}!")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
elseif (NOT EXISTS "${PROJECT_SOURCE_DIR}/.version")
|
||||
|
||||
# No local .version file found: Create a new one...
|
||||
file(WRITE "${PROJECT_SOURCE_DIR}/.version" ${__version_str})
|
||||
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
message(STATUS "stlink version: ${PROJECT_VERSION}")
|
||||
message(STATUS "Major ${PROJECT_VERSION_MAJOR} Minor ${PROJECT_VERSION_MINOR} Patch ${PROJECT_VERSION_PATCH}")
|
||||
|
|
@ -68,13 +68,13 @@ if (GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
|
|||
else (len EQUAL 3)
|
||||
message(STATUS "Failed to extract version parts from \"${PROJECT_VERSION}\"")
|
||||
set(ERROR_FLAG "1")
|
||||
endif (len EQUAL 3)
|
||||
endif(len EQUAL 3)
|
||||
|
||||
else (GIT_DESCRIBE_RESULT EQUAL 0)
|
||||
message(WARNING "git describe failed: ${GIT_DESCRIBE_ERROR}")
|
||||
set(ERROR_FLAG "1")
|
||||
endif(GIT_DESCRIBE_RESULT EQUAL 0)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
##
|
||||
# Failure to read version via git
|
||||
|
|
@ -101,9 +101,9 @@ if (NOT GIT_FOUND OR NOT EXISTS "${PROJECT_SOURCE_DIR}/.git" OR ERROR_FLAG EQUAL
|
|||
set(__detect_version 1)
|
||||
else ()
|
||||
message(STATUS "Fail to extract version parts from \"${PROJECT_VERSION}\"")
|
||||
endif ()
|
||||
endif()
|
||||
else (EXISTS ${PROJECT_SOURCE_DIR}/.version)
|
||||
message(STATUS "File \"${PROJECT_SOURCE_DIR}/.version\" does not exist.")
|
||||
message(FATAL_ERROR "Unable to determine project version")
|
||||
endif ()
|
||||
endif ()
|
||||
endif()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ include(CMakeParseArguments)
|
|||
if (NOT EXISTS ${PANDOC_EXECUTABLE})
|
||||
find_program(PANDOC_EXECUTABLE pandoc)
|
||||
mark_as_advanced(PANDOC_EXECUTABLE)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
###############################################################################
|
||||
# Based on code from UseLATEX
|
||||
|
|
@ -133,7 +133,7 @@ This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
|
|||
Please delete them:
|
||||
$ rm -r CMakeFiles/ CmakeCache.txt
|
||||
")
|
||||
ENDif ()
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
# This builds a document
|
||||
|
|
@ -171,7 +171,7 @@ function(add_document target_name)
|
|||
if (NOT PANDOC_EXECUTABLE)
|
||||
message(WARNING "Pandoc not found. Install Pandoc (http://johnmacfarlane.net/pandoc/) or set cache variable PANDOC_EXECUTABLE.")
|
||||
return()
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
set(options EXPORT_ARCHIVE NO_EXPORT_PRODUCT EXPORT_PDF DIRECT_TEX_TO_PDF VERBOSE)
|
||||
set(oneValueArgs PRODUCT_DIRECTORY)
|
||||
|
|
@ -188,29 +188,29 @@ function(add_document target_name)
|
|||
if (NOT "${target_extension}" STREQUAL ".tex" AND NOT "${target_extension}" STREQUAL ".latex")
|
||||
# if (NOT "${target_extension}" STREQUAL ".tex")
|
||||
MESSAGE(FATAL_ERROR "Target '${target_name}': Cannot use 'EXPORT_PDF' for target of type '${target_extension}': target type must be '.tex' or '.latex'")
|
||||
endif ()
|
||||
endif ()
|
||||
endif()
|
||||
endif()
|
||||
if (${ADD_DOCUMENT_DIRECT_TEX_TO_PDF})
|
||||
list(LENGTH ${ADD_DOCUMENT_SOURCES} SOURCE_LEN)
|
||||
if (SOURCE_LEN GREATER 1)
|
||||
MESSAGE(FATAL_ERROR "Target '${target_name}': Only one source can be specified when using the 'DIRECT_TEX_TO_PDF' option")
|
||||
endif ()
|
||||
endif()
|
||||
# set(ADD_DOCUMENT_SOURCES, list(GET ${ADD_DOCUMENT_SOURCES} 1))
|
||||
pandocology_get_file_stemname(source_stemname ${ADD_DOCUMENT_SOURCES})
|
||||
pandocology_get_file_extension(source_extension ${ADD_DOCUMENT_SOURCES})
|
||||
if (NOT "${source_extension}" STREQUAL ".tex" AND NOT "${source_extension}" STREQUAL ".latex")
|
||||
MESSAGE(FATAL_ERROR "Target '${target_name}': Cannot use 'DIRECT_TEX_TO_PDF' for source of type '${source_extension}': source type must be '.tex' or '.latex'")
|
||||
endif ()
|
||||
endif()
|
||||
SET(check_target ${source_stemname}.pdf)
|
||||
IF (NOT ${check_target} STREQUAL ${target_name})
|
||||
MESSAGE(FATAL_ERROR "Target '${target_name}': Must use target name of '${check_target}' if using 'DIRECT_TEX_TO_PDF'")
|
||||
endif ()
|
||||
endif ()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
## set up output directory
|
||||
if ("${ADD_DOCUMENT_PRODUCT_DIRECTORY}" STREQUAL "")
|
||||
set(ADD_DOCUMENT_PRODUCT_DIRECTORY "product")
|
||||
endif ()
|
||||
endif()
|
||||
get_filename_component(product_directory ${CMAKE_BINARY_DIR}/${ADD_DOCUMENT_PRODUCT_DIRECTORY} ABSOLUTE)
|
||||
# get_filename_component(absolute_product_path ${product_directory}/${target_name} ABSOLUTE)
|
||||
|
||||
|
|
@ -232,7 +232,7 @@ function(add_document target_name)
|
|||
pandocology_add_input_dir(${CMAKE_CURRENT_SOURCE_DIR}/${resource_dir} ${CMAKE_CURRENT_BINARY_DIR} build_resources)
|
||||
if (${ADD_DOCUMENT_EXPORT_ARCHIVE})
|
||||
pandocology_add_input_dir(${CMAKE_CURRENT_SOURCE_DIR}/${resource_dir} ${product_directory} exported_resources)
|
||||
endif ()
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
## primary command
|
||||
|
|
@ -255,7 +255,7 @@ function(add_document target_name)
|
|||
# we produce the target in the source directory, in case other build targets require it as a source
|
||||
COMMAND latexmk -gg -halt-on-error -interaction=nonstopmode -file-line-error -pdf ${build_sources} 2>/dev/null >/dev/null || (grep --no-messages -A8 ".*:[0-9]*:.*" ${target_stemname}.log && false)
|
||||
)
|
||||
endif ()
|
||||
endif()
|
||||
add_to_make_clean(${CMAKE_CURRENT_BINARY_DIR}/${target_name})
|
||||
else()
|
||||
add_custom_command(
|
||||
|
|
@ -267,7 +267,7 @@ function(add_document target_name)
|
|||
COMMAND ${PANDOC_EXECUTABLE} ${build_sources} ${ADD_DOCUMENT_PANDOC_DIRECTIVES} -o ${target_name}
|
||||
)
|
||||
add_to_make_clean(${CMAKE_CURRENT_BINARY_DIR}/${target_name})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
## figure out what all is going to be produced by this build set, and set
|
||||
## those as dependencies of the primary target
|
||||
|
|
@ -275,14 +275,14 @@ function(add_document target_name)
|
|||
set(primary_target_dependencies ${primary_target_dependencies} ${CMAKE_CURRENT_BINARY_DIR}/${target_name})
|
||||
if (NOT ${ADD_DOCUMENT_NO_EXPORT_PRODUCT})
|
||||
set(primary_target_dependencies ${primary_target_dependencies} ${product_directory}/${target_name})
|
||||
endif ()
|
||||
endif()
|
||||
if (${ADD_DOCUMENT_EXPORT_PDF})
|
||||
set(primary_target_dependencies ${primary_target_dependencies} ${CMAKE_CURRENT_BINARY_DIR}/${target_stemname}.pdf)
|
||||
set(primary_target_dependencies ${primary_target_dependencies} ${product_directory}/${target_stemname}.pdf)
|
||||
endif ()
|
||||
endif()
|
||||
if (${ADD_DOCUMENT_EXPORT_ARCHIVE})
|
||||
set(primary_target_dependencies ${primary_target_dependencies} ${product_directory}/${target_stemname}.tbz)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
## primary target
|
||||
# # target cannot have same (absolute name) as dependencies:
|
||||
|
|
@ -326,7 +326,7 @@ function(add_document target_name)
|
|||
)
|
||||
add_to_make_clean(${CMAKE_CURRENT_BINARY_DIR}/${target_stemname}.pdf)
|
||||
add_to_make_clean(${product_directory}/${target_stemname}.pdf)
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
## copy products
|
||||
if (NOT ${ADD_DOCUMENT_NO_EXPORT_PRODUCT})
|
||||
|
|
@ -336,7 +336,7 @@ function(add_document target_name)
|
|||
COMMAND ${CMAKE_COMMAND} -E copy ${target_name} ${product_directory}
|
||||
)
|
||||
add_to_make_clean(${product_directory}/${target_name})
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
## copy resources
|
||||
if (${ADD_DOCUMENT_EXPORT_ARCHIVE})
|
||||
|
|
@ -359,7 +359,7 @@ function(add_document target_name)
|
|||
# ALL
|
||||
# DEPENDS ${product_directory}/${target_stemname}.tbz
|
||||
# )
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
endfunction(add_document)
|
||||
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ elseif (EXISTS "/etc/debian_version" AND NOT EXISTS WIN32) # Package-build is av
|
|||
|
||||
else ()
|
||||
# No package configuration on other platforms ...
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
|
||||
###
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ if (${STLINK_GENERATE_MANPAGES})
|
|||
endforeach ()
|
||||
else ()
|
||||
message(STATUS "Manpage generation disabled")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
# Install from output folder or this folder
|
||||
foreach (manpage ${MANPAGES})
|
||||
|
|
@ -27,10 +27,10 @@ foreach (manpage ${MANPAGES})
|
|||
set(f "${CMAKE_CURRENT_SOURCE_DIR}/${manpage}.1")
|
||||
else()
|
||||
message(AUTHOR_WARNING "Manpage ${manpage} not generated")
|
||||
endif ()
|
||||
endif()
|
||||
|
||||
if (f AND NOT WIN32)
|
||||
install(FILES ${f} DESTINATION ${CMAKE_INSTALL_DATADIR}/man/man1)
|
||||
unset(f)
|
||||
endif ()
|
||||
endif()
|
||||
endforeach ()
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ int32_t main(int32_t ac, char** av) {
|
|||
if (flash_get_opts(&o, ac - 1, av + 1) == -1) {
|
||||
printf("invalid command line\n");
|
||||
usage();
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
printf("st-flash %s\n", STLINK_VERSION);
|
||||
|
|
@ -83,7 +83,7 @@ int32_t main(int32_t ac, char** av) {
|
|||
|
||||
sl = stlink_open_usb(o.log_level, o.connect, (char *)o.serial, o.freq);
|
||||
|
||||
if (sl == NULL) { return(-1); }
|
||||
if (sl == NULL) { return (-1); }
|
||||
|
||||
if (sl->flash_type == STM32_FLASH_TYPE_UNKNOWN) {
|
||||
printf("Failed to connect to target\n");
|
||||
|
|
@ -299,5 +299,5 @@ on_error:
|
|||
stlink_close(sl);
|
||||
free(mem);
|
||||
|
||||
return(err);
|
||||
return (err);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
static bool starts_with(const char * str, const char * prefix) {
|
||||
uint32_t n = strlen(prefix);
|
||||
|
||||
if (strlen(str) < n) { return(false); }
|
||||
if (strlen(str) < n) { return (false); }
|
||||
|
||||
return (0 == strncmp(str, prefix, n));
|
||||
}
|
||||
|
|
@ -49,11 +49,11 @@ static int32_t get_long_integer_from_char_array (const char *const str, uint64_t
|
|||
} else if (tail[0] == '\0') {
|
||||
/* value not changed */
|
||||
} else {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
*read_value = value;
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// support positive integer from 0 to UINT32_MAX
|
||||
|
|
@ -65,24 +65,24 @@ static int32_t get_integer_from_char_array (const char *const str, uint32_t *rea
|
|||
int32_t result = get_long_integer_from_char_array (str, &value);
|
||||
|
||||
if (result != 0) {
|
||||
return(result);
|
||||
return (result);
|
||||
} else if (value > UINT32_MAX) {
|
||||
fprintf (stderr, "*** Error: Integer greater than UINT32_MAX, cannot convert to int32_t\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
} else {
|
||||
*read_value = value;
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
|
||||
static int32_t invalid_args(const char *expected) {
|
||||
fprintf(stderr, "*** Error: Expected args for this command: %s\n", expected);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static int32_t bad_arg(const char *arg) {
|
||||
fprintf(stderr, "*** Error: Invalid value for %s\n", arg);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
||||
|
|
@ -111,7 +111,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
ac--;
|
||||
av++;
|
||||
|
||||
if (ac < 1) { return(-1); }
|
||||
if (ac < 1) { return (-1); }
|
||||
|
||||
serial = av[0];
|
||||
} else {
|
||||
|
|
@ -127,7 +127,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
ac--;
|
||||
av++;
|
||||
|
||||
if (ac < 1) { return(-1); }
|
||||
if (ac < 1) { return (-1); }
|
||||
|
||||
area = av[0];
|
||||
} else {
|
||||
|
|
@ -149,7 +149,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
} else if (strcmp(area, "optcr1") == 0) {
|
||||
o->area = FLASH_OPTCR1;
|
||||
} else {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
} else if (strcmp(av[0], "--freq") == 0) {
|
||||
|
|
@ -157,17 +157,17 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
av++;
|
||||
|
||||
if (ac < 1) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
o->freq = arg_parse_freq(av[0]);
|
||||
if (o->freq < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
} else if (starts_with(av[0], "--freq=")) {
|
||||
o->freq = arg_parse_freq(av[0] + strlen("--freq="));
|
||||
if (o->freq < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
} else if (strcmp(av[0], "--format") == 0 || starts_with(av[0], "--format=")) {
|
||||
const char * format;
|
||||
|
|
@ -176,7 +176,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
ac--;
|
||||
av++;
|
||||
|
||||
if (ac < 1) { return(-1); }
|
||||
if (ac < 1) { return (-1); }
|
||||
|
||||
format = av[0];
|
||||
} else {
|
||||
|
|
@ -188,7 +188,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
} else if (strcmp(format, "ihex") == 0) {
|
||||
o->format = FLASH_FORMAT_IHEX;
|
||||
} else {
|
||||
return(bad_arg("format"));
|
||||
return (bad_arg("format"));
|
||||
}
|
||||
} else if ( starts_with(av[0], "--flash=")) {
|
||||
const char *arg = av[0] + strlen("--flash=");
|
||||
|
|
@ -197,7 +197,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
result = get_integer_from_char_array(arg, &flash_size);
|
||||
|
||||
if (result != 0) {
|
||||
return(bad_arg ("--flash"));
|
||||
return (bad_arg ("--flash"));
|
||||
} else {
|
||||
o->flash_size = (size_t)flash_size;
|
||||
}
|
||||
|
|
@ -217,18 +217,18 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
// command and (optional) device name
|
||||
while (ac >= 1) {
|
||||
if (strcmp(av[0], "erase") == 0) {
|
||||
if (o->cmd != FLASH_CMD_NONE) { return(-1); }
|
||||
if (o->cmd != FLASH_CMD_NONE) { return (-1); }
|
||||
o->cmd = FLASH_CMD_ERASE;
|
||||
} else if (strcmp(av[0], "read") == 0) {
|
||||
if (o->cmd != FLASH_CMD_NONE) { return(-1); }
|
||||
if (o->cmd != FLASH_CMD_NONE) { return (-1); }
|
||||
|
||||
o->cmd = FLASH_CMD_READ;
|
||||
} else if (strcmp(av[0], "write") == 0) {
|
||||
if (o->cmd != FLASH_CMD_NONE) { return(-1); }
|
||||
if (o->cmd != FLASH_CMD_NONE) { return (-1); }
|
||||
|
||||
o->cmd = FLASH_CMD_WRITE;
|
||||
} else if (strcmp(av[0], "reset") == 0) {
|
||||
if (o->cmd != FLASH_CMD_NONE) { return(-1); }
|
||||
if (o->cmd != FLASH_CMD_NONE) { return (-1); }
|
||||
|
||||
o->cmd = CMD_RESET;
|
||||
} else {
|
||||
|
|
@ -241,10 +241,10 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
|
||||
switch (o->cmd) {
|
||||
case FLASH_CMD_NONE: // no command found
|
||||
return(-1);
|
||||
return (-1);
|
||||
|
||||
case FLASH_CMD_ERASE: // no more arguments expected
|
||||
if (ac != 0 && ac != 2) { return(-1); }
|
||||
if (ac != 0 && ac != 2) { return (-1); }
|
||||
if (ac == 2) {
|
||||
uint32_t address;
|
||||
result = get_integer_from_char_array(av[0], &address);
|
||||
|
|
@ -336,7 +336,7 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
result = get_integer_from_char_array(av[0], &val);
|
||||
|
||||
if (result != 0) {
|
||||
return(bad_arg ("val"));
|
||||
return (bad_arg ("val"));
|
||||
} else {
|
||||
o->val = val;
|
||||
}
|
||||
|
|
@ -369,16 +369,16 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
result = get_integer_from_char_array(av[1], &addr);
|
||||
|
||||
if (result != 0) {
|
||||
return(bad_arg ("addr"));
|
||||
return (bad_arg ("addr"));
|
||||
} else {
|
||||
o->addr = (stm32_addr_t)addr;
|
||||
}
|
||||
} else if (o->format == FLASH_FORMAT_IHEX) { // expect filename
|
||||
if (ac != 1) { return(invalid_args("write <path>")); }
|
||||
if (ac != 1) { return (invalid_args("write <path>")); }
|
||||
|
||||
o->filename = av[0];
|
||||
} else {
|
||||
return(-1); // should have been caught during format parsing
|
||||
return (-1); // should have been caught during format parsing
|
||||
}
|
||||
|
||||
break;
|
||||
|
|
@ -386,5 +386,5 @@ int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
|
|||
default: break;
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ static int32_t print_data(int32_t ac, char **av) {
|
|||
|
||||
if (strcmp(av[1], "--version") == 0) {
|
||||
printf("v%s\n", STLINK_VERSION);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
init_chipids(STLINK_CHIPS_DIR);
|
||||
|
|
@ -99,18 +99,18 @@ static int32_t print_data(int32_t ac, char **av) {
|
|||
|
||||
printf("Incorrect argument: %s\n\n", av[i]);
|
||||
usage();
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
// probe needs all devices unclaimed
|
||||
if (strcmp(av[1], "--probe") == 0) {
|
||||
stlink_probe(connect, freq);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// open first st-link device
|
||||
sl = stlink_open_usb(0, connect, NULL, freq);
|
||||
if (sl == NULL) { return(-1); }
|
||||
if (sl == NULL) { return (-1); }
|
||||
|
||||
if (strcmp(av[1], "--serial") == 0) {
|
||||
printf("%s\n", sl->serial);
|
||||
|
|
@ -124,7 +124,7 @@ static int32_t print_data(int32_t ac, char **av) {
|
|||
printf("0x%.4x\n", sl->chip_id);
|
||||
} else if (strcmp(av[1], "--descr") == 0) {
|
||||
const struct stlink_chipid_params *params = stlink_chipid_get_params(sl->chip_id);
|
||||
if (params == NULL) { return(-1); }
|
||||
if (params == NULL) { return (-1); }
|
||||
|
||||
printf("%s\n", params->dev_type);
|
||||
}
|
||||
|
|
@ -134,7 +134,7 @@ static int32_t print_data(int32_t ac, char **av) {
|
|||
stlink_close(sl);
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t main(int32_t ac, char** av) {
|
||||
|
|
@ -142,10 +142,10 @@ int32_t main(int32_t ac, char** av) {
|
|||
|
||||
if (ac < 2) {
|
||||
usage();
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
err = print_data(ac, av);
|
||||
|
||||
return(err);
|
||||
return (err);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,19 +42,19 @@ int32_t gdb_send_packet(int32_t fd, char* data) {
|
|||
while (1) {
|
||||
if (write(fd, packet, length) != length) {
|
||||
free(packet);
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
|
||||
char ack;
|
||||
|
||||
if (read(fd, &ack, 1) != 1) {
|
||||
free(packet);
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
|
||||
if (ack == '+') {
|
||||
free(packet);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -69,7 +69,7 @@ int32_t gdb_recv_packet(int32_t fd, char** buffer) {
|
|||
uint32_t state;
|
||||
|
||||
if (packet_buffer == NULL) {
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
|
||||
start:
|
||||
|
|
@ -88,7 +88,7 @@ start:
|
|||
while (state != 4) {
|
||||
if (read(fd, &c, 1) != 1) {
|
||||
free(packet_buffer);
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
|
||||
switch (state) {
|
||||
|
|
@ -117,7 +117,7 @@ start:
|
|||
packet_buffer = p;
|
||||
} else {
|
||||
free(packet_buffer);
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -143,7 +143,7 @@ start:
|
|||
|
||||
if (write(fd, &nack, 1) != 1) {
|
||||
free(packet_buffer);
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
|
||||
goto start;
|
||||
|
|
@ -152,14 +152,14 @@ start:
|
|||
|
||||
if (write(fd, &ack, 1) != 1) {
|
||||
free(packet_buffer);
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
}
|
||||
|
||||
packet_buffer[packet_idx] = 0;
|
||||
*buffer = packet_buffer;
|
||||
|
||||
return(packet_idx);
|
||||
return (packet_idx);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -176,13 +176,13 @@ int32_t gdb_check_for_interrupt(int32_t fd) {
|
|||
char c;
|
||||
|
||||
if (read(fd, &c, 1) != 1) {
|
||||
return(-2);
|
||||
return (-2);
|
||||
}
|
||||
|
||||
if (c == '\x03') {
|
||||
return(1); // ^C
|
||||
return (1); // ^C
|
||||
}
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ int32_t parse_options(int32_t argc, char** argv, st_state_t *st) {
|
|||
printf("\n");
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t main(int32_t argc, char** argv) {
|
||||
|
|
@ -233,11 +233,11 @@ int32_t main(int32_t argc, char** argv) {
|
|||
init_chipids (STLINK_CHIPS_DIR);
|
||||
|
||||
sl = stlink_open_usb(state.logging_level, state.connect_mode, state.serialnumber, state.freq);
|
||||
if (sl == NULL) { return(1); }
|
||||
if (sl == NULL) { return (1); }
|
||||
|
||||
if (sl->chip_id == STM32_CHIPID_UNKNOWN) {
|
||||
ELOG("Unsupported Target (Chip ID is %#010x, Core ID is %#010x).\n", sl->chip_id, sl->core_id);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
sl->verbose = 0;
|
||||
|
|
@ -275,7 +275,7 @@ winsock_error:
|
|||
stlink_exit_debug_mode(sl);
|
||||
stlink_close(sl);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static const char* const target_description =
|
||||
|
|
@ -608,7 +608,7 @@ char* make_memory_map(stlink_t *sl) {
|
|||
sl->sys_size);
|
||||
}
|
||||
|
||||
return(map);
|
||||
return (map);
|
||||
}
|
||||
|
||||
#define DATA_WATCH_NUM 4
|
||||
|
|
@ -676,12 +676,12 @@ static int32_t add_data_watchpoint(stlink_t *sl, enum watchfun wf, stm32_addr_t
|
|||
|
||||
// just to make sure the matched bit is clear !
|
||||
stlink_read_debug32(sl, STLINK_REG_CM3_DWT_FUNn(i), &dummy);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
|
||||
DLOG("failure: add watchpoints addr %x wf %u len %u\n", addr, wf, len);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static int32_t delete_data_watchpoint(stlink_t *sl, stm32_addr_t addr) {
|
||||
|
|
@ -694,13 +694,13 @@ static int32_t delete_data_watchpoint(stlink_t *sl, stm32_addr_t addr) {
|
|||
data_watches[i].fun = WATCHDISABLED;
|
||||
stlink_write_debug32(sl, STLINK_REG_CM3_DWT_FUNn(i), 0);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
|
||||
DLOG("failure: delete watchpoint addr %x\n", addr);
|
||||
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static int32_t code_break_num;
|
||||
|
|
@ -746,9 +746,9 @@ static void init_code_breakpoints(stlink_t *sl) {
|
|||
|
||||
static int32_t has_breakpoint(stm32_addr_t addr) {
|
||||
for (int32_t i = 0; i < code_break_num; i++)
|
||||
if (code_breaks[i].addr == addr) { return(1); }
|
||||
if (code_breaks[i].addr == addr) { return (1); }
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int32_t update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int32_t set) {
|
||||
|
|
@ -758,7 +758,7 @@ static int32_t update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int32_t s
|
|||
|
||||
if (addr & 1) {
|
||||
ELOG("update_code_breakpoint: unaligned address %08x\n", addr);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (code_break_rev == CODE_BREAK_REV_V1) {
|
||||
|
|
@ -778,9 +778,9 @@ static int32_t update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int32_t s
|
|||
|
||||
if (id == -1) {
|
||||
if (set)
|
||||
return(-1); // free slot not found
|
||||
return (-1); // free slot not found
|
||||
else
|
||||
return(0); // breakpoint is already removed
|
||||
return (0); // breakpoint is already removed
|
||||
}
|
||||
|
||||
struct code_hw_breakpoint* bp = &code_breaks[id];
|
||||
|
|
@ -802,7 +802,7 @@ static int32_t update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int32_t s
|
|||
stlink_write_debug32(sl, STLINK_REG_CM3_FP_COMPn(id), mask);
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -820,14 +820,14 @@ static int32_t flash_add_block(stm32_addr_t addr, uint32_t length, stlink_t *sl)
|
|||
|
||||
if (addr < FLASH_BASE || addr + length > FLASH_BASE + sl->flash_size) {
|
||||
ELOG("flash_add_block: incorrect bounds\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
stlink_calculate_pagesize(sl, addr);
|
||||
|
||||
if (addr % FLASH_PAGE != 0 || length % FLASH_PAGE != 0) {
|
||||
ELOG("flash_add_block: unaligned block\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
struct flash_block* new = malloc(sizeof(struct flash_block));
|
||||
|
|
@ -838,7 +838,7 @@ static int32_t flash_add_block(stm32_addr_t addr, uint32_t length, stlink_t *sl)
|
|||
memset(new->data, stlink_get_erased_pattern(sl), length);
|
||||
|
||||
flash_root = new;
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int32_t flash_populate(stm32_addr_t addr, uint8_t* data, uint32_t length) {
|
||||
|
|
@ -871,7 +871,7 @@ static int32_t flash_populate(stm32_addr_t addr, uint8_t* data, uint32_t length)
|
|||
|
||||
if (fit_blocks == 0) {
|
||||
ELOG("Unfit data block %08x -> %04x\n", addr, length);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (fit_length != length) {
|
||||
|
|
@ -879,7 +879,7 @@ static int32_t flash_populate(stm32_addr_t addr, uint8_t* data, uint32_t length)
|
|||
WLOG("(this is not an error, just a GDB glitch)\n");
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int32_t flash_go(stlink_t *sl, st_state_t *st) {
|
||||
|
|
@ -935,7 +935,7 @@ error:
|
|||
}
|
||||
|
||||
flash_root = NULL;
|
||||
return(error);
|
||||
return (error);
|
||||
}
|
||||
|
||||
struct cache_level_desc {
|
||||
|
|
@ -967,7 +967,7 @@ static uint32_t ceil_log2(uint32_t v) {
|
|||
|
||||
for (res = 0; (1U << res) < v; res++);
|
||||
|
||||
return(res);
|
||||
return (res);
|
||||
}
|
||||
|
||||
static void read_cache_level_desc(stlink_t *sl, struct cache_level_desc *desc) {
|
||||
|
|
@ -1083,12 +1083,12 @@ static uint32_t unhexify(const char *in, char *out, uint32_t out_count) {
|
|||
uint32_t c;
|
||||
|
||||
for (i = 0; i < out_count; i++) {
|
||||
if (sscanf(in + (2 * i), "%02x", &c) != 1) { return(i); }
|
||||
if (sscanf(in + (2 * i), "%02x", &c) != 1) { return (i); }
|
||||
|
||||
out[i] = (char)c;
|
||||
}
|
||||
|
||||
return(i);
|
||||
return (i);
|
||||
}
|
||||
|
||||
int32_t serve(stlink_t *sl, st_state_t *st) {
|
||||
|
|
@ -1096,7 +1096,7 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
|
||||
if (!IS_SOCK_VALID(sock)) {
|
||||
perror("socket");
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
uint32_t val = 1;
|
||||
|
|
@ -1111,13 +1111,13 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
|
||||
perror("bind");
|
||||
close_socket(sock);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
if (listen(sock, 5) < 0) {
|
||||
perror("listen");
|
||||
close_socket(sock);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
ILOG("Listening at *:%d...\n", st->listen_port);
|
||||
|
|
@ -1128,7 +1128,7 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
if (!IS_SOCK_VALID(client)) {
|
||||
perror("accept");
|
||||
close_socket(sock);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
close_socket(sock);
|
||||
|
|
@ -1169,7 +1169,7 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
if (status < 0) {
|
||||
ELOG("cannot recv: %d\n", status);
|
||||
close_socket(client);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
DLOG("recv: %s\n", packet);
|
||||
|
|
@ -1447,7 +1447,7 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
if (status < 0) {
|
||||
ELOG("cannot check for int: %d\n", status);
|
||||
close_socket(client);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
if (status == 1) {
|
||||
|
|
@ -1884,7 +1884,7 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
free(reply);
|
||||
free(packet);
|
||||
close_socket(client);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
free(reply);
|
||||
|
|
@ -1892,12 +1892,12 @@ int32_t serve(stlink_t *sl, st_state_t *st) {
|
|||
|
||||
if (critical_error) {
|
||||
close_socket(client);
|
||||
return(1);
|
||||
return (1);
|
||||
}
|
||||
|
||||
free(packet);
|
||||
}
|
||||
|
||||
close_socket(client);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,13 +16,13 @@ static int32_t mem_read_u8(stlink_t *sl, uint32_t addr, uint8_t *data) {
|
|||
int32_t offset = addr % 4;
|
||||
int32_t len = 4;
|
||||
|
||||
if (sl == NULL || data == NULL) { return(-1); }
|
||||
if (sl == NULL || data == NULL) { return (-1); }
|
||||
|
||||
// read address and length must be aligned
|
||||
if (stlink_read_mem32(sl, addr - offset, len) != 0) { return(-1); }
|
||||
if (stlink_read_mem32(sl, addr - offset, len) != 0) { return (-1); }
|
||||
|
||||
*data = sl->q_buf[offset];
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
#ifdef UNUSED
|
||||
|
|
@ -30,26 +30,26 @@ static int32_t mem_read_u16(stlink_t *sl, uint32_t addr, uint16_t *data) {
|
|||
int32_t offset = addr % 4;
|
||||
int32_t len = (offset > 2 ? 8 : 4);
|
||||
|
||||
if (sl == NULL || data == NULL) { return(-1); }
|
||||
if (sl == NULL || data == NULL) { return (-1); }
|
||||
|
||||
// read address and length must be aligned
|
||||
if (stlink_read_mem32(sl, addr - offset, len) != 0) { return(-1); }
|
||||
if (stlink_read_mem32(sl, addr - offset, len) != 0) { return (-1); }
|
||||
|
||||
memcpy(data, &sl->q_buf[offset], sizeof(*data));
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int32_t mem_read_u32(stlink_t *sl, uint32_t addr, uint32_t *data) {
|
||||
int32_t offset = addr % 4;
|
||||
int32_t len = (offset > 0 ? 8 : 4);
|
||||
|
||||
if (sl == NULL || data == NULL) { return(-1); }
|
||||
if (sl == NULL || data == NULL) { return (-1); }
|
||||
|
||||
// read address and length must be aligned
|
||||
if (stlink_read_mem32(sl, addr - offset, len) != 0) { return(-1); }
|
||||
if (stlink_read_mem32(sl, addr - offset, len) != 0) { return (-1); }
|
||||
|
||||
memcpy(data, &sl->q_buf[offset], sizeof(*data));
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -57,16 +57,16 @@ static int32_t mem_read(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
|
|||
int32_t offset = addr % 4;
|
||||
int32_t read_len = len + offset;
|
||||
|
||||
if (sl == NULL || data == NULL) { return(-1); }
|
||||
if (sl == NULL || data == NULL) { return (-1); }
|
||||
|
||||
// align read size
|
||||
if ((read_len % 4) != 0) { read_len += 4 - (read_len % 4); }
|
||||
|
||||
// address and length must be aligned
|
||||
if (stlink_read_mem32(sl, addr - offset, read_len) != 0) { return(-1); }
|
||||
if (stlink_read_mem32(sl, addr - offset, read_len) != 0) { return (-1); }
|
||||
|
||||
memcpy(data, &sl->q_buf[offset], len);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int32_t mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
|
||||
|
|
@ -77,12 +77,12 @@ static int32_t mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len)
|
|||
* the requested bytes. (perhaps reading the whole area is faster??).
|
||||
* If 16 and 8 bit writes are available, then they could be used instead.
|
||||
* Just return when the length is zero avoiding unneeded work. */
|
||||
if (len == 0) { return(0); }
|
||||
if (len == 0) { return (0); }
|
||||
|
||||
int32_t offset = addr % 4;
|
||||
int32_t write_len = len + offset;
|
||||
|
||||
if (sl == NULL || data == NULL) { return(-1); }
|
||||
if (sl == NULL || data == NULL) { return (-1); }
|
||||
|
||||
// align read size
|
||||
if ((write_len % 4) != 0) { write_len += 4 - (write_len % 4); }
|
||||
|
|
@ -90,9 +90,9 @@ static int32_t mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len)
|
|||
memcpy(&sl->q_buf[offset], data, len);
|
||||
|
||||
// address and length must be aligned
|
||||
if (stlink_write_mem32(sl, addr - offset, write_len) != 0) { return(-1); }
|
||||
if (stlink_write_mem32(sl, addr - offset, write_len) != 0) { return (-1); }
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* For the SYS_WRITE0 call, we don't know the size of the null-terminated buffer
|
||||
|
|
@ -132,7 +132,7 @@ static int32_t saved_errno = 0;
|
|||
|
||||
int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
||||
|
||||
if (sl == NULL || ret == NULL) { return(-1); }
|
||||
if (sl == NULL || ret == NULL) { return (-1); }
|
||||
|
||||
DLOG("Do semihosting R0=0x%08x R1=0x%08x\n", r0, r1);
|
||||
|
||||
|
|
@ -148,7 +148,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (mem_read(sl, r1, args, sizeof(args)) != 0) {
|
||||
DLOG("Semihosting SYS_OPEN error: cannot read args from target memory\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
name_address = args[0];
|
||||
|
|
@ -159,7 +159,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
/* Invalid mode */
|
||||
DLOG("Semihosting SYS_OPEN error: invalid mode %d\n", mode);
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/* Add the trailing zero that is not counted in the length argument (see
|
||||
|
|
@ -170,7 +170,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (name_len > MAX_BUFFER_SIZE) {
|
||||
DLOG("Semihosting SYS_OPEN error: name buffer size is too big %d\n", name_len);
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
name = malloc(name_len);
|
||||
|
|
@ -178,14 +178,14 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (name == NULL) {
|
||||
DLOG("Semihosting SYS_OPEN error: cannot allocate name buffer\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (mem_read(sl, name_address, name, name_len) != 0) {
|
||||
free(name);
|
||||
*ret = -1;
|
||||
DLOG("Semihosting SYS_OPEN error: cannot read name from target memory\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
DLOG("Semihosting: open('%s', (SH open mode)%d, 0644)\n", name, mode);
|
||||
|
|
@ -206,7 +206,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (mem_read(sl, r1, args, sizeof(args)) != 0) {
|
||||
DLOG("Semihosting SYS_CLOSE error: cannot read args from target memory\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
fd = (int32_t)args[0];
|
||||
|
|
@ -230,7 +230,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (mem_read(sl, r1, args, sizeof(args)) != 0) {
|
||||
DLOG("Semihosting SYS_WRITE error: cannot read args from target memory\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
fd = (int32_t)args[0];
|
||||
|
|
@ -241,7 +241,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
DLOG("Semihosting SYS_WRITE error: buffer size is too big %d\n",
|
||||
buffer_len);
|
||||
*ret = buffer_len;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
buffer = malloc(buffer_len);
|
||||
|
|
@ -249,14 +249,14 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (buffer == NULL) {
|
||||
DLOG("Semihosting SYS_WRITE error: cannot allocate buffer\n");
|
||||
*ret = buffer_len;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (mem_read(sl, buffer_address, buffer, buffer_len) != 0) {
|
||||
DLOG("Semihosting SYS_WRITE error: cannot read buffer from target memory\n");
|
||||
free(buffer);
|
||||
*ret = buffer_len;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
DLOG("Semihosting: write(%d, target_addr:0x%08x, %u)\n", fd, buffer_address, buffer_len);
|
||||
|
|
@ -286,7 +286,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (mem_read(sl, r1, args, sizeof(args)) != 0) {
|
||||
DLOG("Semihosting SYS_READ error: cannot read args from target memory\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
fd = (int32_t)args[0];
|
||||
|
|
@ -296,7 +296,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (buffer_len > MAX_BUFFER_SIZE) {
|
||||
DLOG("Semihosting SYS_READ error: buffer size is too big %d\n", buffer_len);
|
||||
*ret = buffer_len;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
buffer = malloc(buffer_len);
|
||||
|
|
@ -304,7 +304,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (buffer == NULL) {
|
||||
DLOG("Semihosting SYS_READ error: cannot allocatebuffer\n");
|
||||
*ret = buffer_len;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
DLOG("Semihosting: read(%d, target_addr:0x%08x, %u)\n", fd, buffer_address,
|
||||
|
|
@ -320,7 +320,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
DLOG("Semihosting SYS_READ error: cannot write buffer to target memory\n");
|
||||
free(buffer);
|
||||
*ret = buffer_len;
|
||||
return(-1);
|
||||
return (-1);
|
||||
} else {
|
||||
*ret = buffer_len - (uint32_t)read_result;
|
||||
}
|
||||
|
|
@ -346,7 +346,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (mem_read(sl, r1, args, sizeof(args)) != 0) {
|
||||
DLOG("Semihosting SYS_REMOVE error: cannot read args from target memory\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
name_address = args[0];
|
||||
|
|
@ -361,7 +361,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
DLOG("Semihosting SYS_REMOVE error: name buffer size is too big %d\n",
|
||||
name_len);
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
name = malloc(name_len);
|
||||
|
|
@ -369,14 +369,14 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (name == NULL) {
|
||||
DLOG("Semihosting SYS_REMOVE error: cannot allocate name buffer\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (mem_read(sl, name_address, name, name_len) != 0) {
|
||||
free(name);
|
||||
*ret = -1;
|
||||
DLOG("Semihosting SYS_REMOVE error: cannot read name from target memory\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
DLOG("Semihosting: unlink('%s')\n", name);
|
||||
|
|
@ -395,7 +395,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
if (mem_read(sl, r1, args, sizeof(args)) != 0) {
|
||||
DLOG("Semihosting SYS_SEEK error: cannot read args from target memory\n");
|
||||
*ret = -1;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
fd = (int32_t)args[0];
|
||||
|
|
@ -435,11 +435,11 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
while (true) {
|
||||
if (mem_read(sl, r1, buf, WRITE0_BUFFER_SIZE) != 0) {
|
||||
DLOG("Semihosting WRITE0: cannot read target memory at 0x%08x\n", r1);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
for (int32_t i = 0; i < WRITE0_BUFFER_SIZE; i++) {
|
||||
if (buf[i] == 0) { return(0); }
|
||||
if (buf[i] == 0) { return (0); }
|
||||
|
||||
fprintf(stderr, "%c", buf[i]);
|
||||
}
|
||||
|
|
@ -451,7 +451,7 @@ int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
|
|||
}
|
||||
default:
|
||||
fprintf(stderr, "semihosting: unsupported call %#x\n", r0);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,5 +31,5 @@ if (NOT WIN32 AND NOT CMAKE_CROSSCOMPILING)
|
|||
COMPILE_DEFINITIONS STLINK_UI_DIR="${CMAKE_INSTALL_SHAREDIR}/${PROJECT_NAME}")
|
||||
target_link_libraries(stlink-gui ${STLINK_LIB_SHARED} ${SSP_LIB} ${GTK3_LDFLAGS})
|
||||
install(TARGETS stlink-gui DESTINATION ${CMAKE_BINDIR})
|
||||
endif ()
|
||||
endif ()
|
||||
endif()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ static gboolean set_info_error_message_idle(STlinkGUI *gui) {
|
|||
gui->error_message = NULL;
|
||||
}
|
||||
|
||||
return(FALSE);
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static void stlink_gui_set_info_error_message(STlinkGUI *gui, const gchar *message) {
|
||||
|
|
@ -156,15 +156,15 @@ static guint32 hexstr_to_guint32(const gchar *str, GError **err) {
|
|||
|
||||
if ((errno == ERANGE && val == UINT_MAX) || (errno != 0 && val == 0)) {
|
||||
g_set_error(err, g_quark_from_string("hextou32"), 1, "Invalid hexstring");
|
||||
return(UINT32_MAX);
|
||||
return (UINT32_MAX);
|
||||
}
|
||||
|
||||
if (end_ptr == str) {
|
||||
g_set_error(err, g_quark_from_string("hextou32"), 2, "Invalid hexstring");
|
||||
return(UINT32_MAX);
|
||||
return (UINT32_MAX);
|
||||
}
|
||||
|
||||
return(val);
|
||||
return (val);
|
||||
}
|
||||
|
||||
static void stlink_gui_update_mem_view(STlinkGUI *gui, struct mem_t *mem, GtkTreeView *view) {
|
||||
|
|
@ -182,7 +182,7 @@ static void stlink_gui_update_mem_view(STlinkGUI *gui, struct mem_t *mem, GtkTre
|
|||
|
||||
static gboolean stlink_gui_update_devmem_view(STlinkGUI *gui) {
|
||||
stlink_gui_update_mem_view(gui, &gui->flash_mem, gui->devmem_treeview);
|
||||
return(FALSE);
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static gpointer stlink_gui_populate_devmem_view(gpointer data) {
|
||||
|
|
@ -220,7 +220,7 @@ static gpointer stlink_gui_populate_devmem_view(gpointer data) {
|
|||
stlink_gui_set_info_error_message(gui, "Failed to read memory");
|
||||
g_free(gui->flash_mem.memory);
|
||||
gui->flash_mem.memory = NULL;
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
memcpy(gui->flash_mem.memory + off, gui->sl->q_buf, n_read);
|
||||
|
|
@ -228,7 +228,7 @@ static gpointer stlink_gui_populate_devmem_view(gpointer data) {
|
|||
}
|
||||
|
||||
g_idle_add((GSourceFunc)stlink_gui_update_devmem_view, gui);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
static gboolean stlink_gui_update_filemem_view(STlinkGUI *gui) {
|
||||
|
|
@ -240,7 +240,7 @@ static gboolean stlink_gui_update_filemem_view(STlinkGUI *gui) {
|
|||
g_free(basename);
|
||||
|
||||
stlink_gui_update_mem_view(gui, &gui->file_mem, gui->filemem_treeview);
|
||||
return(FALSE);
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static gpointer stlink_gui_populate_filemem_view(gpointer data) {
|
||||
|
|
@ -338,7 +338,7 @@ out: g_object_unref(file);
|
|||
}
|
||||
|
||||
g_idle_add((GSourceFunc)stlink_gui_update_filemem_view, gui);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
static void mem_jmp(GtkTreeView *view,
|
||||
|
|
@ -438,13 +438,13 @@ static gchar *dev_format_chip_id(guint32 chip_id) {
|
|||
|
||||
params = stlink_chipid_get_params(chip_id);
|
||||
|
||||
if (!params) { return(g_strdup_printf("0x%x", chip_id)); }
|
||||
if (!params) { return (g_strdup_printf("0x%x", chip_id)); }
|
||||
|
||||
return(g_strdup(params->dev_type));
|
||||
return (g_strdup(params->dev_type));
|
||||
}
|
||||
|
||||
static gchar *dev_format_mem_size(gsize flash_size) {
|
||||
return(g_strdup_printf("%u kB", (uint32_t)(flash_size / 1024)));
|
||||
return (g_strdup_printf("%u kB", (uint32_t)(flash_size / 1024)));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -585,7 +585,7 @@ static gboolean stlink_gui_write_flash_update(STlinkGUI *gui) {
|
|||
stlink_gui_set_sensitivity(gui, TRUE);
|
||||
gui->progress.activity_mode = FALSE;
|
||||
gtk_widget_hide(GTK_WIDGET(gui->progress.bar));
|
||||
return(FALSE);
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static gpointer stlink_gui_write_flash(gpointer data) {
|
||||
|
|
@ -601,7 +601,7 @@ static gpointer stlink_gui_write_flash(gpointer data) {
|
|||
}
|
||||
|
||||
g_idle_add((GSourceFunc)stlink_gui_write_flash_update, gui);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
static void flash_button_cb(GtkWidget *widget, gpointer data) {
|
||||
|
|
@ -648,13 +648,13 @@ int32_t export_to_file(const char*filename, const struct mem_t flash_mem) {
|
|||
printf("%s\n", filename);
|
||||
FILE * f = fopen(filename, "w");
|
||||
|
||||
if (f == NULL) { return(-1); }
|
||||
if (f == NULL) { return (-1); }
|
||||
|
||||
for (gsize i = 0; i < flash_mem.size; i++)
|
||||
if (fputc(flash_mem.memory[i], f) == EOF) { return(-1); }
|
||||
if (fputc(flash_mem.memory[i], f) == EOF) { return (-1); }
|
||||
|
||||
fclose(f);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static void export_button_cb(GtkWidget *widget, gpointer data) {
|
||||
|
|
@ -697,7 +697,7 @@ static gboolean progress_pulse_timeout(STlinkGUI *gui) {
|
|||
gtk_progress_bar_set_fraction(gui->progress.bar, gui->progress.fraction);
|
||||
}
|
||||
|
||||
return(TRUE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static void notebook_switch_page_cb(GtkNotebook *notebook,
|
||||
|
|
@ -901,5 +901,5 @@ int32_t main(int32_t argc, char **argv) {
|
|||
stlink_gui_init_dnd(gui);
|
||||
|
||||
gtk_main();
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -177,7 +177,7 @@ int32_t stlink_flash_loader_init(stlink_t *sl, flash_loader_t *fl) {
|
|||
// allocate the loader in SRAM
|
||||
if (stlink_flash_loader_write_to_sram(sl, &fl->loader_addr, &size) == -1) {
|
||||
WLOG("Failed to write flash loader to sram!\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
// allocate a one page buffer in SRAM right after loader
|
||||
|
|
@ -205,7 +205,7 @@ int32_t stlink_flash_loader_init(stlink_t *sl, flash_loader_t *fl) {
|
|||
stlink_write_debug32(sl, STLINK_REG_HFSR, hfsr);
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int32_t loader_v_dependent_assignment(stlink_t *sl,
|
||||
|
|
@ -235,7 +235,7 @@ static int32_t loader_v_dependent_assignment(stlink_t *sl,
|
|||
}
|
||||
}
|
||||
|
||||
return(retval);
|
||||
return (retval);
|
||||
}
|
||||
|
||||
int32_t stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, uint32_t* size) {
|
||||
|
|
@ -285,7 +285,7 @@ int32_t stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, uint
|
|||
loader_code_stm32f4, sizeof(loader_code_stm32f4),
|
||||
loader_code_stm32f4_lv, sizeof(loader_code_stm32f4_lv));
|
||||
|
||||
if (retval == -1) { return(retval); }
|
||||
if (retval == -1) { return (retval); }
|
||||
} else if (sl->core_id == STM32_CORE_ID_M7F_SWD ||
|
||||
sl->chip_id == STM32_CHIPID_F7 ||
|
||||
sl->chip_id == STM32_CHIPID_F76xxx ||
|
||||
|
|
@ -296,7 +296,7 @@ int32_t stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, uint
|
|||
loader_code_stm32f7, sizeof(loader_code_stm32f7),
|
||||
loader_code_stm32f7_lv, sizeof(loader_code_stm32f7_lv));
|
||||
|
||||
if (retval == -1) { return(retval); }
|
||||
if (retval == -1) { return (retval); }
|
||||
} else if (sl->chip_id == STM32_CHIPID_F0 ||
|
||||
sl->chip_id == STM32_CHIPID_F04 ||
|
||||
sl->chip_id == STM32_CHIPID_F0_CAN ||
|
||||
|
|
@ -315,18 +315,18 @@ int32_t stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, uint
|
|||
} else {
|
||||
ELOG("unknown coreid, not sure what flash loader to use, aborting! coreid: %x, chipid: %x\n",
|
||||
sl->core_id, sl->chip_id);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
memcpy(sl->q_buf, loader_code, loader_size);
|
||||
int32_t ret = stlink_write_mem32(sl, sl->sram_base, (uint16_t)loader_size);
|
||||
|
||||
if (ret) { return(ret); }
|
||||
if (ret) { return (ret); }
|
||||
|
||||
*addr = sl->sram_base;
|
||||
*size = loader_size;
|
||||
|
||||
return(0); // success
|
||||
return (0); // success
|
||||
}
|
||||
|
||||
int32_t stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t target, const uint8_t* buf, uint32_t size) {
|
||||
|
|
@ -339,7 +339,7 @@ int32_t stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t t
|
|||
|
||||
if (write_buffer_to_sram(sl, fl, buf, size) == -1) {
|
||||
ELOG("write_buffer_to_sram() == -1\n");
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if ((sl->flash_type == STM32_FLASH_TYPE_F1_XL) && (target >= FLASH_BANK2_START_ADDR)) {
|
||||
|
|
@ -404,7 +404,7 @@ int32_t stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t t
|
|||
goto error;
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
|
||||
error:
|
||||
dhcsr = dfsr = cfsr = hfsr = 0;
|
||||
|
|
@ -419,7 +419,7 @@ int32_t stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t t
|
|||
WLOG("MCU state: DHCSR 0x%X DFSR 0x%X CFSR 0x%X HFSR 0x%X\n", dhcsr, dfsr, cfsr, hfsr);
|
||||
}
|
||||
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -868,8 +868,7 @@ int32_t stlink_flashloader_stop(stlink_t *sl, flash_loader_t *fl) {
|
|||
(sl->flash_type == STM32_FLASH_TYPE_WB_WL)) {
|
||||
|
||||
clear_flash_cr_pg(sl, BANK_1);
|
||||
if ((sl->flash_type == STM32_FLASH_TYPE_H7 &&
|
||||
sl->chip_flags & CHIP_F_HAS_DUAL_BANK) ||
|
||||
if ((sl->flash_type == STM32_FLASH_TYPE_H7 && sl->chip_flags & CHIP_F_HAS_DUAL_BANK) ||
|
||||
sl->flash_type == STM32_FLASH_TYPE_F1_XL) {
|
||||
clear_flash_cr_pg(sl, BANK_2);
|
||||
}
|
||||
|
|
@ -886,9 +885,8 @@ int32_t stlink_flashloader_stop(stlink_t *sl, flash_loader_t *fl) {
|
|||
|
||||
// enable interrupt
|
||||
if (!stlink_read_debug32(sl, STLINK_REG_DHCSR, &dhcsr)) {
|
||||
stlink_write_debug32(sl, STLINK_REG_DHCSR,
|
||||
STLINK_REG_DHCSR_DBGKEY | STLINK_REG_DHCSR_C_DEBUGEN |
|
||||
(dhcsr & (~STLINK_REG_DHCSR_C_MASKINTS)));
|
||||
stlink_write_debug32(sl, STLINK_REG_DHCSR, STLINK_REG_DHCSR_DBGKEY | STLINK_REG_DHCSR_C_DEBUGEN |
|
||||
(dhcsr & (~STLINK_REG_DHCSR_C_MASKINTS)));
|
||||
}
|
||||
|
||||
// restore DMA state
|
||||
|
|
|
|||
|
|
@ -152,7 +152,7 @@ static void* TransformFunction(Md5Context* ctx, void const* data, uintmax_t size
|
|||
#undef GET
|
||||
#undef SET
|
||||
|
||||
return(ptr);
|
||||
return (ptr);
|
||||
}
|
||||
|
||||
/* EXPORTED FUNCTIONS */
|
||||
|
|
|
|||
|
|
@ -141,12 +141,12 @@ static int32_t get_usb_mass_storage_status(libusb_device_handle *handle, uint8_t
|
|||
|
||||
if (ret != LIBUSB_SUCCESS) {
|
||||
WLOG("%s: receiving failed: %d\n", __func__, ret);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (transferred != sizeof(csw)) {
|
||||
WLOG("%s: received unexpected amount: %d\n", __func__, transferred);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
uint32_t rsig = read_uint32(csw, 0);
|
||||
|
|
@ -157,12 +157,12 @@ static int32_t get_usb_mass_storage_status(libusb_device_handle *handle, uint8_t
|
|||
|
||||
if (rsig != USB_CSW_SIGNATURE) {
|
||||
WLOG("status signature was invalid: %#x\n", rsig);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
*tag = rtag;
|
||||
uint8_t rstatus = csw[12];
|
||||
return(rstatus);
|
||||
return (rstatus);
|
||||
}
|
||||
|
||||
static int32_t dump_CDB_command(uint8_t *cdb, uint8_t cdb_len) {
|
||||
|
|
@ -176,7 +176,7 @@ static int32_t dump_CDB_command(uint8_t *cdb, uint8_t cdb_len) {
|
|||
|
||||
sprintf(dbugp, "]\n");
|
||||
DLOG("%s",dbugblah);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -239,10 +239,10 @@ int32_t send_usb_mass_storage_command(libusb_device_handle *handle, uint8_t endp
|
|||
|
||||
if (ret != LIBUSB_SUCCESS) {
|
||||
WLOG("sending failed: %d\n", ret);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
return(this_tag);
|
||||
return (this_tag);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -332,7 +332,7 @@ int32_t send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_
|
|||
|
||||
if (ret != LIBUSB_SUCCESS) {
|
||||
WLOG("sending failed: %d\n", ret);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
// now, swallow up the status, so that things behave nicely...
|
||||
|
|
@ -342,7 +342,7 @@ int32_t send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_
|
|||
|
||||
if (status < 0) {
|
||||
WLOG("receiving status failed: %d\n", status);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (status != 0) {
|
||||
|
|
@ -351,10 +351,10 @@ int32_t send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_
|
|||
|
||||
if (status == 1) {
|
||||
get_sense(handle, endpoint_in, endpoint_out);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
return(real_transferred);
|
||||
return (real_transferred);
|
||||
}
|
||||
|
||||
int32_t stlink_q(stlink_t *sl) {
|
||||
|
|
@ -386,7 +386,7 @@ int32_t stlink_q(stlink_t *sl) {
|
|||
|
||||
if (ret != LIBUSB_SUCCESS) {
|
||||
WLOG("Receiving failed: %d\n", ret);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (real_transferred != rx_length) {
|
||||
|
|
@ -400,7 +400,7 @@ int32_t stlink_q(stlink_t *sl) {
|
|||
|
||||
if (status < 0) {
|
||||
WLOG("receiving status failed: %d\n", status);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (status != 0) {
|
||||
|
|
@ -409,7 +409,7 @@ int32_t stlink_q(stlink_t *sl) {
|
|||
|
||||
if (status == 1) {
|
||||
get_sense(sg->usb_handle, sg->ep_rep, sg->ep_req);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (received_tag != tag) {
|
||||
|
|
@ -418,10 +418,10 @@ int32_t stlink_q(stlink_t *sl) {
|
|||
}
|
||||
|
||||
if (rx_length > 0 && real_transferred != rx_length) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// TODO: thinking, cleanup
|
||||
|
|
@ -448,7 +448,7 @@ int32_t _stlink_sg_version(stlink_t *stl) {
|
|||
sl->cdb_cmd_blk[0] = STLINK_GET_VERSION;
|
||||
stl->q_len = 6;
|
||||
sl->q_addr = 0;
|
||||
return(stlink_q(stl));
|
||||
return (stlink_q(stl));
|
||||
}
|
||||
|
||||
// Get stlink mode:
|
||||
|
|
@ -461,9 +461,9 @@ int32_t _stlink_sg_current_mode(stlink_t *stl) {
|
|||
stl->q_len = 2;
|
||||
sl->q_addr = 0;
|
||||
|
||||
if (stlink_q(stl)) { return(-1); }
|
||||
if (stlink_q(stl)) { return (-1); }
|
||||
|
||||
return(stl->q_buf[0]);
|
||||
return (stl->q_buf[0]);
|
||||
}
|
||||
|
||||
// exit the mass mode and enter the swd debug mode.
|
||||
|
|
@ -473,7 +473,7 @@ int32_t _stlink_sg_enter_swd_mode(stlink_t *sl) {
|
|||
sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV1_ENTER;
|
||||
sg->cdb_cmd_blk[2] = STLINK_DEBUG_ENTER_SWD;
|
||||
sl->q_len = 0; // >0 -> aboard
|
||||
return(stlink_q(sl));
|
||||
return (stlink_q(sl));
|
||||
}
|
||||
|
||||
// exit the mass mode and enter the jtag debug mode.
|
||||
|
|
@ -485,7 +485,7 @@ int32_t _stlink_sg_enter_jtag_mode(stlink_t *sl) {
|
|||
sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV1_ENTER;
|
||||
sg->cdb_cmd_blk[2] = STLINK_DEBUG_ENTER_JTAG_RESET;
|
||||
sl->q_len = 0;
|
||||
return(stlink_q(sl));
|
||||
return (stlink_q(sl));
|
||||
}
|
||||
|
||||
// XXX kernel driver performs reset, the device temporally disappears
|
||||
|
|
@ -497,7 +497,7 @@ int32_t _stlink_sg_exit_dfu_mode(stlink_t *sl) {
|
|||
sg->cdb_cmd_blk[0] = STLINK_DFU_COMMAND;
|
||||
sg->cdb_cmd_blk[1] = STLINK_DFU_EXIT;
|
||||
sl->q_len = 0; // ??
|
||||
return(stlink_q(sl));
|
||||
return (stlink_q(sl));
|
||||
/*
|
||||
[135121.844564] sd 19:0:0:0: [sdb] Unhandled error code
|
||||
[135121.844569] sd 19:0:0:0: [sdb] Result: hostbyte=DID_ERROR driverbyte=DRIVER_OK
|
||||
|
|
@ -552,10 +552,10 @@ int32_t _stlink_sg_core_id(stlink_t *sl) {
|
|||
sg->q_addr = 0;
|
||||
ret = stlink_q(sl);
|
||||
|
||||
if (ret) { return(ret); }
|
||||
if (ret) { return (ret); }
|
||||
|
||||
sl->core_id = read_uint32(sl->q_buf, 0);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// arm-core reset -> halted state.
|
||||
|
|
@ -566,17 +566,17 @@ int32_t _stlink_sg_reset(stlink_t *sl) {
|
|||
sl->q_len = 2;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
// Reset through AIRCR so NRST does not need to be connected
|
||||
if (stlink_write_debug32(sl, STLINK_REG_AIRCR,
|
||||
STLINK_REG_AIRCR_VECTKEY | \
|
||||
STLINK_REG_AIRCR_SYSRESETREQ)) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
stlink_stat(sl, "core reset");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// arm-core reset -> halted state.
|
||||
|
|
@ -588,11 +588,11 @@ int32_t _stlink_sg_jtag_reset(stlink_t *sl, int32_t value) {
|
|||
sl->q_len = 3;
|
||||
sg->q_addr = 2;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_stat(sl, "core reset");
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// arm-core status: halted or running.
|
||||
|
|
@ -602,7 +602,7 @@ int32_t _stlink_sg_status(stlink_t *sl) {
|
|||
sg->cdb_cmd_blk[1] = STLINK_DEBUG_GETSTATUS;
|
||||
sl->q_len = 2;
|
||||
sg->q_addr = 0;
|
||||
return(stlink_q(sl));
|
||||
return (stlink_q(sl));
|
||||
}
|
||||
|
||||
// force the core into the debug mode -> halted state.
|
||||
|
|
@ -613,10 +613,10 @@ int32_t _stlink_sg_force_debug(stlink_t *sl) {
|
|||
sl->q_len = 2;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_stat(sl, "force debug");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// read all arm-core registers.
|
||||
|
|
@ -628,7 +628,7 @@ int32_t _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
|||
sl->q_len = 84;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_print_data(sl);
|
||||
|
||||
|
|
@ -648,7 +648,7 @@ int32_t _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
|||
regp->rw = read_uint32(sl->q_buf, 76);
|
||||
regp->rw2 = read_uint32(sl->q_buf, 80);
|
||||
|
||||
if (sl->verbose < 2) { return(0); }
|
||||
if (sl->verbose < 2) { return (0); }
|
||||
|
||||
DLOG("xpsr = 0x%08x\n", regp->xpsr);
|
||||
DLOG("main_sp = 0x%08x\n", regp->main_sp);
|
||||
|
|
@ -656,7 +656,7 @@ int32_t _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
|||
DLOG("rw = 0x%08x\n", regp->rw);
|
||||
DLOG("rw2 = 0x%08x\n", regp->rw2);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// read an arm-core register, the index must be in the range 0..20.
|
||||
|
|
@ -671,7 +671,7 @@ int32_t _stlink_sg_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp
|
|||
sl->q_len = 4;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
// 0 | 1 | ... | 15 | 16 | 17 | 18 | 19 | 20
|
||||
// 0-3 | 4-7 | ... | 60-63 | 64-67 | 68-71 | 72-75 | 76-79 | 80-83
|
||||
|
|
@ -701,7 +701,7 @@ int32_t _stlink_sg_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp
|
|||
regp->r[r_idx] = r;
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// write an arm-core register. Index:
|
||||
|
|
@ -719,10 +719,10 @@ int32_t _stlink_sg_write_reg(stlink_t *sl, uint32_t reg, int32_t idx) {
|
|||
sl->q_len = 2;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_stat(sl, "write reg");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// write a register of the debug module of the core.
|
||||
|
|
@ -752,11 +752,11 @@ int32_t _stlink_sg_run(stlink_t *sl, enum run_type type) {
|
|||
sl->q_len = 2;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_stat(sl, "run core");
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// step the arm-core.
|
||||
|
|
@ -767,10 +767,10 @@ int32_t _stlink_sg_step(stlink_t *sl) {
|
|||
sl->q_len = 2;
|
||||
sg->q_addr = 0;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_stat(sl, "step core");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// TODO: test and make delegate!
|
||||
|
|
@ -823,10 +823,10 @@ int32_t _stlink_sg_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
|
|||
sl->q_len = len;
|
||||
sg->q_addr = addr;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
stlink_print_data(sl);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// write a "len" bytes from the sl->q_buf to the memory, max 64 Bytes.
|
||||
|
|
@ -845,16 +845,16 @@ int32_t _stlink_sg_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
|
|||
ret = send_usb_mass_storage_command(sg->usb_handle,
|
||||
sg->ep_req, sg->cdb_cmd_blk, CDB_SL, 0, 0, 0);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
// This sends the data...
|
||||
ret = send_usb_data_only(sg->usb_handle,
|
||||
sg->ep_req, sg->ep_rep, sl->q_buf, len);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
stlink_print_data(sl);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// write a "len" bytes from the sl->q_buf to the memory, max Q_BUF_LEN bytes.
|
||||
|
|
@ -873,16 +873,16 @@ int32_t _stlink_sg_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
|
|||
ret = send_usb_mass_storage_command(sg->usb_handle,
|
||||
sg->ep_req, sg->cdb_cmd_blk, CDB_SL, 0, 0, 0);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
// This sends the data...
|
||||
ret = send_usb_data_only(sg->usb_handle,
|
||||
sg->ep_req, sg->ep_rep, sl->q_buf, len);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
stlink_print_data(sl);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// write one DWORD data to memory
|
||||
|
|
@ -894,7 +894,7 @@ int32_t _stlink_sg_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
|
|||
write_uint32(sg->cdb_cmd_blk + 2, addr);
|
||||
write_uint32(sg->cdb_cmd_blk + 6, data);
|
||||
sl->q_len = 2;
|
||||
return(stlink_q(sl));
|
||||
return (stlink_q(sl));
|
||||
}
|
||||
|
||||
// read one DWORD data from memory
|
||||
|
|
@ -906,10 +906,10 @@ int32_t _stlink_sg_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
|
|||
write_uint32(sg->cdb_cmd_blk + 2, addr);
|
||||
sl->q_len = 8;
|
||||
|
||||
if (stlink_q(sl)) { return(-1); }
|
||||
if (stlink_q(sl)) { return (-1); }
|
||||
|
||||
*data = read_uint32(sl->q_buf, 4);
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// exit the jtag or swd mode and enter the mass mode.
|
||||
|
|
@ -919,10 +919,10 @@ int32_t _stlink_sg_exit_debug_mode(stlink_t *stl) {
|
|||
clear_cdb(sl);
|
||||
sl->cdb_cmd_blk[1] = STLINK_DEBUG_EXIT;
|
||||
stl->q_len = 0; // >0 -> aboard
|
||||
return(stlink_q(stl));
|
||||
return (stlink_q(stl));
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// 1) open a sg device, switch the stlink from dfu to mass mode
|
||||
|
|
@ -975,7 +975,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
|
||||
if (slsg != NULL) { free(slsg); }
|
||||
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
memset(sl, 0, sizeof(stlink_t));
|
||||
|
|
@ -984,7 +984,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
WLOG("failed to init libusb context, wrong version of libraries?\n");
|
||||
free(sl);
|
||||
free(slsg);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
#if LIBUSB_API_VERSION < 0x01000106
|
||||
|
|
@ -1001,7 +1001,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
libusb_exit(slsg->libusb_ctx);
|
||||
free(sl);
|
||||
free(slsg);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
// TODO: Could read the interface config descriptor, and assert lots of the assumptions
|
||||
|
|
@ -1015,7 +1015,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
libusb_exit(slsg->libusb_ctx);
|
||||
free(sl);
|
||||
free(slsg);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
DLOG("Kernel driver was successfully detached\n");
|
||||
|
|
@ -1030,7 +1030,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
libusb_exit(slsg->libusb_ctx);
|
||||
free(sl);
|
||||
free(slsg);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1046,7 +1046,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
libusb_exit(slsg->libusb_ctx);
|
||||
free(sl);
|
||||
free(slsg);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1056,7 +1056,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
libusb_exit(slsg->libusb_ctx);
|
||||
free(sl);
|
||||
free(slsg);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
// assumption: endpoint config is fixed mang. really.
|
||||
|
|
@ -1072,7 +1072,7 @@ static stlink_t* stlink_open(const int32_t verbose) {
|
|||
sl->core_stat = TARGET_UNKNOWN;
|
||||
slsg->q_addr = 0;
|
||||
|
||||
return(sl);
|
||||
return (sl);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1082,24 +1082,24 @@ stlink_t* stlink_v1_open_inner(const int32_t verbose) {
|
|||
|
||||
if (sl == NULL) {
|
||||
ELOG("Could not open stlink device\n");
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
stlink_version(sl);
|
||||
|
||||
if ((sl->version.st_vid != STLINK_USB_VID_ST) || (sl->version.stlink_pid != STLINK_USB_PID_STLINK)) {
|
||||
ELOG("WTF? successfully opened, but unable to read version details. BROKEN!\n");
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
DLOG("Reading current mode...\n");
|
||||
|
||||
switch (stlink_current_mode(sl)) {
|
||||
case STLINK_DEV_MASS_MODE:
|
||||
return(sl);
|
||||
return (sl);
|
||||
case STLINK_DEV_DEBUG_MODE:
|
||||
// TODO go to mass?
|
||||
return(sl);
|
||||
return (sl);
|
||||
default:
|
||||
ILOG("Current mode unusable, trying to get back to a useful state...\n");
|
||||
break;
|
||||
|
|
@ -1113,16 +1113,16 @@ stlink_t* stlink_v1_open_inner(const int32_t verbose) {
|
|||
|
||||
if ((sl->version.st_vid != STLINK_USB_VID_ST) || (sl->version.stlink_pid != STLINK_USB_PID_STLINK)) {
|
||||
ELOG("WTF? successfully opened, but unable to read version details. BROKEN!\n");
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
return(sl);
|
||||
return (sl);
|
||||
}
|
||||
|
||||
stlink_t* stlink_v1_open(const int32_t verbose, int32_t reset) {
|
||||
stlink_t *sl = stlink_v1_open_inner(verbose);
|
||||
|
||||
if (sl == NULL) { return(NULL); }
|
||||
if (sl == NULL) { return (NULL); }
|
||||
|
||||
// by now, it _must_ be fully open and in a useful mode....
|
||||
stlink_enter_swd_mode(sl);
|
||||
|
|
@ -1132,5 +1132,5 @@ stlink_t* stlink_v1_open(const int32_t verbose, int32_t reset) {
|
|||
|
||||
stlink_load_device_params(sl);
|
||||
ILOG("Successfully opened a stlink v1 debugger\n");
|
||||
return(sl);
|
||||
return (sl);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@
|
|||
#include "register.h"
|
||||
|
||||
static inline uint32_t le_to_h_u32(const uint8_t* buf) {
|
||||
return((uint32_t)((uint32_t)buf[0] | (uint32_t)buf[1] << 8 | (uint32_t)buf[2] << 16 | (uint32_t)buf[3] << 24));
|
||||
return ((uint32_t)((uint32_t)buf[0] | (uint32_t)buf[1] << 8 | (uint32_t)buf[2] << 16 | (uint32_t)buf[3] << 24));
|
||||
}
|
||||
|
||||
static int32_t _stlink_match_speed_map(const uint32_t *map, uint32_t map_size, uint32_t khz) {
|
||||
|
|
@ -73,7 +73,7 @@ static int32_t _stlink_match_speed_map(const uint32_t *map, uint32_t map_size, u
|
|||
ILOG("Unable to match requested speed %d kHz, using %d kHz\n", khz, map[speed_index]);
|
||||
}
|
||||
|
||||
return(speed_index);
|
||||
return (speed_index);
|
||||
}
|
||||
|
||||
void _stlink_usb_close(stlink_t* sl) {
|
||||
|
|
@ -101,7 +101,7 @@ ssize_t send_recv(struct stlink_libusb* handle, int32_t terminate, unsigned char
|
|||
|
||||
if (t) {
|
||||
ELOG("%s send request failed: %s\n", cmd, libusb_error_name(t));
|
||||
return(-1);
|
||||
return (-1);
|
||||
} else if ((size_t)res != txsize) {
|
||||
ELOG("%s send request wrote %u bytes, instead of %u\n", cmd, (uint32_t)res, (uint32_t)txsize);
|
||||
}
|
||||
|
|
@ -111,7 +111,7 @@ ssize_t send_recv(struct stlink_libusb* handle, int32_t terminate, unsigned char
|
|||
|
||||
if (t) {
|
||||
ELOG("%s read reply failed: %s\n", cmd, libusb_error_name(t));
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/* Checking the command execution status stored in the first byte of the response */
|
||||
|
|
@ -139,7 +139,7 @@ ssize_t send_recv(struct stlink_libusb* handle, int32_t terminate, unsigned char
|
|||
default: DLOG("%s error (0x%02X)\n", cmd, rxbuf[0]); break;
|
||||
}
|
||||
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (check_error == CMD_CHECK_REP_LEN && res != (int32_t)rxsize) {
|
||||
|
|
@ -155,20 +155,20 @@ ssize_t send_recv(struct stlink_libusb* handle, int32_t terminate, unsigned char
|
|||
|
||||
if (t) {
|
||||
ELOG("%s read storage failed: %s\n", cmd, libusb_error_name(t));
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
// The STLink doesn't seem to evaluate the sequence number.
|
||||
handle->sg_transfer_idx++;
|
||||
}
|
||||
|
||||
return(res);
|
||||
return (res);
|
||||
}
|
||||
}
|
||||
|
||||
static inline int32_t send_only(struct stlink_libusb* handle, int32_t terminate, unsigned char* txbuf,
|
||||
uint32_t txsize, const char *cmd) {
|
||||
return((int32_t)send_recv(handle, terminate, txbuf, txsize, NULL, 0, CMD_CHECK_NO, cmd));
|
||||
return ((int32_t)send_recv(handle, terminate, txbuf, txsize, NULL, 0, CMD_CHECK_NO, cmd));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -190,7 +190,7 @@ static int32_t fill_command(stlink_t * sl, enum SCSI_Generic_Direction dir, uint
|
|||
cmd[i++] = 0; // logical unit
|
||||
cmd[i++] = 0xa; // command length
|
||||
}
|
||||
return(i);
|
||||
return (i);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_version(stlink_t *sl) {
|
||||
|
|
@ -214,7 +214,7 @@ int32_t _stlink_usb_version(stlink_t *sl) {
|
|||
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_REP_LEN, "GET_VERSION");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_target_voltage(stlink_t *sl) {
|
||||
|
|
@ -232,14 +232,14 @@ int32_t _stlink_usb_target_voltage(stlink_t *sl) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len, CMD_CHECK_REP_LEN, "GET_TARGET_VOLTAGE");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
factor = (rdata[3] << 24) | (rdata[2] << 16) | (rdata[1] << 8) | (rdata[0] << 0);
|
||||
reading = (rdata[7] << 24) | (rdata[6] << 16) | (rdata[5] << 8) | (rdata[4] << 0);
|
||||
voltage = 2400 * reading / factor;
|
||||
|
||||
return(voltage);
|
||||
return (voltage);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
|
||||
|
|
@ -256,12 +256,12 @@ int32_t _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len, CMD_CHECK_RETRY, "READDEBUGREG");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
*data = read_uint32(rdata, 4);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
|
||||
|
|
@ -278,11 +278,11 @@ int32_t _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
|
|||
write_uint32(&cmd[i + 4], data);
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len, CMD_CHECK_RETRY, "WRITEDEBUGREG");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_get_rw_status(stlink_t *sl) {
|
||||
if (sl->version.jtag_api == STLINK_JTAG_API_V1) { return(0); }
|
||||
if (sl->version.jtag_api == STLINK_JTAG_API_V1) { return (0); }
|
||||
|
||||
unsigned char* const rdata = sl->q_buf;
|
||||
struct stlink_libusb * const slu = sl->backend_data;
|
||||
|
|
@ -301,7 +301,7 @@ int32_t _stlink_usb_get_rw_status(stlink_t *sl) {
|
|||
ret = send_recv(slu, 1, cmd, slu->cmd_len, rdata, 2, CMD_CHECK_STATUS, "GETLASTRWSTATUS");
|
||||
}
|
||||
|
||||
return(ret < 0 ? -1 : 0);
|
||||
return (ret < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
|
||||
|
|
@ -317,13 +317,13 @@ int32_t _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
|
|||
write_uint16(&cmd[i + 4], len);
|
||||
ret = send_only(slu, 0, cmd, slu->cmd_len, "WRITEMEM_32BIT");
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
ret = send_only(slu, 1, data, len, "WRITEMEM_32BIT");
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
return(_stlink_usb_get_rw_status(sl));
|
||||
return (_stlink_usb_get_rw_status(sl));
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
|
||||
|
|
@ -345,13 +345,13 @@ int32_t _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
|
|||
write_uint16(&cmd[i + 4], len);
|
||||
ret = send_only(slu, 0, cmd, slu->cmd_len, "WRITEMEM_8BIT");
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
ret = send_only(slu, 1, data, len, "WRITEMEM_8BIT");
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_current_mode(stlink_t * sl) {
|
||||
|
|
@ -366,10 +366,10 @@ int32_t _stlink_usb_current_mode(stlink_t * sl) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_NO, "GET_CURRENT_MODE");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
return(sl->q_buf[0]);
|
||||
return (sl->q_buf[0]);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_core_id(stlink_t * sl) {
|
||||
|
|
@ -393,12 +393,12 @@ int32_t _stlink_usb_core_id(stlink_t * sl) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_STATUS, "READ_IDCODES");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
sl->core_id = read_uint32(data, offset);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_status_v2(stlink_t *sl) {
|
||||
|
|
@ -420,11 +420,11 @@ int32_t _stlink_usb_status_v2(stlink_t *sl) {
|
|||
}
|
||||
}
|
||||
|
||||
return(result);
|
||||
return (result);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_status(stlink_t * sl) {
|
||||
if (sl->version.jtag_api != STLINK_JTAG_API_V1) { return(_stlink_usb_status_v2(sl)); }
|
||||
if (sl->version.jtag_api != STLINK_JTAG_API_V1) { return (_stlink_usb_status_v2(sl)); }
|
||||
|
||||
struct stlink_libusb * const slu = sl->backend_data;
|
||||
unsigned char* const data = sl->q_buf;
|
||||
|
|
@ -449,7 +449,7 @@ int32_t _stlink_usb_status(stlink_t * sl) {
|
|||
sl->core_stat = TARGET_UNKNOWN;
|
||||
}
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_force_debug(stlink_t *sl) {
|
||||
|
|
@ -459,7 +459,7 @@ int32_t _stlink_usb_force_debug(stlink_t *sl) {
|
|||
|
||||
if (sl->version.jtag_api != STLINK_JTAG_API_V1) {
|
||||
res = _stlink_usb_write_debug32(sl, STLINK_REG_DHCSR, STLINK_REG_DHCSR_DBGKEY | STLINK_REG_DHCSR_C_HALT | STLINK_REG_DHCSR_C_DEBUGEN);
|
||||
return(res);
|
||||
return (res);
|
||||
}
|
||||
|
||||
unsigned char* const data = sl->q_buf;
|
||||
|
|
@ -472,7 +472,7 @@ int32_t _stlink_usb_force_debug(stlink_t *sl) {
|
|||
cmd[i++] = STLINK_DEBUG_FORCEDEBUG;
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "FORCEDEBUG");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_enter_swd_mode(stlink_t * sl) {
|
||||
|
|
@ -489,7 +489,7 @@ int32_t _stlink_usb_enter_swd_mode(stlink_t * sl) {
|
|||
cmd[i++] = STLINK_DEBUG_ENTER_SWD;
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "ENTER_SWD");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_exit_dfu_mode(stlink_t* sl) {
|
||||
|
|
@ -502,7 +502,7 @@ int32_t _stlink_usb_exit_dfu_mode(stlink_t* sl) {
|
|||
cmd[i++] = STLINK_DFU_EXIT;
|
||||
size = send_only(slu, 1, cmd, slu->cmd_len, "DFU_EXIT");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -525,7 +525,7 @@ int32_t _stlink_usb_reset(stlink_t * sl) {
|
|||
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "RESETSYS");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_jtag_reset(stlink_t * sl, int32_t value) {
|
||||
|
|
@ -541,7 +541,7 @@ int32_t _stlink_usb_jtag_reset(stlink_t * sl, int32_t value) {
|
|||
cmd[i++] = value;
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "DRIVE_NRST");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -568,7 +568,7 @@ int32_t _stlink_usb_step(stlink_t* sl) {
|
|||
cmd[i++] = STLINK_DEBUG_STEPCORE;
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "STEPCORE");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -584,7 +584,7 @@ int32_t _stlink_usb_run(stlink_t* sl, enum run_type type) {
|
|||
if (sl->version.jtag_api != STLINK_JTAG_API_V1) {
|
||||
res = _stlink_usb_write_debug32(sl, STLINK_REG_DHCSR, STLINK_REG_DHCSR_DBGKEY | STLINK_REG_DHCSR_C_DEBUGEN |
|
||||
((type==RUN_FLASH_LOADER)?STLINK_REG_DHCSR_C_MASKINTS:0));
|
||||
return(res);
|
||||
return (res);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -598,7 +598,7 @@ int32_t _stlink_usb_run(stlink_t* sl, enum run_type type) {
|
|||
cmd[i++] = STLINK_DEBUG_RUNCORE;
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "RUNCORE");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_set_swdclk(stlink_t* sl, int32_t clk_freq) {
|
||||
|
|
@ -641,7 +641,7 @@ int32_t _stlink_usb_set_swdclk(stlink_t* sl, int32_t clk_freq) {
|
|||
cmd[i++] = (clk_divisor >> 8) & 0xFF;
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "SWD_SET_FREQ");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
} else if (sl->version.stlink_v == 3) {
|
||||
int32_t speed_index;
|
||||
uint32_t map[STLINK_V3_MAX_FREQ_NB];
|
||||
|
|
@ -653,7 +653,7 @@ int32_t _stlink_usb_set_swdclk(stlink_t* sl, int32_t clk_freq) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, 52, CMD_CHECK_STATUS, "GET_COM_FREQ");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
int32_t speeds_size = data[8];
|
||||
|
|
@ -682,12 +682,12 @@ int32_t _stlink_usb_set_swdclk(stlink_t* sl, int32_t clk_freq) {
|
|||
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, 8, CMD_CHECK_STATUS, "SET_COM_FREQ");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
} else if (clk_freq) {
|
||||
WLOG("ST-Link firmware does not support frequency setup\n");
|
||||
}
|
||||
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_exit_debug_mode(stlink_t *sl) {
|
||||
|
|
@ -701,7 +701,7 @@ int32_t _stlink_usb_exit_debug_mode(stlink_t *sl) {
|
|||
|
||||
size = send_only(slu, 1, cmd, slu->cmd_len, "DEBUG_EXIT");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
|
||||
|
|
@ -718,13 +718,13 @@ int32_t _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, len, CMD_CHECK_NO, "READMEM_32BIT");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
sl->q_len = (int32_t)size;
|
||||
stlink_print_data(sl);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
||||
|
|
@ -746,7 +746,7 @@ int32_t _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_STATUS, "READALLREGS");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/* V1: regs data from offset 0 */
|
||||
|
|
@ -763,7 +763,7 @@ int32_t _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
|||
regp->rw = read_uint32(sl->q_buf, reg_offset + 76);
|
||||
regp->rw2 = read_uint32(sl->q_buf, reg_offset + 80);
|
||||
|
||||
if (sl->verbose < 2) { return(0); }
|
||||
if (sl->verbose < 2) { return (0); }
|
||||
|
||||
DLOG("xpsr = 0x%08x\n", regp->xpsr);
|
||||
DLOG("main_sp = 0x%08x\n", regp->main_sp);
|
||||
|
|
@ -771,7 +771,7 @@ int32_t _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
|
|||
DLOG("rw = 0x%08x\n", regp->rw);
|
||||
DLOG("rw2 = 0x%08x\n", regp->rw2);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp) {
|
||||
|
|
@ -796,7 +796,7 @@ int32_t _stlink_usb_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *reg
|
|||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "READREG");
|
||||
|
||||
if (size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
sl->q_len = (int32_t)size;
|
||||
|
|
@ -824,7 +824,7 @@ int32_t _stlink_usb_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *reg
|
|||
regp->r[r_idx] = r;
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* See section C1.6 of the ARMv7-M Architecture Reference Manual */
|
||||
|
|
@ -838,11 +838,11 @@ int32_t _stlink_usb_read_unsupported_reg(stlink_t *sl, int32_t r_idx, struct stl
|
|||
|
||||
ret = _stlink_usb_write_mem32(sl, STLINK_REG_DCRSR, 4);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
ret = _stlink_usb_read_mem32(sl, STLINK_REG_DCRDR, 4);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
r = read_uint32(sl->q_buf, 0);
|
||||
DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
|
||||
|
|
@ -862,7 +862,7 @@ int32_t _stlink_usb_read_unsupported_reg(stlink_t *sl, int32_t r_idx, struct stl
|
|||
break;
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp) {
|
||||
|
|
@ -870,19 +870,19 @@ int32_t _stlink_usb_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *r
|
|||
|
||||
ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
ret = _stlink_usb_read_unsupported_reg(sl, 0x21, regp);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
for (int32_t i = 0; i < 32; i++) {
|
||||
ret = _stlink_usb_read_unsupported_reg(sl, 0x40 + i, regp);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* See section C1.6 of the ARMv7-M Architecture Reference Manual */
|
||||
|
|
@ -893,7 +893,7 @@ int32_t _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int32_t r_
|
|||
/* These are held in the same register */
|
||||
ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
val = (uint8_t)(val >> 24);
|
||||
|
||||
|
|
@ -931,14 +931,14 @@ int32_t _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int32_t r_
|
|||
|
||||
ret = _stlink_usb_write_mem32(sl, STLINK_REG_DCRDR, 4);
|
||||
|
||||
if (ret == -1) { return(ret); }
|
||||
if (ret == -1) { return (ret); }
|
||||
|
||||
sl->q_buf[0] = (unsigned char)r_idx;
|
||||
sl->q_buf[1] = 0;
|
||||
sl->q_buf[2] = 0x01;
|
||||
sl->q_buf[3] = 0;
|
||||
|
||||
return(_stlink_usb_write_mem32(sl, STLINK_REG_DCRSR, 4));
|
||||
return (_stlink_usb_write_mem32(sl, STLINK_REG_DCRSR, 4));
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int32_t idx) {
|
||||
|
|
@ -961,7 +961,7 @@ int32_t _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int32_t idx) {
|
|||
write_uint32(&cmd[i], reg);
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_RETRY, "WRITEREG");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_enable_trace(stlink_t* sl, uint32_t frequency) {
|
||||
|
|
@ -979,7 +979,7 @@ int32_t _stlink_usb_enable_trace(stlink_t* sl, uint32_t frequency) {
|
|||
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_STATUS, "START_TRACE_RX");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_disable_trace(stlink_t* sl) {
|
||||
|
|
@ -995,7 +995,7 @@ int32_t _stlink_usb_disable_trace(stlink_t* sl) {
|
|||
|
||||
size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_STATUS, "STOP_TRACE_RX");
|
||||
|
||||
return(size < 0 ? -1 : 0);
|
||||
return (size < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int32_t _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, uint32_t size) {
|
||||
|
|
@ -1010,10 +1010,10 @@ int32_t _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, uint32_t size) {
|
|||
ssize_t send_size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len, CMD_CHECK_NO, "GET_TRACE_NB");
|
||||
|
||||
if (send_size < 0) {
|
||||
return(-1);
|
||||
return (-1);
|
||||
} else if (send_size != 2) {
|
||||
ELOG("STLINK_DEBUG_APIV2_GET_TRACE_NB reply size %d\n", (int32_t)send_size);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
uint16_t trace_count = read_uint16(sl->q_buf, 0);
|
||||
|
|
@ -1029,7 +1029,7 @@ int32_t _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, uint32_t size) {
|
|||
|
||||
if (t || res != (int32_t)trace_count) {
|
||||
ELOG("read_trace read error %d\n", t);
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1282,11 +1282,11 @@ stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect,
|
|||
_stlink_usb_set_swdclk(sl, freq);
|
||||
|
||||
stlink_target_connect(sl, connect);
|
||||
return(sl);
|
||||
return (sl);
|
||||
|
||||
on_libusb_error:
|
||||
stlink_close(sl);
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
|
||||
on_error:
|
||||
if (slu->libusb_ctx) { libusb_exit(slu->libusb_ctx); }
|
||||
|
|
@ -1295,7 +1295,7 @@ on_malloc_error:
|
|||
if (sl != NULL) { free(sl); }
|
||||
if (slu != NULL) { free(slu); }
|
||||
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
static uint32_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[], enum connect_type connect, int32_t freq) {
|
||||
|
|
@ -1329,7 +1329,7 @@ static uint32_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[],
|
|||
|
||||
if (!_sldevs) {
|
||||
*sldevs = NULL;
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* Open STLINKS and attach them to list */
|
||||
|
|
@ -1379,7 +1379,7 @@ static uint32_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[],
|
|||
|
||||
*sldevs = _sldevs;
|
||||
|
||||
return(slcur);
|
||||
return (slcur);
|
||||
}
|
||||
|
||||
size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int32_t freq) {
|
||||
|
|
@ -1392,11 +1392,11 @@ size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int32_t
|
|||
|
||||
r = libusb_init(NULL);
|
||||
|
||||
if (r < 0) { return(0); }
|
||||
if (r < 0) { return (0); }
|
||||
|
||||
cnt = libusb_get_device_list(NULL, &devs);
|
||||
|
||||
if (cnt < 0) { return(0); }
|
||||
if (cnt < 0) { return (0); }
|
||||
|
||||
slcnt = stlink_probe_usb_devs(devs, &sldevs, connect, freq);
|
||||
libusb_free_device_list(devs, 1);
|
||||
|
|
@ -1405,7 +1405,7 @@ size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int32_t
|
|||
|
||||
*stdevs = sldevs;
|
||||
|
||||
return(slcnt);
|
||||
return (slcnt);
|
||||
}
|
||||
|
||||
void stlink_probe_usb_free(stlink_t ***stdevs, uint32_t size) {
|
||||
|
|
|
|||
|
|
@ -118,11 +118,11 @@ int32_t getopt(int32_t argc, char* const argv[], const char* optstring) {
|
|||
|
||||
if (optcursor == NULL || *++optcursor == '\0') { ++optind; }
|
||||
|
||||
return(optchar);
|
||||
return (optchar);
|
||||
|
||||
no_more_optchars:
|
||||
optcursor = NULL;
|
||||
return(-1);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/* Implementation based on http://www.kernel.org/doc/man-pages/online/pages/man3/getopt.3.html */
|
||||
|
|
@ -141,10 +141,10 @@ int32_t getopt_long(int32_t argc,
|
|||
optarg = NULL;
|
||||
optopt = 0;
|
||||
|
||||
if (optind >= argc) { return(-1); }
|
||||
if (optind >= argc) { return (-1); }
|
||||
|
||||
if (strlen(argv[optind]) < 3 || strncmp(argv[optind], "--", 2) != 0) {
|
||||
return(getopt(argc, argv, optstring));
|
||||
return (getopt(argc, argv, optstring));
|
||||
}
|
||||
|
||||
// it's an option; starts with -- and is longer than two chars
|
||||
|
|
@ -198,5 +198,5 @@ int32_t getopt_long(int32_t argc,
|
|||
}
|
||||
|
||||
++optind;
|
||||
return(retval);
|
||||
return (retval);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,30 +10,30 @@ void *mmap (void *addr, uint32_t len, int32_t prot, int32_t flags, int32_t fd, i
|
|||
void *buf;
|
||||
ssize_t count;
|
||||
|
||||
if ( addr || fd == -1 || (prot & PROT_WRITE)) { return(MAP_FAILED); }
|
||||
if ( addr || fd == -1 || (prot & PROT_WRITE)) { return (MAP_FAILED); }
|
||||
|
||||
buf = malloc(len);
|
||||
|
||||
if ( NULL == buf ) { return(MAP_FAILED); }
|
||||
if ( NULL == buf ) { return (MAP_FAILED); }
|
||||
|
||||
if (lseek(fd, offset, SEEK_SET) != offset) {
|
||||
free(buf);
|
||||
return(MAP_FAILED);
|
||||
return (MAP_FAILED);
|
||||
}
|
||||
|
||||
count = read(fd, buf, len);
|
||||
|
||||
if (count != (ssize_t)len) {
|
||||
free (buf);
|
||||
return(MAP_FAILED);
|
||||
return (MAP_FAILED);
|
||||
}
|
||||
|
||||
return(buf);
|
||||
return (buf);
|
||||
(void)flags;
|
||||
}
|
||||
|
||||
int32_t munmap (void *addr, uint32_t len) {
|
||||
free (addr);
|
||||
return(0);
|
||||
return (0);
|
||||
(void)len;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ int32_t gettimeofday(struct timeval *tv, struct timezone *tz) {
|
|||
ULARGE_INTEGER ulint;
|
||||
static int32_t tzflag = 0;
|
||||
|
||||
if(NULL != tv) {
|
||||
if (NULL != tv) {
|
||||
GetSystemTimeAsFileTime(&ftime);
|
||||
ulint.LowPart = ftime.dwLowDateTime;
|
||||
ulint.HighPart = ftime.dwHighDateTime;
|
||||
|
|
@ -21,7 +21,7 @@ int32_t gettimeofday(struct timeval *tv, struct timezone *tz) {
|
|||
tv->tv_usec = (int32_t)(ulint.QuadPart % 10000000L);
|
||||
}
|
||||
|
||||
if(NULL != tz) {
|
||||
if (NULL != tz) {
|
||||
if (!tzflag) {
|
||||
_tzset();
|
||||
tzflag++;
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ int32_t win32_poll(struct pollfd *fds, uint32_t nfds, int32_t timo) {
|
|||
printf("Exiting select rc=%d\n", rc);
|
||||
#endif
|
||||
|
||||
if (rc <= 0) { return(rc); }
|
||||
if (rc <= 0) { return (rc); }
|
||||
|
||||
if (rc > 0) {
|
||||
for ( i = 0; i < nfds; ++i) {
|
||||
|
|
@ -98,7 +98,7 @@ int32_t win32_poll(struct pollfd *fds, uint32_t nfds, int32_t timo) {
|
|||
}
|
||||
}
|
||||
|
||||
return(rc);
|
||||
return (rc);
|
||||
}
|
||||
|
||||
static void set_connect_errno(int32_t winsock_err) {
|
||||
|
|
@ -135,7 +135,7 @@ SOCKET win32_socket(int32_t domain, int32_t type, int32_t protocol) {
|
|||
|
||||
if (fd == INVALID_SOCKET) { set_socket_errno(WSAGetLastError()); }
|
||||
|
||||
return(fd);
|
||||
return (fd);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -149,7 +149,7 @@ int32_t win32_connect(SOCKET fd, struct sockaddr *addr, socklen_t addr_len) {
|
|||
|
||||
if (rc == SOCKET_ERROR) { set_connect_errno(WSAGetLastError()); }
|
||||
|
||||
return(rc);
|
||||
return (rc);
|
||||
}
|
||||
|
||||
/* A wrapper around the accept() function.
|
||||
|
|
@ -164,7 +164,7 @@ SOCKET win32_accept(SOCKET fd, struct sockaddr *addr, socklen_t *addr_len) {
|
|||
newfd = (SOCKET)-1;
|
||||
}
|
||||
|
||||
return(newfd);
|
||||
return (newfd);
|
||||
}
|
||||
|
||||
/* A wrapper around the shutdown() function.
|
||||
|
|
@ -177,7 +177,7 @@ int32_t win32_shutdown(SOCKET fd, int32_t mode) {
|
|||
|
||||
if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
|
||||
|
||||
return(rc);
|
||||
return (rc);
|
||||
}
|
||||
|
||||
int32_t win32_close_socket(SOCKET fd) {
|
||||
|
|
@ -185,7 +185,7 @@ int32_t win32_close_socket(SOCKET fd) {
|
|||
|
||||
if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
|
||||
|
||||
return(rc);
|
||||
return (rc);
|
||||
}
|
||||
|
||||
ssize_t win32_write_socket(SOCKET fd, void *buf, int32_t n) {
|
||||
|
|
@ -193,7 +193,7 @@ ssize_t win32_write_socket(SOCKET fd, void *buf, int32_t n) {
|
|||
|
||||
if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
|
||||
|
||||
return(rc);
|
||||
return (rc);
|
||||
}
|
||||
|
||||
ssize_t win32_read_socket(SOCKET fd, void *buf, int32_t n) {
|
||||
|
|
@ -201,7 +201,7 @@ ssize_t win32_read_socket(SOCKET fd, void *buf, int32_t n) {
|
|||
|
||||
if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
|
||||
|
||||
return(rc);
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -244,7 +244,7 @@ cont:
|
|||
}
|
||||
|
||||
*lasts = s;
|
||||
return(tok);
|
||||
return (tok);
|
||||
}
|
||||
|
||||
} while (sc != 0);
|
||||
|
|
@ -260,7 +260,7 @@ char *win32_strsep (char **stringp, const char *delim) {
|
|||
char *tok;
|
||||
|
||||
if ((s = *stringp) == NULL) {
|
||||
return(NULL);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
for (tok = s; ;) {
|
||||
|
|
@ -276,7 +276,7 @@ char *win32_strsep (char **stringp, const char *delim) {
|
|||
}
|
||||
|
||||
*stringp = s;
|
||||
return(tok);
|
||||
return (tok);
|
||||
}
|
||||
|
||||
} while (sc != 0);
|
||||
|
|
@ -301,7 +301,7 @@ int32_t usleep(uint32_t waitTime) {
|
|||
WaitForSingleObject(timer, INFINITE);
|
||||
CloseHandle(timer);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
LARGE_INTEGER perf_cnt, start, now;
|
||||
|
|
@ -313,7 +313,7 @@ int32_t usleep(uint32_t waitTime) {
|
|||
QueryPerformanceCounter((LARGE_INTEGER*)&now);
|
||||
} while ((now.QuadPart - start.QuadPart) / (float)perf_cnt.QuadPart * 1000 * 1000 < waitTime);
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ static bool execute_test(const struct Test * test) {
|
|||
strcpy(cmd_line, test->cmd_line);
|
||||
|
||||
for (char * tok = strtok(cmd_line, " "); tok; tok = strtok(NULL, " ")) {
|
||||
if ((size_t)ac >= sizeof(av) / sizeof(av[0])) return(false);
|
||||
if ((size_t)ac >= sizeof(av) / sizeof(av[0])) return (false);
|
||||
|
||||
av[ac] = tok;
|
||||
++ac;
|
||||
|
|
@ -75,7 +75,7 @@ static bool execute_test(const struct Test * test) {
|
|||
}
|
||||
|
||||
printf("[%s] (%d) %s\n", ret ? "OK" : "ERROR", res, test->cmd_line);
|
||||
return(ret);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
static struct Test tests[] = {
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ int32_t main(void) { // main() ripped out of old stlink-hw.c
|
|||
|
||||
stlink_t *sl = stlink_v1_open(99, 1);
|
||||
|
||||
if (sl == NULL) return(0);
|
||||
if (sl == NULL) return (0);
|
||||
|
||||
// we are in mass mode, go to swd
|
||||
stlink_enter_swd_mode(sl);
|
||||
|
|
@ -212,5 +212,5 @@ int32_t main(void) { // main() ripped out of old stlink-hw.c
|
|||
|
||||
// fflush(stderr);
|
||||
// fflush(stdout);
|
||||
return(EXIT_SUCCESS);
|
||||
return (EXIT_SUCCESS);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ int32_t main(int32_t ac, char** av) {
|
|||
|
||||
if (reset == 0) {
|
||||
usage();
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
sl = stlink_open_usb(10, reset, NULL, 0);
|
||||
|
|
@ -125,5 +125,5 @@ int32_t main(int32_t ac, char** av) {
|
|||
stlink_close(sl);
|
||||
}
|
||||
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue