arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-03-03 08:46:05 +00:00
Code Issues Releases Wiki Activity

style(core): systemview editorconfig reformat

Browse Source
This commit is contained in:
Ondrej Mikle 2020-12-14 15:20:56 +01:00 committed by Pavol Rusnak
parent 9411756c42
commit 4cf91b128d
14 changed files with 8463 additions and 8463 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

226
core/embed/segger/Config/Global.h
View File

@ -1,113 +1,113 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
---------------------------------------------------------------------- ----------------------------------------------------------------------
File : Global.h File : Global.h
Purpose : Global types Purpose : Global types
In case your application already has a Global.h, you should In case your application already has a Global.h, you should
merge the files. In order to use Segger code, the types merge the files. In order to use Segger code, the types
U8, U16, U32, I8, I16, I32 need to be defined in Global.h; U8, U16, U32, I8, I16, I32 need to be defined in Global.h;
additional definitions do not hurt. additional definitions do not hurt.
Revision: $Rev: 12501 $ Revision: $Rev: 12501 $
---------------------------END-OF-HEADER------------------------------ ---------------------------END-OF-HEADER------------------------------
*/ */
#ifndef GLOBAL_H // Guard against multiple inclusion #ifndef GLOBAL_H // Guard against multiple inclusion
#define GLOBAL_H #define GLOBAL_H
#define U8 unsigned char #define U8 unsigned char
#define I8 signed char #define I8 signed char
#define U16 unsigned short #define U16 unsigned short
#define I16 signed short #define I16 signed short
#ifdef __x86_64__ #ifdef __x86_64__
#define U32 unsigned #define U32 unsigned
#define I32 int #define I32 int
#else #else
#define U32 unsigned long #define U32 unsigned long
#define I32 signed long #define I32 signed long
#endif #endif
// //
// CC_NO_LONG_SUPPORT can be defined to compile test // CC_NO_LONG_SUPPORT can be defined to compile test
// without long support for compilers that do not // without long support for compilers that do not
// support C99 and its long type. // support C99 and its long type.
// //
#ifdef CC_NO_LONG_SUPPORT #ifdef CC_NO_LONG_SUPPORT
#define PTR_ADDR U32 #define PTR_ADDR U32
#else // Supports long type. #else // Supports long type.
#if defined(_WIN32) && !defined(__clang__) && !defined(__MINGW32__) #if defined(_WIN32) && !defined(__clang__) && !defined(__MINGW32__)
// //
// Microsoft VC6 compiler related // Microsoft VC6 compiler related
// //
#define U64 unsigned __int64 #define U64 unsigned __int64
#define U128 unsigned __int128 #define U128 unsigned __int128
#define I64 __int64 #define I64 __int64
#define I128 __int128 #define I128 __int128
#if _MSC_VER <= 1200 #if _MSC_VER <= 1200
#define U64_C(x) x##UI64 #define U64_C(x) x##UI64
#else #else
#define U64_C(x) x##ULL #define U64_C(x) x##ULL
#endif #endif
#else #else
// //
// C99 compliant compiler // C99 compliant compiler
// //
#define U64 unsigned long long #define U64 unsigned long long
#define I64 signed long long #define I64 signed long long
#define U64_C(x) x##ULL #define U64_C(x) x##ULL
#endif #endif
#if (defined(_WIN64) || defined(__LP64__)) // 64-bit symbols used by Visual Studio and GCC, maybe others as well. #if (defined(_WIN64) || defined(__LP64__)) // 64-bit symbols used by Visual Studio and GCC, maybe others as well.
#define PTR_ADDR U64 #define PTR_ADDR U64
#else #else
#define PTR_ADDR U32 #define PTR_ADDR U32
#endif #endif
#endif // Supports long type. #endif // Supports long type.
#endif // Avoid multiple inclusion #endif // Avoid multiple inclusion
/*************************** End of file ****************************/ /*************************** End of file ****************************/

856
core/embed/segger/Config/SEGGER_RTT_Conf.h
View File

@ -1,428 +1,428 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
---------------------------END-OF-HEADER------------------------------ ---------------------------END-OF-HEADER------------------------------
File : SEGGER_RTT_Conf.h File : SEGGER_RTT_Conf.h
Purpose : Implementation of SEGGER real-time transfer (RTT) which Purpose : Implementation of SEGGER real-time transfer (RTT) which
allows real-time communication on targets which support allows real-time communication on targets which support
debugger memory accesses while the CPU is running. debugger memory accesses while the CPU is running.
Revision: $Rev: 21386 $ Revision: $Rev: 21386 $
*/ */
#ifndef SEGGER_RTT_CONF_H #ifndef SEGGER_RTT_CONF_H
#define SEGGER_RTT_CONF_H #define SEGGER_RTT_CONF_H
#ifdef __IAR_SYSTEMS_ICC__ #ifdef __IAR_SYSTEMS_ICC__
#include <intrinsics.h> #include <intrinsics.h>
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Defines, configurable * Defines, configurable
* *
********************************************************************** **********************************************************************
*/ */
// //
// Take in and set to correct values for Cortex-A systems with CPU cache // Take in and set to correct values for Cortex-A systems with CPU cache
// //
//#define SEGGER_RTT_CPU_CACHE_LINE_SIZE (32) // Largest cache line size (in bytes) in the current system //#define SEGGER_RTT_CPU_CACHE_LINE_SIZE (32) // Largest cache line size (in bytes) in the current system
//#define SEGGER_RTT_UNCACHED_OFF (0xFB000000) // Address alias where RTT CB and buffers can be accessed uncached //#define SEGGER_RTT_UNCACHED_OFF (0xFB000000) // Address alias where RTT CB and buffers can be accessed uncached
// //
// Most common case: // Most common case:
// Up-channel 0: RTT // Up-channel 0: RTT
// Up-channel 1: SystemView // Up-channel 1: SystemView
// //
#ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS #ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS
#define SEGGER_RTT_MAX_NUM_UP_BUFFERS (3) // Max. number of up-buffers (T->H) available on this target (Default: 3) #define SEGGER_RTT_MAX_NUM_UP_BUFFERS (3) // Max. number of up-buffers (T->H) available on this target (Default: 3)
#endif #endif
// //
// Most common case: // Most common case:
// Down-channel 0: RTT // Down-channel 0: RTT
// Down-channel 1: SystemView // Down-channel 1: SystemView
// //
#ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS #ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS
#define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (3) // Max. number of down-buffers (H->T) available on this target (Default: 3) #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (3) // Max. number of down-buffers (H->T) available on this target (Default: 3)
#endif #endif
#ifndef BUFFER_SIZE_UP #ifndef BUFFER_SIZE_UP
#define BUFFER_SIZE_UP (1024) // Size of the buffer for terminal output of target, up to host (Default: 1k) #define BUFFER_SIZE_UP (1024) // Size of the buffer for terminal output of target, up to host (Default: 1k)
#endif #endif
#ifndef BUFFER_SIZE_DOWN #ifndef BUFFER_SIZE_DOWN
#define BUFFER_SIZE_DOWN (16) // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16) #define BUFFER_SIZE_DOWN (16) // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16)
#endif #endif
#ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE #ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE
#define SEGGER_RTT_PRINTF_BUFFER_SIZE (64u) // Size of buffer for RTT printf to bulk-send chars via RTT (Default: 64) #define SEGGER_RTT_PRINTF_BUFFER_SIZE (64u) // Size of buffer for RTT printf to bulk-send chars via RTT (Default: 64)
#endif #endif
#ifndef SEGGER_RTT_MODE_DEFAULT #ifndef SEGGER_RTT_MODE_DEFAULT
#define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0) #define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0)
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT memcpy configuration * RTT memcpy configuration
* *
* memcpy() is good for large amounts of data, * memcpy() is good for large amounts of data,
* but the overhead is big for small amounts, which are usually stored via RTT. * but the overhead is big for small amounts, which are usually stored via RTT.
* With SEGGER_RTT_MEMCPY_USE_BYTELOOP a simple byte loop can be used instead. * With SEGGER_RTT_MEMCPY_USE_BYTELOOP a simple byte loop can be used instead.
* *
* SEGGER_RTT_MEMCPY() can be used to replace standard memcpy() in RTT functions. * SEGGER_RTT_MEMCPY() can be used to replace standard memcpy() in RTT functions.
* This is may be required with memory access restrictions, * This is may be required with memory access restrictions,
* such as on Cortex-A devices with MMU. * such as on Cortex-A devices with MMU.
*/ */
#ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP #ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP
#define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0 // 0: Use memcpy/SEGGER_RTT_MEMCPY, 1: Use a simple byte-loop #define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0 // 0: Use memcpy/SEGGER_RTT_MEMCPY, 1: Use a simple byte-loop
#endif #endif
// //
// Example definition of SEGGER_RTT_MEMCPY to external memcpy with GCC toolchains and Cortex-A targets // Example definition of SEGGER_RTT_MEMCPY to external memcpy with GCC toolchains and Cortex-A targets
// //
//#if ((defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)) && (defined (__ARM_ARCH_7A__)) //#if ((defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)) && (defined (__ARM_ARCH_7A__))
// #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) SEGGER_memcpy((pDest), (pSrc), (NumBytes)) // #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) SEGGER_memcpy((pDest), (pSrc), (NumBytes))
//#endif //#endif
// //
// Target is not allowed to perform other RTT operations while string still has not been stored completely. // Target is not allowed to perform other RTT operations while string still has not been stored completely.
// Otherwise we would probably end up with a mixed string in the buffer. // Otherwise we would probably end up with a mixed string in the buffer.
// If using RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here. // If using RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here.
// //
// SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4. // SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4.
// Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches. // Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches.
// When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly. // When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly.
// (Higher priority = lower priority number) // (Higher priority = lower priority number)
// Default value for embOS: 128u // Default value for embOS: 128u
// Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) ) // Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
// In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC // In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC
// or define SEGGER_RTT_LOCK() to completely disable interrupts. // or define SEGGER_RTT_LOCK() to completely disable interrupts.
// //
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20) #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20)
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for SEGGER Embedded Studio, * RTT lock configuration for SEGGER Embedded Studio,
* Rowley CrossStudio and GCC * Rowley CrossStudio and GCC
*/ */
#if ((defined(__SES_ARM) || defined(__SES_RISCV) || defined(__CROSSWORKS_ARM) || defined(__GNUC__) || defined(__clang__)) && !defined (__CC_ARM) && !defined(WIN32)) #if ((defined(__SES_ARM) || defined(__SES_RISCV) || defined(__CROSSWORKS_ARM) || defined(__GNUC__) || defined(__clang__)) && !defined (__CC_ARM) && !defined(WIN32))
#if (defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_8M_BASE__)) #if (defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_8M_BASE__))
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
__asm volatile ("mrs %0, primask \n\t" \ __asm volatile ("mrs %0, primask \n\t" \
"movs r1, #1 \n\t" \ "movs r1, #1 \n\t" \
"msr primask, r1 \n\t" \ "msr primask, r1 \n\t" \
: "=r" (_SEGGER_RTT__LockState) \ : "=r" (_SEGGER_RTT__LockState) \
: \ : \
: "r1", "cc" \ : "r1", "cc" \
); );
#define SEGGER_RTT_UNLOCK() __asm volatile ("msr primask, %0 \n\t" \ #define SEGGER_RTT_UNLOCK() __asm volatile ("msr primask, %0 \n\t" \
: \ : \
: "r" (_SEGGER_RTT__LockState) \ : "r" (_SEGGER_RTT__LockState) \
: \ : \
); \ ); \
} }
#elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__)) #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__))
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
#endif #endif
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
__asm volatile ("mrs %0, basepri \n\t" \ __asm volatile ("mrs %0, basepri \n\t" \
"mov r1, %1 \n\t" \ "mov r1, %1 \n\t" \
"msr basepri, r1 \n\t" \ "msr basepri, r1 \n\t" \
: "=r" (_SEGGER_RTT__LockState) \ : "=r" (_SEGGER_RTT__LockState) \
: "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY) \ : "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY) \
: "r1", "cc" \ : "r1", "cc" \
); );
#define SEGGER_RTT_UNLOCK() __asm volatile ("msr basepri, %0 \n\t" \ #define SEGGER_RTT_UNLOCK() __asm volatile ("msr basepri, %0 \n\t" \
: \ : \
: "r" (_SEGGER_RTT__LockState) \ : "r" (_SEGGER_RTT__LockState) \
: \ : \
); \ ); \
} }
#elif defined(__ARM_ARCH_7A__) #elif defined(__ARM_ARCH_7A__)
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
__asm volatile ("mrs r1, CPSR \n\t" \ __asm volatile ("mrs r1, CPSR \n\t" \
"mov %0, r1 \n\t" \ "mov %0, r1 \n\t" \
"orr r1, r1, #0xC0 \n\t" \ "orr r1, r1, #0xC0 \n\t" \
"msr CPSR_c, r1 \n\t" \ "msr CPSR_c, r1 \n\t" \
: "=r" (_SEGGER_RTT__LockState) \ : "=r" (_SEGGER_RTT__LockState) \
: \ : \
: "r1", "cc" \ : "r1", "cc" \
); );
#define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \ #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \
"mrs r1, CPSR \n\t" \ "mrs r1, CPSR \n\t" \
"bic r1, r1, #0xC0 \n\t" \ "bic r1, r1, #0xC0 \n\t" \
"and r0, r0, #0xC0 \n\t" \ "and r0, r0, #0xC0 \n\t" \
"orr r1, r1, r0 \n\t" \ "orr r1, r1, r0 \n\t" \
"msr CPSR_c, r1 \n\t" \ "msr CPSR_c, r1 \n\t" \
: \ : \
: "r" (_SEGGER_RTT__LockState) \ : "r" (_SEGGER_RTT__LockState) \
: "r0", "r1", "cc" \ : "r0", "r1", "cc" \
); \ ); \
} }
#elif defined(__riscv) || defined(__riscv_xlen) #elif defined(__riscv) || defined(__riscv_xlen)
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
__asm volatile ("csrr %0, mstatus \n\t" \ __asm volatile ("csrr %0, mstatus \n\t" \
"csrci mstatus, 8 \n\t" \ "csrci mstatus, 8 \n\t" \
"andi %0, %0, 8 \n\t" \ "andi %0, %0, 8 \n\t" \
: "=r" (_SEGGER_RTT__LockState) \ : "=r" (_SEGGER_RTT__LockState) \
: \ : \
: \ : \
); );
#define SEGGER_RTT_UNLOCK() __asm volatile ("csrr a1, mstatus \n\t" \ #define SEGGER_RTT_UNLOCK() __asm volatile ("csrr a1, mstatus \n\t" \
"or %0, %0, a1 \n\t" \ "or %0, %0, a1 \n\t" \
"csrs mstatus, %0 \n\t" \ "csrs mstatus, %0 \n\t" \
: \ : \
: "r" (_SEGGER_RTT__LockState) \ : "r" (_SEGGER_RTT__LockState) \
: "a1" \ : "a1" \
); \ ); \
} }
#else #else
#define SEGGER_RTT_LOCK() #define SEGGER_RTT_LOCK()
#define SEGGER_RTT_UNLOCK() #define SEGGER_RTT_UNLOCK()
#endif #endif
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for IAR EWARM * RTT lock configuration for IAR EWARM
*/ */
#ifdef __ICCARM__ #ifdef __ICCARM__
#if (defined (__ARM6M__) && (__CORE__ == __ARM6M__)) || \ #if (defined (__ARM6M__) && (__CORE__ == __ARM6M__)) || \
(defined (__ARM8M_BASELINE__) && (__CORE__ == __ARM8M_BASELINE__)) (defined (__ARM8M_BASELINE__) && (__CORE__ == __ARM8M_BASELINE__))
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = __get_PRIMASK(); \ _SEGGER_RTT__LockState = __get_PRIMASK(); \
__set_PRIMASK(1); __set_PRIMASK(1);
#define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \
} }
#elif (defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) || \ #elif (defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) || \
(defined (__ARM7M__) && (__CORE__ == __ARM7M__)) || \ (defined (__ARM7M__) && (__CORE__ == __ARM7M__)) || \
(defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) || \ (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) || \
(defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__))
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
#endif #endif
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = __get_BASEPRI(); \ _SEGGER_RTT__LockState = __get_BASEPRI(); \
__set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY); __set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
#define SEGGER_RTT_UNLOCK() __set_BASEPRI(_SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() __set_BASEPRI(_SEGGER_RTT__LockState); \
} }
#elif (defined (__ARM7A__) && (__CORE__ == __ARM7A__)) || \ #elif (defined (__ARM7A__) && (__CORE__ == __ARM7A__)) || \
(defined (__ARM7R__) && (__CORE__ == __ARM7R__)) (defined (__ARM7R__) && (__CORE__ == __ARM7R__))
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
__asm volatile ("mrs r1, CPSR \n\t" \ __asm volatile ("mrs r1, CPSR \n\t" \
"mov %0, r1 \n\t" \ "mov %0, r1 \n\t" \
"orr r1, r1, #0xC0 \n\t" \ "orr r1, r1, #0xC0 \n\t" \
"msr CPSR_c, r1 \n\t" \ "msr CPSR_c, r1 \n\t" \
: "=r" (_SEGGER_RTT__LockState) \ : "=r" (_SEGGER_RTT__LockState) \
: \ : \
: "r1", "cc" \ : "r1", "cc" \
); );
#define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \ #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \
"mrs r1, CPSR \n\t" \ "mrs r1, CPSR \n\t" \
"bic r1, r1, #0xC0 \n\t" \ "bic r1, r1, #0xC0 \n\t" \
"and r0, r0, #0xC0 \n\t" \ "and r0, r0, #0xC0 \n\t" \
"orr r1, r1, r0 \n\t" \ "orr r1, r1, r0 \n\t" \
"msr CPSR_c, r1 \n\t" \ "msr CPSR_c, r1 \n\t" \
: \ : \
: "r" (_SEGGER_RTT__LockState) \ : "r" (_SEGGER_RTT__LockState) \
: "r0", "r1", "cc" \ : "r0", "r1", "cc" \
); \ ); \
} }
#endif #endif
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for IAR RX * RTT lock configuration for IAR RX
*/ */
#ifdef __ICCRX__ #ifdef __ICCRX__
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned long _SEGGER_RTT__LockState; \ unsigned long _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = __get_interrupt_state(); \ _SEGGER_RTT__LockState = __get_interrupt_state(); \
__disable_interrupt(); __disable_interrupt();
#define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \
} }
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for IAR RL78 * RTT lock configuration for IAR RL78
*/ */
#ifdef __ICCRL78__ #ifdef __ICCRL78__
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
__istate_t _SEGGER_RTT__LockState; \ __istate_t _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = __get_interrupt_state(); \ _SEGGER_RTT__LockState = __get_interrupt_state(); \
__disable_interrupt(); __disable_interrupt();
#define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \
} }
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for KEIL ARM * RTT lock configuration for KEIL ARM
*/ */
#ifdef __CC_ARM #ifdef __CC_ARM
#if (defined __TARGET_ARCH_6S_M) #if (defined __TARGET_ARCH_6S_M)
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
register unsigned char _SEGGER_RTT__PRIMASK __asm( "primask"); \ register unsigned char _SEGGER_RTT__PRIMASK __asm( "primask"); \
_SEGGER_RTT__LockState = _SEGGER_RTT__PRIMASK; \ _SEGGER_RTT__LockState = _SEGGER_RTT__PRIMASK; \
_SEGGER_RTT__PRIMASK = 1u; \ _SEGGER_RTT__PRIMASK = 1u; \
__schedule_barrier(); __schedule_barrier();
#define SEGGER_RTT_UNLOCK() _SEGGER_RTT__PRIMASK = _SEGGER_RTT__LockState; \ #define SEGGER_RTT_UNLOCK() _SEGGER_RTT__PRIMASK = _SEGGER_RTT__LockState; \
__schedule_barrier(); \ __schedule_barrier(); \
} }
#elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M)) #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M))
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
#endif #endif
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
register unsigned char BASEPRI __asm( "basepri"); \ register unsigned char BASEPRI __asm( "basepri"); \
_SEGGER_RTT__LockState = BASEPRI; \ _SEGGER_RTT__LockState = BASEPRI; \
BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY; \ BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY; \
__schedule_barrier(); __schedule_barrier();
#define SEGGER_RTT_UNLOCK() BASEPRI = _SEGGER_RTT__LockState; \ #define SEGGER_RTT_UNLOCK() BASEPRI = _SEGGER_RTT__LockState; \
__schedule_barrier(); \ __schedule_barrier(); \
} }
#endif #endif
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for TI ARM * RTT lock configuration for TI ARM
*/ */
#ifdef __TI_ARM__ #ifdef __TI_ARM__
#if defined (__TI_ARM_V6M0__) #if defined (__TI_ARM_V6M0__)
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = __get_PRIMASK(); \ _SEGGER_RTT__LockState = __get_PRIMASK(); \
__set_PRIMASK(1); __set_PRIMASK(1);
#define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \
} }
#elif (defined (__TI_ARM_V7M3__) || defined (__TI_ARM_V7M4__)) #elif (defined (__TI_ARM_V7M3__) || defined (__TI_ARM_V7M4__))
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
#endif #endif
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned int _SEGGER_RTT__LockState; \ unsigned int _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = _set_interrupt_priority(SEGGER_RTT_MAX_INTERRUPT_PRIORITY); _SEGGER_RTT__LockState = _set_interrupt_priority(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
#define SEGGER_RTT_UNLOCK() _set_interrupt_priority(_SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() _set_interrupt_priority(_SEGGER_RTT__LockState); \
} }
#endif #endif
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for CCRX * RTT lock configuration for CCRX
*/ */
#ifdef __RX #ifdef __RX
#include <machine.h> #include <machine.h>
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
unsigned long _SEGGER_RTT__LockState; \ unsigned long _SEGGER_RTT__LockState; \
_SEGGER_RTT__LockState = get_psw() & 0x010000; \ _SEGGER_RTT__LockState = get_psw() & 0x010000; \
clrpsw_i(); clrpsw_i();
#define SEGGER_RTT_UNLOCK() set_psw(get_psw() | _SEGGER_RTT__LockState); \ #define SEGGER_RTT_UNLOCK() set_psw(get_psw() | _SEGGER_RTT__LockState); \
} }
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration for embOS Simulation on Windows * RTT lock configuration for embOS Simulation on Windows
* (Can also be used for generic RTT locking with embOS) * (Can also be used for generic RTT locking with embOS)
*/ */
#if defined(WIN32) || defined(SEGGER_RTT_LOCK_EMBOS) #if defined(WIN32) || defined(SEGGER_RTT_LOCK_EMBOS)
void OS_SIM_EnterCriticalSection(void); void OS_SIM_EnterCriticalSection(void);
void OS_SIM_LeaveCriticalSection(void); void OS_SIM_LeaveCriticalSection(void);
#define SEGGER_RTT_LOCK() { \ #define SEGGER_RTT_LOCK() { \
OS_SIM_EnterCriticalSection(); OS_SIM_EnterCriticalSection();
#define SEGGER_RTT_UNLOCK() OS_SIM_LeaveCriticalSection(); \ #define SEGGER_RTT_UNLOCK() OS_SIM_LeaveCriticalSection(); \
} }
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT lock configuration fallback * RTT lock configuration fallback
*/ */
#ifndef SEGGER_RTT_LOCK #ifndef SEGGER_RTT_LOCK
#define SEGGER_RTT_LOCK() // Lock RTT (nestable) (i.e. disable interrupts) #define SEGGER_RTT_LOCK() // Lock RTT (nestable) (i.e. disable interrupts)
#endif #endif
#ifndef SEGGER_RTT_UNLOCK #ifndef SEGGER_RTT_UNLOCK
#define SEGGER_RTT_UNLOCK() // Unlock RTT (nestable) (i.e. enable previous interrupt lock state) #define SEGGER_RTT_UNLOCK() // Unlock RTT (nestable) (i.e. enable previous interrupt lock state)
#endif #endif
#endif #endif
/*************************** End of file ****************************/ /*************************** End of file ****************************/

172
core/embed/segger/Config/SEGGER_SYSVIEW_Conf.h
View File

@ -1,86 +1,86 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
-------------------------- END-OF-HEADER ----------------------------- -------------------------- END-OF-HEADER -----------------------------
File : SEGGER_SYSVIEW_Conf.h File : SEGGER_SYSVIEW_Conf.h
Purpose : SEGGER SystemView configuration file. Purpose : SEGGER SystemView configuration file.
Set defines which deviate from the defaults (see SEGGER_SYSVIEW_ConfDefaults.h) here. Set defines which deviate from the defaults (see SEGGER_SYSVIEW_ConfDefaults.h) here.
Revision: $Rev: 21292 $ Revision: $Rev: 21292 $
Additional information: Additional information:
Required defines which must be set are: Required defines which must be set are:
SEGGER_SYSVIEW_GET_TIMESTAMP SEGGER_SYSVIEW_GET_TIMESTAMP
SEGGER_SYSVIEW_GET_INTERRUPT_ID SEGGER_SYSVIEW_GET_INTERRUPT_ID
For known compilers and cores, these might be set to good defaults For known compilers and cores, these might be set to good defaults
in SEGGER_SYSVIEW_ConfDefaults.h. in SEGGER_SYSVIEW_ConfDefaults.h.
SystemView needs a (nestable) locking mechanism. SystemView needs a (nestable) locking mechanism.
If not defined, the RTT locking mechanism is used, If not defined, the RTT locking mechanism is used,
which then needs to be properly configured. which then needs to be properly configured.
*/ */
#ifndef SEGGER_SYSVIEW_CONF_H #ifndef SEGGER_SYSVIEW_CONF_H
#define SEGGER_SYSVIEW_CONF_H #define SEGGER_SYSVIEW_CONF_H
/********************************************************************* /*********************************************************************
* *
* Defines, configurable * Defines, configurable
* *
********************************************************************** **********************************************************************
*/ */
/********************************************************************* /*********************************************************************
* TODO: Add your defines here. * * TODO: Add your defines here. *
********************************************************************** **********************************************************************
*/ */
#define SEGGER_SYSVIEW_BUFFER_SECTION "CCMRAM" #define SEGGER_SYSVIEW_BUFFER_SECTION "CCMRAM"
#endif // SEGGER_SYSVIEW_CONF_H #endif // SEGGER_SYSVIEW_CONF_H
/*************************** End of file ****************************/ /*************************** End of file ****************************/

496
core/embed/segger/SEGGER/SEGGER.h
View File

@ -1,248 +1,248 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
---------------------------------------------------------------------- ----------------------------------------------------------------------
File : SEGGER.h File : SEGGER.h
Purpose : Global types etc & general purpose utility functions Purpose : Global types etc & general purpose utility functions
Revision: $Rev: 18102 $ Revision: $Rev: 18102 $
---------------------------END-OF-HEADER------------------------------ ---------------------------END-OF-HEADER------------------------------
*/ */
#ifndef SEGGER_H // Guard against multiple inclusion #ifndef SEGGER_H // Guard against multiple inclusion
#define SEGGER_H #define SEGGER_H
#include <stdarg.h> // For va_list. #include <stdarg.h> // For va_list.
#include "Global.h" // Type definitions: U8, U16, U32, I8, I16, I32 #include "Global.h" // Type definitions: U8, U16, U32, I8, I16, I32
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { /* Make sure we have C-declarations in C++ programs */ extern "C" { /* Make sure we have C-declarations in C++ programs */
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Keywords/specifiers * Keywords/specifiers
* *
********************************************************************** **********************************************************************
*/ */
#ifndef INLINE #ifndef INLINE
#if (defined(__ICCARM__) || defined(__RX) || defined(__ICCRX__)) #if (defined(__ICCARM__) || defined(__RX) || defined(__ICCRX__))
// //
// Other known compilers. // Other known compilers.
// //
#define INLINE inline #define INLINE inline
#else #else
#if (defined(_WIN32) && !defined(__clang__)) #if (defined(_WIN32) && !defined(__clang__))
// //
// Microsoft VC6 and newer. // Microsoft VC6 and newer.
// Force inlining without cost checking. // Force inlining without cost checking.
// //
#define INLINE __forceinline #define INLINE __forceinline
#elif defined(__GNUC__) || defined(__clang__) #elif defined(__GNUC__) || defined(__clang__)
// //
// Force inlining with GCC + clang // Force inlining with GCC + clang
// //
#define INLINE inline __attribute__((always_inline)) #define INLINE inline __attribute__((always_inline))
#elif (defined(__CC_ARM)) #elif (defined(__CC_ARM))
// //
// Force inlining with ARMCC (Keil) // Force inlining with ARMCC (Keil)
// //
#define INLINE __inline #define INLINE __inline
#else #else
// //
// Unknown compilers. // Unknown compilers.
// //
#define INLINE #define INLINE
#endif #endif
#endif #endif
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Function-like macros * Function-like macros
* *
********************************************************************** **********************************************************************
*/ */
#define SEGGER_COUNTOF(a) (sizeof((a))/sizeof((a)[0])) #define SEGGER_COUNTOF(a) (sizeof((a))/sizeof((a)[0]))
#define SEGGER_MIN(a,b) (((a) < (b)) ? (a) : (b)) #define SEGGER_MIN(a,b) (((a) < (b)) ? (a) : (b))
#define SEGGER_MAX(a,b) (((a) > (b)) ? (a) : (b)) #define SEGGER_MAX(a,b) (((a) > (b)) ? (a) : (b))
#ifndef SEGGER_USE_PARA // Some compiler complain about unused parameters. #ifndef SEGGER_USE_PARA // Some compiler complain about unused parameters.
#define SEGGER_USE_PARA(Para) (void)Para // This works for most compilers. #define SEGGER_USE_PARA(Para) (void)Para // This works for most compilers.
#endif #endif
#define SEGGER_ADDR2PTR(Type, Addr) (/*lint -e(923) -e(9078)*/((Type*)((PTR_ADDR)(Addr)))) // Allow cast from address to pointer. #define SEGGER_ADDR2PTR(Type, Addr) (/*lint -e(923) -e(9078)*/((Type*)((PTR_ADDR)(Addr)))) // Allow cast from address to pointer.
#define SEGGER_PTR2ADDR(p) (/*lint -e(923) -e(9078)*/((PTR_ADDR)(p))) // Allow cast from pointer to address. #define SEGGER_PTR2ADDR(p) (/*lint -e(923) -e(9078)*/((PTR_ADDR)(p))) // Allow cast from pointer to address.
#define SEGGER_PTR2PTR(Type, p) (/*lint -e(740) -e(826) -e(9079) -e(9087)*/((Type*)(p))) // Allow cast from one pointer type to another (ignore different size). #define SEGGER_PTR2PTR(Type, p) (/*lint -e(740) -e(826) -e(9079) -e(9087)*/((Type*)(p))) // Allow cast from one pointer type to another (ignore different size).
#define SEGGER_PTR_DISTANCE(p0, p1) (SEGGER_PTR2ADDR(p0) - SEGGER_PTR2ADDR(p1)) #define SEGGER_PTR_DISTANCE(p0, p1) (SEGGER_PTR2ADDR(p0) - SEGGER_PTR2ADDR(p1))
/********************************************************************* /*********************************************************************
* *
* Defines * Defines
* *
********************************************************************** **********************************************************************
*/ */
#define SEGGER_PRINTF_FLAG_ADJLEFT (1 << 0) #define SEGGER_PRINTF_FLAG_ADJLEFT (1 << 0)
#define SEGGER_PRINTF_FLAG_SIGNFORCE (1 << 1) #define SEGGER_PRINTF_FLAG_SIGNFORCE (1 << 1)
#define SEGGER_PRINTF_FLAG_SIGNSPACE (1 << 2) #define SEGGER_PRINTF_FLAG_SIGNSPACE (1 << 2)
#define SEGGER_PRINTF_FLAG_PRECEED (1 << 3) #define SEGGER_PRINTF_FLAG_PRECEED (1 << 3)
#define SEGGER_PRINTF_FLAG_ZEROPAD (1 << 4) #define SEGGER_PRINTF_FLAG_ZEROPAD (1 << 4)
#define SEGGER_PRINTF_FLAG_NEGATIVE (1 << 5) #define SEGGER_PRINTF_FLAG_NEGATIVE (1 << 5)
/********************************************************************* /*********************************************************************
* *
* Types * Types
* *
********************************************************************** **********************************************************************
*/ */
typedef struct { typedef struct {
char* pBuffer; char* pBuffer;
int BufferSize; int BufferSize;
int Cnt; int Cnt;
} SEGGER_BUFFER_DESC; } SEGGER_BUFFER_DESC;
typedef struct { typedef struct {
unsigned int CacheLineSize; // 0: No Cache. Most Systems such as ARM9 use a 32 bytes cache line size. unsigned int CacheLineSize; // 0: No Cache. Most Systems such as ARM9 use a 32 bytes cache line size.
void (*pfDMB) (void); // Optional DMB function for Data Memory Barrier to make sure all memory operations are completed. void (*pfDMB) (void); // Optional DMB function for Data Memory Barrier to make sure all memory operations are completed.
void (*pfClean) (void *p, unsigned long NumBytes); // Optional clean function for cached memory. void (*pfClean) (void *p, unsigned long NumBytes); // Optional clean function for cached memory.
void (*pfInvalidate)(void *p, unsigned long NumBytes); // Optional invalidate function for cached memory. void (*pfInvalidate)(void *p, unsigned long NumBytes); // Optional invalidate function for cached memory.
} SEGGER_CACHE_CONFIG; } SEGGER_CACHE_CONFIG;
typedef struct SEGGER_SNPRINTF_CONTEXT_struct SEGGER_SNPRINTF_CONTEXT; typedef struct SEGGER_SNPRINTF_CONTEXT_struct SEGGER_SNPRINTF_CONTEXT;
struct SEGGER_SNPRINTF_CONTEXT_struct { struct SEGGER_SNPRINTF_CONTEXT_struct {
void* pContext; // Application specific context. void* pContext; // Application specific context.
SEGGER_BUFFER_DESC* pBufferDesc; // Buffer descriptor to use for output. SEGGER_BUFFER_DESC* pBufferDesc; // Buffer descriptor to use for output.
void (*pfFlush)(SEGGER_SNPRINTF_CONTEXT* pContext); // Callback executed once the buffer is full. Callback decides if the buffer gets cleared to store more or not. void (*pfFlush)(SEGGER_SNPRINTF_CONTEXT* pContext); // Callback executed once the buffer is full. Callback decides if the buffer gets cleared to store more or not.
}; };
typedef struct { typedef struct {
void (*pfStoreChar) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, char c); void (*pfStoreChar) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, char c);
int (*pfPrintUnsigned) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, U32 v, unsigned Base, char Flags, int Width, int Precision); int (*pfPrintUnsigned) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, U32 v, unsigned Base, char Flags, int Width, int Precision);
int (*pfPrintInt) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, I32 v, unsigned Base, char Flags, int Width, int Precision); int (*pfPrintInt) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, I32 v, unsigned Base, char Flags, int Width, int Precision);
} SEGGER_PRINTF_API; } SEGGER_PRINTF_API;
typedef void (*SEGGER_pFormatter)(SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, const SEGGER_PRINTF_API* pApi, va_list* pParamList, char Lead, int Width, int Precision); typedef void (*SEGGER_pFormatter)(SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, const SEGGER_PRINTF_API* pApi, va_list* pParamList, char Lead, int Width, int Precision);
typedef struct SEGGER_PRINTF_FORMATTER { typedef struct SEGGER_PRINTF_FORMATTER {
struct SEGGER_PRINTF_FORMATTER* pNext; // Pointer to next formatter. struct SEGGER_PRINTF_FORMATTER* pNext; // Pointer to next formatter.
SEGGER_pFormatter pfFormatter; // Formatter function. SEGGER_pFormatter pfFormatter; // Formatter function.
char Specifier; // Format specifier. char Specifier; // Format specifier.
} SEGGER_PRINTF_FORMATTER; } SEGGER_PRINTF_FORMATTER;
typedef struct { typedef struct {
U32 (*pfGetHPTimestamp)(void); // Mandatory, pfGetHPTimestamp U32 (*pfGetHPTimestamp)(void); // Mandatory, pfGetHPTimestamp
int (*pfGetUID) (U8 abUID[16]); // Optional, pfGetUID int (*pfGetUID) (U8 abUID[16]); // Optional, pfGetUID
} SEGGER_BSP_API; } SEGGER_BSP_API;
/********************************************************************* /*********************************************************************
* *
* Utility functions * Utility functions
* *
********************************************************************** **********************************************************************
*/ */
// //
// Memory operations. // Memory operations.
// //
void SEGGER_ARM_memcpy(void* pDest, const void* pSrc, int NumBytes); void SEGGER_ARM_memcpy(void* pDest, const void* pSrc, int NumBytes);
void SEGGER_memcpy (void* pDest, const void* pSrc, unsigned NumBytes); void SEGGER_memcpy (void* pDest, const void* pSrc, unsigned NumBytes);
void SEGGER_memxor (void* pDest, const void* pSrc, unsigned NumBytes); void SEGGER_memxor (void* pDest, const void* pSrc, unsigned NumBytes);
// //
// String functions. // String functions.
// //
int SEGGER_atoi (const char* s); int SEGGER_atoi (const char* s);
int SEGGER_isalnum (int c); int SEGGER_isalnum (int c);
int SEGGER_isalpha (int c); int SEGGER_isalpha (int c);
unsigned SEGGER_strlen (const char* s); unsigned SEGGER_strlen (const char* s);
int SEGGER_tolower (int c); int SEGGER_tolower (int c);
int SEGGER_strcasecmp (const char* sText1, const char* sText2); int SEGGER_strcasecmp (const char* sText1, const char* sText2);
int SEGGER_strncasecmp(const char *sText1, const char *sText2, unsigned Count); int SEGGER_strncasecmp(const char *sText1, const char *sText2, unsigned Count);
// //
// Buffer/printf related. // Buffer/printf related.
// //
void SEGGER_StoreChar (SEGGER_BUFFER_DESC* pBufferDesc, char c); void SEGGER_StoreChar (SEGGER_BUFFER_DESC* pBufferDesc, char c);
void SEGGER_PrintUnsigned(SEGGER_BUFFER_DESC* pBufferDesc, U32 v, unsigned Base, int Precision); void SEGGER_PrintUnsigned(SEGGER_BUFFER_DESC* pBufferDesc, U32 v, unsigned Base, int Precision);
void SEGGER_PrintInt (SEGGER_BUFFER_DESC* pBufferDesc, I32 v, unsigned Base, int Precision); void SEGGER_PrintInt (SEGGER_BUFFER_DESC* pBufferDesc, I32 v, unsigned Base, int Precision);
int SEGGER_snprintf (char* pBuffer, int BufferSize, const char* sFormat, ...); int SEGGER_snprintf (char* pBuffer, int BufferSize, const char* sFormat, ...);
int SEGGER_vsnprintf (char* pBuffer, int BufferSize, const char* sFormat, va_list ParamList); int SEGGER_vsnprintf (char* pBuffer, int BufferSize, const char* sFormat, va_list ParamList);
int SEGGER_vsnprintfEx (SEGGER_SNPRINTF_CONTEXT* pContext, const char* sFormat, va_list ParamList); int SEGGER_vsnprintfEx (SEGGER_SNPRINTF_CONTEXT* pContext, const char* sFormat, va_list ParamList);
int SEGGER_PRINTF_AddFormatter (SEGGER_PRINTF_FORMATTER* pFormatter, SEGGER_pFormatter pfFormatter, char c); int SEGGER_PRINTF_AddFormatter (SEGGER_PRINTF_FORMATTER* pFormatter, SEGGER_pFormatter pfFormatter, char c);
void SEGGER_PRINTF_AddDoubleFormatter (void); void SEGGER_PRINTF_AddDoubleFormatter (void);
void SEGGER_PRINTF_AddIPFormatter (void); void SEGGER_PRINTF_AddIPFormatter (void);
void SEGGER_PRINTF_AddBLUEFormatter (void); void SEGGER_PRINTF_AddBLUEFormatter (void);
void SEGGER_PRINTF_AddCONNECTFormatter(void); void SEGGER_PRINTF_AddCONNECTFormatter(void);
void SEGGER_PRINTF_AddSSLFormatter (void); void SEGGER_PRINTF_AddSSLFormatter (void);
void SEGGER_PRINTF_AddSSHFormatter (void); void SEGGER_PRINTF_AddSSHFormatter (void);
void SEGGER_PRINTF_AddHTMLFormatter (void); void SEGGER_PRINTF_AddHTMLFormatter (void);
// //
// BSP abstraction API. // BSP abstraction API.
// //
int SEGGER_BSP_GetUID (U8 abUID[16]); int SEGGER_BSP_GetUID (U8 abUID[16]);
int SEGGER_BSP_GetUID32(U32* pUID); int SEGGER_BSP_GetUID32(U32* pUID);
void SEGGER_BSP_SetAPI (const SEGGER_BSP_API* pAPI); void SEGGER_BSP_SetAPI (const SEGGER_BSP_API* pAPI);
void SEGGER_BSP_SeedUID (void); void SEGGER_BSP_SeedUID (void);
// //
// Other API. // Other API.
// //
void SEGGER_VERSION_GetString(char acText[8], unsigned Version); void SEGGER_VERSION_GetString(char acText[8], unsigned Version);
#if defined(__cplusplus) #if defined(__cplusplus)
} /* Make sure we have C-declarations in C++ programs */ } /* Make sure we have C-declarations in C++ programs */
#endif #endif
#endif // Avoid multiple inclusion #endif // Avoid multiple inclusion
/*************************** End of file ****************************/ /*************************** End of file ****************************/

4130
core/embed/segger/SEGGER/SEGGER_RTT.c
View File

File diff suppressed because it is too large Load Diff

836
core/embed/segger/SEGGER/SEGGER_RTT.h
View File

@ -1,418 +1,418 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
---------------------------END-OF-HEADER------------------------------ ---------------------------END-OF-HEADER------------------------------
File : SEGGER_RTT.h File : SEGGER_RTT.h
Purpose : Implementation of SEGGER real-time transfer which allows Purpose : Implementation of SEGGER real-time transfer which allows
real-time communication on targets which support debugger real-time communication on targets which support debugger
memory accesses while the CPU is running. memory accesses while the CPU is running.
Revision: $Rev: 20869 $ Revision: $Rev: 20869 $
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#ifndef SEGGER_RTT_H #ifndef SEGGER_RTT_H
#define SEGGER_RTT_H #define SEGGER_RTT_H
#include "SEGGER_RTT_Conf.h" #include "SEGGER_RTT_Conf.h"
/********************************************************************* /*********************************************************************
* *
* Defines, defaults * Defines, defaults
* *
********************************************************************** **********************************************************************
*/ */
#ifndef RTT_USE_ASM #ifndef RTT_USE_ASM
#if (defined __SES_ARM) // SEGGER Embedded Studio #if (defined __SES_ARM) // SEGGER Embedded Studio
#define _CC_HAS_RTT_ASM_SUPPORT 1 #define _CC_HAS_RTT_ASM_SUPPORT 1
#elif (defined __CROSSWORKS_ARM) // Rowley Crossworks #elif (defined __CROSSWORKS_ARM) // Rowley Crossworks
#define _CC_HAS_RTT_ASM_SUPPORT 1 #define _CC_HAS_RTT_ASM_SUPPORT 1
#elif (defined __ARMCC_VERSION) // ARM compiler #elif (defined __ARMCC_VERSION) // ARM compiler
#if (__ARMCC_VERSION >= 6000000) // ARM compiler V6.0 and later is clang based #if (__ARMCC_VERSION >= 6000000) // ARM compiler V6.0 and later is clang based
#define _CC_HAS_RTT_ASM_SUPPORT 1 #define _CC_HAS_RTT_ASM_SUPPORT 1
#else #else
#define _CC_HAS_RTT_ASM_SUPPORT 0 #define _CC_HAS_RTT_ASM_SUPPORT 0
#endif #endif
#elif (defined __GNUC__) // GCC #elif (defined __GNUC__) // GCC
#define _CC_HAS_RTT_ASM_SUPPORT 1 #define _CC_HAS_RTT_ASM_SUPPORT 1
#elif (defined __clang__) // Clang compiler #elif (defined __clang__) // Clang compiler
#define _CC_HAS_RTT_ASM_SUPPORT 1 #define _CC_HAS_RTT_ASM_SUPPORT 1
#elif ((defined __IASMARM__) || (defined __ICCARM__)) // IAR assembler/compiler #elif ((defined __IASMARM__) || (defined __ICCARM__)) // IAR assembler/compiler
#define _CC_HAS_RTT_ASM_SUPPORT 1 #define _CC_HAS_RTT_ASM_SUPPORT 1
#else #else
#define _CC_HAS_RTT_ASM_SUPPORT 0 #define _CC_HAS_RTT_ASM_SUPPORT 0
#endif #endif
#if ((defined __IASMARM__) || (defined __ICCARM__)) // IAR assembler/compiler #if ((defined __IASMARM__) || (defined __ICCARM__)) // IAR assembler/compiler
// //
// IAR assembler / compiler // IAR assembler / compiler
// //
#if (__VER__ < 6300000) #if (__VER__ < 6300000)
#define VOLATILE #define VOLATILE
#else #else
#define VOLATILE volatile #define VOLATILE volatile
#endif #endif
#if (defined __ARM7M__) // Needed for old versions that do not know the define yet #if (defined __ARM7M__) // Needed for old versions that do not know the define yet
#if (__CORE__ == __ARM7M__) // Cortex-M3 #if (__CORE__ == __ARM7M__) // Cortex-M3
#define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_HAS_RTT_ASM_SUPPORT 1
#endif #endif
#endif #endif
#if (defined __ARM7EM__) // Needed for old versions that do not know the define yet #if (defined __ARM7EM__) // Needed for old versions that do not know the define yet
#if (__CORE__ == __ARM7EM__) // Cortex-M4/M7 #if (__CORE__ == __ARM7EM__) // Cortex-M4/M7
#define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_HAS_RTT_ASM_SUPPORT 1
#define _CORE_NEEDS_DMB 1 #define _CORE_NEEDS_DMB 1
#define RTT__DMB() asm VOLATILE ("DMB"); #define RTT__DMB() asm VOLATILE ("DMB");
#endif #endif
#endif #endif
#if (defined __ARM8M_BASELINE__) // Needed for old versions that do not know the define yet #if (defined __ARM8M_BASELINE__) // Needed for old versions that do not know the define yet
#if (__CORE__ == __ARM8M_BASELINE__) // Cortex-M23 #if (__CORE__ == __ARM8M_BASELINE__) // Cortex-M23
#define _CORE_HAS_RTT_ASM_SUPPORT 0 #define _CORE_HAS_RTT_ASM_SUPPORT 0
#define _CORE_NEEDS_DMB 1 #define _CORE_NEEDS_DMB 1
#define RTT__DMB() asm VOLATILE ("DMB"); #define RTT__DMB() asm VOLATILE ("DMB");
#endif #endif
#endif #endif
#if (defined __ARM8M_MAINLINE__) // Needed for old versions that do not know the define yet #if (defined __ARM8M_MAINLINE__) // Needed for old versions that do not know the define yet
#if (__CORE__ == __ARM8M_MAINLINE__) // Cortex-M33 #if (__CORE__ == __ARM8M_MAINLINE__) // Cortex-M33
#define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_HAS_RTT_ASM_SUPPORT 1
#define _CORE_NEEDS_DMB 1 #define _CORE_NEEDS_DMB 1
#define RTT__DMB() asm VOLATILE ("DMB"); #define RTT__DMB() asm VOLATILE ("DMB");
#endif #endif
#endif #endif
#else #else
// //
// GCC / Clang // GCC / Clang
// //
#if (defined __ARM_ARCH_7M__) // Cortex-M3 #if (defined __ARM_ARCH_7M__) // Cortex-M3
#define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_HAS_RTT_ASM_SUPPORT 1
#elif (defined __ARM_ARCH_7EM__) // Cortex-M4/M7 #elif (defined __ARM_ARCH_7EM__) // Cortex-M4/M7
#define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_HAS_RTT_ASM_SUPPORT 1
#define _CORE_NEEDS_DMB 1 #define _CORE_NEEDS_DMB 1
#define RTT__DMB() __asm volatile ("dmb\n" : : :); #define RTT__DMB() __asm volatile ("dmb\n" : : :);
#elif (defined __ARM_ARCH_8M_BASE__) // Cortex-M23 #elif (defined __ARM_ARCH_8M_BASE__) // Cortex-M23
#define _CORE_HAS_RTT_ASM_SUPPORT 0 #define _CORE_HAS_RTT_ASM_SUPPORT 0
#define _CORE_NEEDS_DMB 1 #define _CORE_NEEDS_DMB 1
#define RTT__DMB() __asm volatile ("dmb\n" : : :); #define RTT__DMB() __asm volatile ("dmb\n" : : :);
#elif (defined __ARM_ARCH_8M_MAIN__) // Cortex-M33 #elif (defined __ARM_ARCH_8M_MAIN__) // Cortex-M33
#define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_HAS_RTT_ASM_SUPPORT 1
#define _CORE_NEEDS_DMB 1 #define _CORE_NEEDS_DMB 1
#define RTT__DMB() __asm volatile ("dmb\n" : : :); #define RTT__DMB() __asm volatile ("dmb\n" : : :);
#else #else
#define _CORE_HAS_RTT_ASM_SUPPORT 0 #define _CORE_HAS_RTT_ASM_SUPPORT 0
#endif #endif
#endif #endif
// //
// If IDE and core support the ASM version, enable ASM version by default // If IDE and core support the ASM version, enable ASM version by default
// //
#ifndef _CORE_HAS_RTT_ASM_SUPPORT #ifndef _CORE_HAS_RTT_ASM_SUPPORT
#define _CORE_HAS_RTT_ASM_SUPPORT 0 // Default for unknown cores #define _CORE_HAS_RTT_ASM_SUPPORT 0 // Default for unknown cores
#endif #endif
#if (_CC_HAS_RTT_ASM_SUPPORT && _CORE_HAS_RTT_ASM_SUPPORT) #if (_CC_HAS_RTT_ASM_SUPPORT && _CORE_HAS_RTT_ASM_SUPPORT)
#define RTT_USE_ASM (1) #define RTT_USE_ASM (1)
#else #else
#define RTT_USE_ASM (0) #define RTT_USE_ASM (0)
#endif #endif
#endif #endif
// //
// We need to know if a DMB is needed to make sure that on Cortex-M7 etc. // We need to know if a DMB is needed to make sure that on Cortex-M7 etc.
// the order of accesses to the ring buffers is guaranteed // the order of accesses to the ring buffers is guaranteed
// Needed for: Cortex-M7, Cortex-M23, Cortex-M33 // Needed for: Cortex-M7, Cortex-M23, Cortex-M33
// //
#ifndef _CORE_NEEDS_DMB #ifndef _CORE_NEEDS_DMB
#define _CORE_NEEDS_DMB 0 #define _CORE_NEEDS_DMB 0
#endif #endif
#ifndef RTT__DMB #ifndef RTT__DMB
#if _CORE_NEEDS_DMB #if _CORE_NEEDS_DMB
#error "Don't know how to place inline assembly for DMB" #error "Don't know how to place inline assembly for DMB"
#else #else
#define RTT__DMB() #define RTT__DMB()
#endif #endif
#endif #endif
#ifndef SEGGER_RTT_CPU_CACHE_LINE_SIZE #ifndef SEGGER_RTT_CPU_CACHE_LINE_SIZE
#define SEGGER_RTT_CPU_CACHE_LINE_SIZE (0) // On most target systems where RTT is used, we do not have a CPU cache, therefore 0 is a good default here #define SEGGER_RTT_CPU_CACHE_LINE_SIZE (0) // On most target systems where RTT is used, we do not have a CPU cache, therefore 0 is a good default here
#endif #endif
#ifndef SEGGER_RTT_UNCACHED_OFF #ifndef SEGGER_RTT_UNCACHED_OFF
#if SEGGER_RTT_CPU_CACHE_LINE_SIZE #if SEGGER_RTT_CPU_CACHE_LINE_SIZE
#error "SEGGER_RTT_UNCACHED_OFF must be defined when setting SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #error "SEGGER_RTT_UNCACHED_OFF must be defined when setting SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
#else #else
#define SEGGER_RTT_UNCACHED_OFF (0) #define SEGGER_RTT_UNCACHED_OFF (0)
#endif #endif
#endif #endif
#if RTT_USE_ASM #if RTT_USE_ASM
#if SEGGER_RTT_CPU_CACHE_LINE_SIZE #if SEGGER_RTT_CPU_CACHE_LINE_SIZE
#error "RTT_USE_ASM is not available if SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #error "RTT_USE_ASM is not available if SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
#endif #endif
#endif #endif
#ifndef SEGGER_RTT_ASM // defined when SEGGER_RTT.h is included from assembly file #ifndef SEGGER_RTT_ASM // defined when SEGGER_RTT.h is included from assembly file
#include <stdlib.h> #include <stdlib.h>
#include <stdarg.h> #include <stdarg.h>
/********************************************************************* /*********************************************************************
* *
* Defines, fixed * Defines, fixed
* *
********************************************************************** **********************************************************************
*/ */
// //
// Determine how much we must pad the control block to make it a multiple of a cache line in size // Determine how much we must pad the control block to make it a multiple of a cache line in size
// Assuming: U8 = 1B // Assuming: U8 = 1B
// U16 = 2B // U16 = 2B
// U32 = 4B // U32 = 4B
// U8/U16/U32* = 4B // U8/U16/U32* = 4B
// //
#if SEGGER_RTT_CPU_CACHE_LINE_SIZE // Avoid division by zero in case we do not have any cache #if SEGGER_RTT_CPU_CACHE_LINE_SIZE // Avoid division by zero in case we do not have any cache
#define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (((NumBytes + SEGGER_RTT_CPU_CACHE_LINE_SIZE - 1) / SEGGER_RTT_CPU_CACHE_LINE_SIZE) * SEGGER_RTT_CPU_CACHE_LINE_SIZE) #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (((NumBytes + SEGGER_RTT_CPU_CACHE_LINE_SIZE - 1) / SEGGER_RTT_CPU_CACHE_LINE_SIZE) * SEGGER_RTT_CPU_CACHE_LINE_SIZE)
#else #else
#define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (NumBytes) #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (NumBytes)
#endif #endif
#define SEGGER_RTT__CB_SIZE (16 + 4 + 4 + (SEGGER_RTT_MAX_NUM_UP_BUFFERS * 24) + (SEGGER_RTT_MAX_NUM_DOWN_BUFFERS * 24)) #define SEGGER_RTT__CB_SIZE (16 + 4 + 4 + (SEGGER_RTT_MAX_NUM_UP_BUFFERS * 24) + (SEGGER_RTT_MAX_NUM_DOWN_BUFFERS * 24))
#define SEGGER_RTT__CB_PADDING (SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(SEGGER_RTT__CB_SIZE) - SEGGER_RTT__CB_SIZE) #define SEGGER_RTT__CB_PADDING (SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(SEGGER_RTT__CB_SIZE) - SEGGER_RTT__CB_SIZE)
/********************************************************************* /*********************************************************************
* *
* Types * Types
* *
********************************************************************** **********************************************************************
*/ */
// //
// Description for a circular buffer (also called "ring buffer") // Description for a circular buffer (also called "ring buffer")
// which is used as up-buffer (T->H) // which is used as up-buffer (T->H)
// //
typedef struct { typedef struct {
const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4" const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
char* pBuffer; // Pointer to start of buffer char* pBuffer; // Pointer to start of buffer
unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty. unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
unsigned WrOff; // Position of next item to be written by either target. unsigned WrOff; // Position of next item to be written by either target.
volatile unsigned RdOff; // Position of next item to be read by host. Must be volatile since it may be modified by host. volatile unsigned RdOff; // Position of next item to be read by host. Must be volatile since it may be modified by host.
unsigned Flags; // Contains configuration flags unsigned Flags; // Contains configuration flags
} SEGGER_RTT_BUFFER_UP; } SEGGER_RTT_BUFFER_UP;
// //
// Description for a circular buffer (also called "ring buffer") // Description for a circular buffer (also called "ring buffer")
// which is used as down-buffer (H->T) // which is used as down-buffer (H->T)
// //
typedef struct { typedef struct {
const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4" const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
char* pBuffer; // Pointer to start of buffer char* pBuffer; // Pointer to start of buffer
unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty. unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
volatile unsigned WrOff; // Position of next item to be written by host. Must be volatile since it may be modified by host. volatile unsigned WrOff; // Position of next item to be written by host. Must be volatile since it may be modified by host.
unsigned RdOff; // Position of next item to be read by target (down-buffer). unsigned RdOff; // Position of next item to be read by target (down-buffer).
unsigned Flags; // Contains configuration flags unsigned Flags; // Contains configuration flags
} SEGGER_RTT_BUFFER_DOWN; } SEGGER_RTT_BUFFER_DOWN;
// //
// RTT control block which describes the number of buffers available // RTT control block which describes the number of buffers available
// as well as the configuration for each buffer // as well as the configuration for each buffer
// //
// //
typedef struct { typedef struct {
char acID[16]; // Initialized to "SEGGER RTT" char acID[16]; // Initialized to "SEGGER RTT"
int MaxNumUpBuffers; // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2) int MaxNumUpBuffers; // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2)
int MaxNumDownBuffers; // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2) int MaxNumDownBuffers; // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2)
SEGGER_RTT_BUFFER_UP aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS]; // Up buffers, transferring information up from target via debug probe to host SEGGER_RTT_BUFFER_UP aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS]; // Up buffers, transferring information up from target via debug probe to host
SEGGER_RTT_BUFFER_DOWN aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS]; // Down buffers, transferring information down from host via debug probe to target SEGGER_RTT_BUFFER_DOWN aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS]; // Down buffers, transferring information down from host via debug probe to target
#if SEGGER_RTT__CB_PADDING #if SEGGER_RTT__CB_PADDING
unsigned char aDummy[SEGGER_RTT__CB_PADDING]; unsigned char aDummy[SEGGER_RTT__CB_PADDING];
#endif #endif
} SEGGER_RTT_CB; } SEGGER_RTT_CB;
/********************************************************************* /*********************************************************************
* *
* Global data * Global data
* *
********************************************************************** **********************************************************************
*/ */
extern SEGGER_RTT_CB _SEGGER_RTT; extern SEGGER_RTT_CB _SEGGER_RTT;
/********************************************************************* /*********************************************************************
* *
* RTT API functions * RTT API functions
* *
********************************************************************** **********************************************************************
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int SEGGER_RTT_AllocDownBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_AllocDownBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
int SEGGER_RTT_AllocUpBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_AllocUpBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
int SEGGER_RTT_ConfigUpBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_ConfigUpBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
int SEGGER_RTT_ConfigDownBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_ConfigDownBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
int SEGGER_RTT_GetKey (void); int SEGGER_RTT_GetKey (void);
unsigned SEGGER_RTT_HasData (unsigned BufferIndex); unsigned SEGGER_RTT_HasData (unsigned BufferIndex);
int SEGGER_RTT_HasKey (void); int SEGGER_RTT_HasKey (void);
unsigned SEGGER_RTT_HasDataUp (unsigned BufferIndex); unsigned SEGGER_RTT_HasDataUp (unsigned BufferIndex);
void SEGGER_RTT_Init (void); void SEGGER_RTT_Init (void);
unsigned SEGGER_RTT_Read (unsigned BufferIndex, void* pBuffer, unsigned BufferSize); unsigned SEGGER_RTT_Read (unsigned BufferIndex, void* pBuffer, unsigned BufferSize);
unsigned SEGGER_RTT_ReadNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize); unsigned SEGGER_RTT_ReadNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize);
int SEGGER_RTT_SetNameDownBuffer (unsigned BufferIndex, const char* sName); int SEGGER_RTT_SetNameDownBuffer (unsigned BufferIndex, const char* sName);
int SEGGER_RTT_SetNameUpBuffer (unsigned BufferIndex, const char* sName); int SEGGER_RTT_SetNameUpBuffer (unsigned BufferIndex, const char* sName);
int SEGGER_RTT_SetFlagsDownBuffer (unsigned BufferIndex, unsigned Flags); int SEGGER_RTT_SetFlagsDownBuffer (unsigned BufferIndex, unsigned Flags);
int SEGGER_RTT_SetFlagsUpBuffer (unsigned BufferIndex, unsigned Flags); int SEGGER_RTT_SetFlagsUpBuffer (unsigned BufferIndex, unsigned Flags);
int SEGGER_RTT_WaitKey (void); int SEGGER_RTT_WaitKey (void);
unsigned SEGGER_RTT_Write (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_Write (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
unsigned SEGGER_RTT_WriteNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
unsigned SEGGER_RTT_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
unsigned SEGGER_RTT_ASM_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_ASM_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
unsigned SEGGER_RTT_WriteString (unsigned BufferIndex, const char* s); unsigned SEGGER_RTT_WriteString (unsigned BufferIndex, const char* s);
void SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); void SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
unsigned SEGGER_RTT_PutChar (unsigned BufferIndex, char c); unsigned SEGGER_RTT_PutChar (unsigned BufferIndex, char c);
unsigned SEGGER_RTT_PutCharSkip (unsigned BufferIndex, char c); unsigned SEGGER_RTT_PutCharSkip (unsigned BufferIndex, char c);
unsigned SEGGER_RTT_PutCharSkipNoLock (unsigned BufferIndex, char c); unsigned SEGGER_RTT_PutCharSkipNoLock (unsigned BufferIndex, char c);
unsigned SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex); unsigned SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex);
unsigned SEGGER_RTT_GetBytesInBuffer (unsigned BufferIndex); unsigned SEGGER_RTT_GetBytesInBuffer (unsigned BufferIndex);
// //
// Function macro for performance optimization // Function macro for performance optimization
// //
#define SEGGER_RTT_HASDATA(n) (((SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) #define SEGGER_RTT_HASDATA(n) (((SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff)
#if RTT_USE_ASM #if RTT_USE_ASM
#define SEGGER_RTT_WriteSkipNoLock SEGGER_RTT_ASM_WriteSkipNoLock #define SEGGER_RTT_WriteSkipNoLock SEGGER_RTT_ASM_WriteSkipNoLock
#endif #endif
/********************************************************************* /*********************************************************************
* *
* RTT transfer functions to send RTT data via other channels. * RTT transfer functions to send RTT data via other channels.
* *
********************************************************************** **********************************************************************
*/ */
unsigned SEGGER_RTT_ReadUpBuffer (unsigned BufferIndex, void* pBuffer, unsigned BufferSize); unsigned SEGGER_RTT_ReadUpBuffer (unsigned BufferIndex, void* pBuffer, unsigned BufferSize);
unsigned SEGGER_RTT_ReadUpBufferNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize); unsigned SEGGER_RTT_ReadUpBufferNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize);
unsigned SEGGER_RTT_WriteDownBuffer (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteDownBuffer (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
unsigned SEGGER_RTT_WriteDownBufferNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteDownBufferNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
#define SEGGER_RTT_HASDATA_UP(n) (((SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly #define SEGGER_RTT_HASDATA_UP(n) (((SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
/********************************************************************* /*********************************************************************
* *
* RTT "Terminal" API functions * RTT "Terminal" API functions
* *
********************************************************************** **********************************************************************
*/ */
int SEGGER_RTT_SetTerminal (unsigned char TerminalId); int SEGGER_RTT_SetTerminal (unsigned char TerminalId);
int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s); int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s);
/********************************************************************* /*********************************************************************
* *
* RTT printf functions (require SEGGER_RTT_printf.c) * RTT printf functions (require SEGGER_RTT_printf.c)
* *
********************************************************************** **********************************************************************
*/ */
int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...); int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...);
int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList); int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // ifndef(SEGGER_RTT_ASM) #endif // ifndef(SEGGER_RTT_ASM)
/********************************************************************* /*********************************************************************
* *
* Defines * Defines
* *
********************************************************************** **********************************************************************
*/ */
// //
// Operating modes. Define behavior if buffer is full (not enough space for entire message) // Operating modes. Define behavior if buffer is full (not enough space for entire message)
// //
#define SEGGER_RTT_MODE_NO_BLOCK_SKIP (0) // Skip. Do not block, output nothing. (Default) #define SEGGER_RTT_MODE_NO_BLOCK_SKIP (0) // Skip. Do not block, output nothing. (Default)
#define SEGGER_RTT_MODE_NO_BLOCK_TRIM (1) // Trim: Do not block, output as much as fits. #define SEGGER_RTT_MODE_NO_BLOCK_TRIM (1) // Trim: Do not block, output as much as fits.
#define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL (2) // Block: Wait until there is space in the buffer. #define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL (2) // Block: Wait until there is space in the buffer.
#define SEGGER_RTT_MODE_MASK (3) #define SEGGER_RTT_MODE_MASK (3)
// //
// Control sequences, based on ANSI. // Control sequences, based on ANSI.
// Can be used to control color, and clear the screen // Can be used to control color, and clear the screen
// //
#define RTT_CTRL_RESET "\x1B[0m" // Reset to default colors #define RTT_CTRL_RESET "\x1B[0m" // Reset to default colors
#define RTT_CTRL_CLEAR "\x1B[2J" // Clear screen, reposition cursor to top left #define RTT_CTRL_CLEAR "\x1B[2J" // Clear screen, reposition cursor to top left
#define RTT_CTRL_TEXT_BLACK "\x1B[2;30m" #define RTT_CTRL_TEXT_BLACK "\x1B[2;30m"
#define RTT_CTRL_TEXT_RED "\x1B[2;31m" #define RTT_CTRL_TEXT_RED "\x1B[2;31m"
#define RTT_CTRL_TEXT_GREEN "\x1B[2;32m" #define RTT_CTRL_TEXT_GREEN "\x1B[2;32m"
#define RTT_CTRL_TEXT_YELLOW "\x1B[2;33m" #define RTT_CTRL_TEXT_YELLOW "\x1B[2;33m"
#define RTT_CTRL_TEXT_BLUE "\x1B[2;34m" #define RTT_CTRL_TEXT_BLUE "\x1B[2;34m"
#define RTT_CTRL_TEXT_MAGENTA "\x1B[2;35m" #define RTT_CTRL_TEXT_MAGENTA "\x1B[2;35m"
#define RTT_CTRL_TEXT_CYAN "\x1B[2;36m" #define RTT_CTRL_TEXT_CYAN "\x1B[2;36m"
#define RTT_CTRL_TEXT_WHITE "\x1B[2;37m" #define RTT_CTRL_TEXT_WHITE "\x1B[2;37m"
#define RTT_CTRL_TEXT_BRIGHT_BLACK "\x1B[1;30m" #define RTT_CTRL_TEXT_BRIGHT_BLACK "\x1B[1;30m"
#define RTT_CTRL_TEXT_BRIGHT_RED "\x1B[1;31m" #define RTT_CTRL_TEXT_BRIGHT_RED "\x1B[1;31m"
#define RTT_CTRL_TEXT_BRIGHT_GREEN "\x1B[1;32m" #define RTT_CTRL_TEXT_BRIGHT_GREEN "\x1B[1;32m"
#define RTT_CTRL_TEXT_BRIGHT_YELLOW "\x1B[1;33m" #define RTT_CTRL_TEXT_BRIGHT_YELLOW "\x1B[1;33m"
#define RTT_CTRL_TEXT_BRIGHT_BLUE "\x1B[1;34m" #define RTT_CTRL_TEXT_BRIGHT_BLUE "\x1B[1;34m"
#define RTT_CTRL_TEXT_BRIGHT_MAGENTA "\x1B[1;35m" #define RTT_CTRL_TEXT_BRIGHT_MAGENTA "\x1B[1;35m"
#define RTT_CTRL_TEXT_BRIGHT_CYAN "\x1B[1;36m" #define RTT_CTRL_TEXT_BRIGHT_CYAN "\x1B[1;36m"
#define RTT_CTRL_TEXT_BRIGHT_WHITE "\x1B[1;37m" #define RTT_CTRL_TEXT_BRIGHT_WHITE "\x1B[1;37m"
#define RTT_CTRL_BG_BLACK "\x1B[24;40m" #define RTT_CTRL_BG_BLACK "\x1B[24;40m"
#define RTT_CTRL_BG_RED "\x1B[24;41m" #define RTT_CTRL_BG_RED "\x1B[24;41m"
#define RTT_CTRL_BG_GREEN "\x1B[24;42m" #define RTT_CTRL_BG_GREEN "\x1B[24;42m"
#define RTT_CTRL_BG_YELLOW "\x1B[24;43m" #define RTT_CTRL_BG_YELLOW "\x1B[24;43m"
#define RTT_CTRL_BG_BLUE "\x1B[24;44m" #define RTT_CTRL_BG_BLUE "\x1B[24;44m"
#define RTT_CTRL_BG_MAGENTA "\x1B[24;45m" #define RTT_CTRL_BG_MAGENTA "\x1B[24;45m"
#define RTT_CTRL_BG_CYAN "\x1B[24;46m" #define RTT_CTRL_BG_CYAN "\x1B[24;46m"
#define RTT_CTRL_BG_WHITE "\x1B[24;47m" #define RTT_CTRL_BG_WHITE "\x1B[24;47m"
#define RTT_CTRL_BG_BRIGHT_BLACK "\x1B[4;40m" #define RTT_CTRL_BG_BRIGHT_BLACK "\x1B[4;40m"
#define RTT_CTRL_BG_BRIGHT_RED "\x1B[4;41m" #define RTT_CTRL_BG_BRIGHT_RED "\x1B[4;41m"
#define RTT_CTRL_BG_BRIGHT_GREEN "\x1B[4;42m" #define RTT_CTRL_BG_BRIGHT_GREEN "\x1B[4;42m"
#define RTT_CTRL_BG_BRIGHT_YELLOW "\x1B[4;43m" #define RTT_CTRL_BG_BRIGHT_YELLOW "\x1B[4;43m"
#define RTT_CTRL_BG_BRIGHT_BLUE "\x1B[4;44m" #define RTT_CTRL_BG_BRIGHT_BLUE "\x1B[4;44m"
#define RTT_CTRL_BG_BRIGHT_MAGENTA "\x1B[4;45m" #define RTT_CTRL_BG_BRIGHT_MAGENTA "\x1B[4;45m"
#define RTT_CTRL_BG_BRIGHT_CYAN "\x1B[4;46m" #define RTT_CTRL_BG_BRIGHT_CYAN "\x1B[4;46m"
#define RTT_CTRL_BG_BRIGHT_WHITE "\x1B[4;47m" #define RTT_CTRL_BG_BRIGHT_WHITE "\x1B[4;47m"
#endif #endif
/*************************** End of file ****************************/ /*************************** End of file ****************************/

484
core/embed/segger/SEGGER/SEGGER_RTT_ASM_ARMv7M.S
View File

@ -1,242 +1,242 @@
/********************************************************************* /*********************************************************************
* (c) SEGGER Microcontroller GmbH * * (c) SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
* www.segger.com * * www.segger.com *
********************************************************************** **********************************************************************
-------------------------- END-OF-HEADER ----------------------------- -------------------------- END-OF-HEADER -----------------------------
File : SEGGER_RTT_ASM_ARMv7M.S File : SEGGER_RTT_ASM_ARMv7M.S
Purpose : Assembler implementation of RTT functions for ARMv7M Purpose : Assembler implementation of RTT functions for ARMv7M
Additional information: Additional information:
This module is written to be assembler-independent and works with This module is written to be assembler-independent and works with
GCC and clang (Embedded Studio) and IAR. GCC and clang (Embedded Studio) and IAR.
*/ */
#define SEGGER_RTT_ASM // Used to control processed input from header file #define SEGGER_RTT_ASM // Used to control processed input from header file
#include "SEGGER_RTT.h" #include "SEGGER_RTT.h"
/********************************************************************* /*********************************************************************
* *
* Defines, fixed * Defines, fixed
* *
********************************************************************** **********************************************************************
*/ */
#define _CCIAR 0 #define _CCIAR 0
#define _CCCLANG 1 #define _CCCLANG 1
#if (defined __SES_ARM) || (defined __GNUC__) || (defined __clang__) #if (defined __SES_ARM) || (defined __GNUC__) || (defined __clang__)
#define _CC_TYPE _CCCLANG #define _CC_TYPE _CCCLANG
#define _PUB_SYM .global #define _PUB_SYM .global
#define _EXT_SYM .extern #define _EXT_SYM .extern
#define _END .end #define _END .end
#define _WEAK .weak #define _WEAK .weak
#define _THUMB_FUNC .thumb_func #define _THUMB_FUNC .thumb_func
#define _THUMB_CODE .code 16 #define _THUMB_CODE .code 16
#define _WORD .word #define _WORD .word
#define _SECTION(Sect, Type, AlignExp) .section Sect ##, "ax" #define _SECTION(Sect, Type, AlignExp) .section Sect ##, "ax"
#define _ALIGN(Exp) .align Exp #define _ALIGN(Exp) .align Exp
#define _PLACE_LITS .ltorg #define _PLACE_LITS .ltorg
#define _DATA_SECT_START #define _DATA_SECT_START
#define _C_STARTUP _start #define _C_STARTUP _start
#define _STACK_END __stack_end__ #define _STACK_END __stack_end__
#define _RAMFUNC #define _RAMFUNC
// //
// .text => Link to flash // .text => Link to flash
// .fast => Link to RAM // .fast => Link to RAM
// OtherSect => Usually link to RAM // OtherSect => Usually link to RAM
// Alignment is 2^x // Alignment is 2^x
// //
#elif defined (__IASMARM__) #elif defined (__IASMARM__)
#define _CC_TYPE _CCIAR #define _CC_TYPE _CCIAR
#define _PUB_SYM PUBLIC #define _PUB_SYM PUBLIC
#define _EXT_SYM EXTERN #define _EXT_SYM EXTERN
#define _END END #define _END END
#define _WEAK _WEAK #define _WEAK _WEAK
#define _THUMB_FUNC #define _THUMB_FUNC
#define _THUMB_CODE THUMB #define _THUMB_CODE THUMB
#define _WORD DCD #define _WORD DCD
#define _SECTION(Sect, Type, AlignExp) SECTION Sect ## : ## Type ## :REORDER:NOROOT ## (AlignExp) #define _SECTION(Sect, Type, AlignExp) SECTION Sect ## : ## Type ## :REORDER:NOROOT ## (AlignExp)
#define _ALIGN(Exp) alignrom Exp #define _ALIGN(Exp) alignrom Exp
#define _PLACE_LITS #define _PLACE_LITS
#define _DATA_SECT_START DATA #define _DATA_SECT_START DATA
#define _C_STARTUP __iar_program_start #define _C_STARTUP __iar_program_start
#define _STACK_END sfe(CSTACK) #define _STACK_END sfe(CSTACK)
#define _RAMFUNC SECTION_TYPE SHT_PROGBITS, SHF_WRITE | SHF_EXECINSTR #define _RAMFUNC SECTION_TYPE SHT_PROGBITS, SHF_WRITE | SHF_EXECINSTR
// //
// .text => Link to flash // .text => Link to flash
// .textrw => Link to RAM // .textrw => Link to RAM
// OtherSect => Usually link to RAM // OtherSect => Usually link to RAM
// NOROOT => Allows linker to throw away the function, if not referenced // NOROOT => Allows linker to throw away the function, if not referenced
// Alignment is 2^x // Alignment is 2^x
// //
#endif #endif
#if (_CC_TYPE == _CCIAR) #if (_CC_TYPE == _CCIAR)
NAME SEGGER_RTT_ASM_ARMv7M NAME SEGGER_RTT_ASM_ARMv7M
#else #else
.syntax unified .syntax unified
#endif #endif
#if defined (RTT_USE_ASM) && (RTT_USE_ASM == 1) #if defined (RTT_USE_ASM) && (RTT_USE_ASM == 1)
#define SHT_PROGBITS 0x1 #define SHT_PROGBITS 0x1
/********************************************************************* /*********************************************************************
* *
* Public / external symbols * Public / external symbols
* *
********************************************************************** **********************************************************************
*/ */
_EXT_SYM __aeabi_memcpy _EXT_SYM __aeabi_memcpy
_EXT_SYM __aeabi_memcpy4 _EXT_SYM __aeabi_memcpy4
_EXT_SYM _SEGGER_RTT _EXT_SYM _SEGGER_RTT
_PUB_SYM SEGGER_RTT_ASM_WriteSkipNoLock _PUB_SYM SEGGER_RTT_ASM_WriteSkipNoLock
/********************************************************************* /*********************************************************************
* *
* SEGGER_RTT_WriteSkipNoLock * SEGGER_RTT_WriteSkipNoLock
* *
* Function description * Function description
* Stores a specified number of characters in SEGGER RTT * Stores a specified number of characters in SEGGER RTT
* control block which is then read by the host. * control block which is then read by the host.
* SEGGER_RTT_WriteSkipNoLock does not lock the application and * SEGGER_RTT_WriteSkipNoLock does not lock the application and
* skips all data, if the data does not fit into the buffer. * skips all data, if the data does not fit into the buffer.
* *
* Parameters * Parameters
* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal").
* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * pBuffer Pointer to character array. Does not need to point to a \0 terminated string.
* NumBytes Number of bytes to be stored in the SEGGER RTT control block. * NumBytes Number of bytes to be stored in the SEGGER RTT control block.
* MUST be > 0!!! * MUST be > 0!!!
* This is done for performance reasons, so no initial check has do be done. * This is done for performance reasons, so no initial check has do be done.
* *
* Return value * Return value
* 1: Data has been copied * 1: Data has been copied
* 0: No space, data has not been copied * 0: No space, data has not been copied
* *
* Notes * Notes
* (1) If there is not enough space in the "Up"-buffer, all data is dropped. * (1) If there is not enough space in the "Up"-buffer, all data is dropped.
* (2) For performance reasons this function does not call Init() * (2) For performance reasons this function does not call Init()
* and may only be called after RTT has been initialized. * and may only be called after RTT has been initialized.
* Either by calling SEGGER_RTT_Init() or calling another RTT API function first. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first.
*/ */
_SECTION(.text, CODE, 2) _SECTION(.text, CODE, 2)
_ALIGN(2) _ALIGN(2)
_THUMB_FUNC _THUMB_FUNC
SEGGER_RTT_ASM_WriteSkipNoLock: // unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pData, unsigned NumBytes) { SEGGER_RTT_ASM_WriteSkipNoLock: // unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pData, unsigned NumBytes) {
// //
// Cases: // Cases:
// 1) RdOff <= WrOff => Space until wrap-around is sufficient // 1) RdOff <= WrOff => Space until wrap-around is sufficient
// 2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks) // 2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks)
// 3) RdOff < WrOff => No space in buf // 3) RdOff < WrOff => No space in buf
// 4) RdOff > WrOff => Space is sufficient // 4) RdOff > WrOff => Space is sufficient
// 5) RdOff > WrOff => No space in buf // 5) RdOff > WrOff => No space in buf
// //
// 1) is the most common case for large buffers and assuming that J-Link reads the data fast enough // 1) is the most common case for large buffers and assuming that J-Link reads the data fast enough
// //
// Register usage: // Register usage:
// R0 Temporary needed as RdOff, <Tmp> register later on // R0 Temporary needed as RdOff, <Tmp> register later on
// R1 pData // R1 pData
// R2 <NumBytes> // R2 <NumBytes>
// R3 <Tmp> register. Hold free for subroutine calls // R3 <Tmp> register. Hold free for subroutine calls
// R4 <Rem> // R4 <Rem>
// R5 pRing->pBuffer // R5 pRing->pBuffer
// R6 pRing (Points to active struct SEGGER_RTT_BUFFER_DOWN) // R6 pRing (Points to active struct SEGGER_RTT_BUFFER_DOWN)
// R7 WrOff // R7 WrOff
// //
PUSH {R4-R7} PUSH {R4-R7}
ADD R3,R0,R0, LSL #+1 ADD R3,R0,R0, LSL #+1
LDR.W R0,=_SEGGER_RTT // pRing = &_SEGGER_RTT.aUp[BufferIndex]; LDR.W R0,=_SEGGER_RTT // pRing = &_SEGGER_RTT.aUp[BufferIndex];
ADD R0,R0,R3, LSL #+3 ADD R0,R0,R3, LSL #+3
ADD R6,R0,#+24 ADD R6,R0,#+24
LDR R0,[R6, #+16] // RdOff = pRing->RdOff; LDR R0,[R6, #+16] // RdOff = pRing->RdOff;
LDR R7,[R6, #+12] // WrOff = pRing->WrOff; LDR R7,[R6, #+12] // WrOff = pRing->WrOff;
LDR R5,[R6, #+4] // pRing->pBuffer LDR R5,[R6, #+4] // pRing->pBuffer
CMP R7,R0 CMP R7,R0
BCC.N _CheckCase4 // if (RdOff <= WrOff) { => Case 1), 2) or 3) BCC.N _CheckCase4 // if (RdOff <= WrOff) { => Case 1), 2) or 3)
// //
// Handling for case 1, later on identical to case 4 // Handling for case 1, later on identical to case 4
// //
LDR R3,[R6, #+8] // Avail = pRing->SizeOfBuffer - WrOff - 1u; => Space until wrap-around (assume 1 byte not usable for case that RdOff == 0) LDR R3,[R6, #+8] // Avail = pRing->SizeOfBuffer - WrOff - 1u; => Space until wrap-around (assume 1 byte not usable for case that RdOff == 0)
SUBS R4,R3,R7 // <Rem> (Used in case we jump into case 2 afterwards) SUBS R4,R3,R7 // <Rem> (Used in case we jump into case 2 afterwards)
SUBS R3,R4,#+1 // <Avail> SUBS R3,R4,#+1 // <Avail>
CMP R3,R2 CMP R3,R2
BCC.N _CheckCase2 // if (Avail >= NumBytes) { => Case 1)? BCC.N _CheckCase2 // if (Avail >= NumBytes) { => Case 1)?
_Case4: _Case4:
ADDS R5,R7,R5 // pBuffer += WrOff ADDS R5,R7,R5 // pBuffer += WrOff
ADDS R0,R2,R7 // v = WrOff + NumBytes ADDS R0,R2,R7 // v = WrOff + NumBytes
// //
// 2x unrolling for the copy loop that is used most of the time // 2x unrolling for the copy loop that is used most of the time
// This is a special optimization for small SystemView packets and makes them even faster // This is a special optimization for small SystemView packets and makes them even faster
// //
_ALIGN(2) _ALIGN(2)
_LoopCopyStraight: // memcpy(pRing->pBuffer + WrOff, pData, NumBytes); _LoopCopyStraight: // memcpy(pRing->pBuffer + WrOff, pData, NumBytes);
LDRB R3,[R1], #+1 LDRB R3,[R1], #+1
STRB R3,[R5], #+1 // *pDest++ = *pSrc++ STRB R3,[R5], #+1 // *pDest++ = *pSrc++
SUBS R2,R2,#+1 SUBS R2,R2,#+1
BEQ _CSDone BEQ _CSDone
LDRB R3,[R1], #+1 LDRB R3,[R1], #+1
STRB R3,[R5], #+1 // *pDest++ = *pSrc++ STRB R3,[R5], #+1 // *pDest++ = *pSrc++
SUBS R2,R2,#+1 SUBS R2,R2,#+1
BNE _LoopCopyStraight BNE _LoopCopyStraight
_CSDone: _CSDone:
#if _CORE_NEEDS_DMB // Do not slow down cores that do not need a DMB instruction here #if _CORE_NEEDS_DMB // Do not slow down cores that do not need a DMB instruction here
DMB // Cortex-M7 may delay memory writes and also change the order in which the writes happen. Therefore, make sure that all buffer writes are finished, before updating the <WrOff> in the struct DMB // Cortex-M7 may delay memory writes and also change the order in which the writes happen. Therefore, make sure that all buffer writes are finished, before updating the <WrOff> in the struct
#endif #endif
STR R0,[R6, #+12] // pRing->WrOff = WrOff + NumBytes; STR R0,[R6, #+12] // pRing->WrOff = WrOff + NumBytes;
MOVS R0,#+1 MOVS R0,#+1
POP {R4-R7} POP {R4-R7}
BX LR // Return 1 BX LR // Return 1
_CheckCase2: _CheckCase2:
ADDS R0,R0,R3 // Avail += RdOff; => Space incl. wrap-around ADDS R0,R0,R3 // Avail += RdOff; => Space incl. wrap-around
CMP R0,R2 CMP R0,R2
BCC.N _Case3 // if (Avail >= NumBytes) { => Case 2? => If not, we have case 3) (does not fit) BCC.N _Case3 // if (Avail >= NumBytes) { => Case 2? => If not, we have case 3) (does not fit)
// //
// Handling for case 2 // Handling for case 2
// //
ADDS R0,R7,R5 // v = pRing->pBuffer + WrOff => Do not change pRing->pBuffer here because 2nd chunk needs org. value ADDS R0,R7,R5 // v = pRing->pBuffer + WrOff => Do not change pRing->pBuffer here because 2nd chunk needs org. value
SUBS R2,R2,R4 // NumBytes -= Rem; (Rem = pRing->SizeOfBuffer - WrOff; => Space until end of buffer) SUBS R2,R2,R4 // NumBytes -= Rem; (Rem = pRing->SizeOfBuffer - WrOff; => Space until end of buffer)
_LoopCopyBeforeWrapAround: // memcpy(pRing->pBuffer + WrOff, pData, Rem); => Copy 1st chunk _LoopCopyBeforeWrapAround: // memcpy(pRing->pBuffer + WrOff, pData, Rem); => Copy 1st chunk
LDRB R3,[R1], #+1 LDRB R3,[R1], #+1
STRB R3,[R0], #+1 // *pDest++ = *pSrc++ STRB R3,[R0], #+1 // *pDest++ = *pSrc++
SUBS R4,R4,#+1 SUBS R4,R4,#+1
BNE _LoopCopyBeforeWrapAround BNE _LoopCopyBeforeWrapAround
// //
// Special case: First check that assumed RdOff == 0 calculated that last element before wrap-around could not be used // Special case: First check that assumed RdOff == 0 calculated that last element before wrap-around could not be used
// But 2nd check (considering space until wrap-around and until RdOff) revealed that RdOff is not 0, so we can use the last element // But 2nd check (considering space until wrap-around and until RdOff) revealed that RdOff is not 0, so we can use the last element
// In this case, we may use a copy straight until buffer end anyway without needing to copy 2 chunks // In this case, we may use a copy straight until buffer end anyway without needing to copy 2 chunks
// Therefore, check if 2nd memcpy is necessary at all // Therefore, check if 2nd memcpy is necessary at all
// //
ADDS R4,R2,#+0 // Save <NumBytes> (needed as counter in loop but must be written to <WrOff> after the loop). Also use this inst to update the flags to skip 2nd loop if possible ADDS R4,R2,#+0 // Save <NumBytes> (needed as counter in loop but must be written to <WrOff> after the loop). Also use this inst to update the flags to skip 2nd loop if possible
BEQ.N _No2ChunkNeeded // if (NumBytes) { BEQ.N _No2ChunkNeeded // if (NumBytes) {
_LoopCopyAfterWrapAround: // memcpy(pRing->pBuffer, pData + Rem, NumBytes); _LoopCopyAfterWrapAround: // memcpy(pRing->pBuffer, pData + Rem, NumBytes);
LDRB R3,[R1], #+1 // pData already points to the next src byte due to copy loop increment before this loop LDRB R3,[R1], #+1 // pData already points to the next src byte due to copy loop increment before this loop
STRB R3,[R5], #+1 // *pDest++ = *pSrc++ STRB R3,[R5], #+1 // *pDest++ = *pSrc++
SUBS R2,R2,#+1 SUBS R2,R2,#+1
BNE _LoopCopyAfterWrapAround BNE _LoopCopyAfterWrapAround
_No2ChunkNeeded: _No2ChunkNeeded:
#if _CORE_NEEDS_DMB // Do not slow down cores that do not need a DMB instruction here #if _CORE_NEEDS_DMB // Do not slow down cores that do not need a DMB instruction here
DMB // Cortex-M7 may delay memory writes and also change the order in which the writes happen. Therefore, make sure that all buffer writes are finished, before updating the <WrOff> in the struct DMB // Cortex-M7 may delay memory writes and also change the order in which the writes happen. Therefore, make sure that all buffer writes are finished, before updating the <WrOff> in the struct
#endif #endif
STR R4,[R6, #+12] // pRing->WrOff = NumBytes; => Must be written after copying data because J-Link may read control block asynchronously while writing into buffer STR R4,[R6, #+12] // pRing->WrOff = NumBytes; => Must be written after copying data because J-Link may read control block asynchronously while writing into buffer
MOVS R0,#+1 MOVS R0,#+1
POP {R4-R7} POP {R4-R7}
BX LR // Return 1 BX LR // Return 1
_CheckCase4: _CheckCase4:
SUBS R0,R0,R7 SUBS R0,R0,R7
SUBS R0,R0,#+1 // Avail = RdOff - WrOff - 1u; SUBS R0,R0,#+1 // Avail = RdOff - WrOff - 1u;
CMP R0,R2 CMP R0,R2
BCS.N _Case4 // if (Avail >= NumBytes) { => Case 4) == 1) ? => If not, we have case 5) == 3) (does not fit) BCS.N _Case4 // if (Avail >= NumBytes) { => Case 4) == 1) ? => If not, we have case 5) == 3) (does not fit)
_Case3: _Case3:
MOVS R0,#+0 MOVS R0,#+0
POP {R4-R7} POP {R4-R7}
BX LR // Return 0 BX LR // Return 0
_PLACE_LITS _PLACE_LITS
#endif // defined (RTT_USE_ASM) && (RTT_USE_ASM == 1) #endif // defined (RTT_USE_ASM) && (RTT_USE_ASM == 1)
_END _END
/*************************** End of file ****************************/ /*************************** End of file ****************************/

1008
core/embed/segger/SEGGER/SEGGER_RTT_printf.c
View File

File diff suppressed because it is too large Load Diff

6122
core/embed/segger/SEGGER/SEGGER_SYSVIEW.c
View File

File diff suppressed because it is too large Load Diff

740
core/embed/segger/SEGGER/SEGGER_SYSVIEW.h
View File

@ -1,370 +1,370 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
-------------------------- END-OF-HEADER ----------------------------- -------------------------- END-OF-HEADER -----------------------------
File : SEGGER_SYSVIEW.h File : SEGGER_SYSVIEW.h
Purpose : System visualization API. Purpose : System visualization API.
Revision: $Rev: 21292 $ Revision: $Rev: 21292 $
*/ */
#ifndef SEGGER_SYSVIEW_H #ifndef SEGGER_SYSVIEW_H
#define SEGGER_SYSVIEW_H #define SEGGER_SYSVIEW_H
/********************************************************************* /*********************************************************************
* *
* #include Section * #include Section
* *
********************************************************************** **********************************************************************
*/ */
#include "SEGGER.h" #include "SEGGER.h"
#include "SEGGER_SYSVIEW_ConfDefaults.h" #include "SEGGER_SYSVIEW_ConfDefaults.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Defines, fixed * Defines, fixed
* *
********************************************************************** **********************************************************************
*/ */
#define SEGGER_SYSVIEW_MAJOR 3 #define SEGGER_SYSVIEW_MAJOR 3
#define SEGGER_SYSVIEW_MINOR 10 #define SEGGER_SYSVIEW_MINOR 10
#define SEGGER_SYSVIEW_REV 0 #define SEGGER_SYSVIEW_REV 0
#define SEGGER_SYSVIEW_VERSION ((SEGGER_SYSVIEW_MAJOR * 10000) + (SEGGER_SYSVIEW_MINOR * 100) + SEGGER_SYSVIEW_REV) #define SEGGER_SYSVIEW_VERSION ((SEGGER_SYSVIEW_MAJOR * 10000) + (SEGGER_SYSVIEW_MINOR * 100) + SEGGER_SYSVIEW_REV)
#define SEGGER_SYSVIEW_INFO_SIZE 9 // Minimum size, which has to be reserved for a packet. 1-2 byte of message type, 0-2 byte of payload length, 1-5 bytes of timestamp. #define SEGGER_SYSVIEW_INFO_SIZE 9 // Minimum size, which has to be reserved for a packet. 1-2 byte of message type, 0-2 byte of payload length, 1-5 bytes of timestamp.
#define SEGGER_SYSVIEW_QUANTA_U32 5 // Maximum number of bytes to encode a U32, should be reserved for each 32-bit value in a packet. #define SEGGER_SYSVIEW_QUANTA_U32 5 // Maximum number of bytes to encode a U32, should be reserved for each 32-bit value in a packet.
#define SEGGER_SYSVIEW_LOG (0u) #define SEGGER_SYSVIEW_LOG (0u)
#define SEGGER_SYSVIEW_WARNING (1u) #define SEGGER_SYSVIEW_WARNING (1u)
#define SEGGER_SYSVIEW_ERROR (2u) #define SEGGER_SYSVIEW_ERROR (2u)
#define SEGGER_SYSVIEW_FLAG_APPEND (1u << 6) #define SEGGER_SYSVIEW_FLAG_APPEND (1u << 6)
#define SEGGER_SYSVIEW_PREPARE_PACKET(p) (p) + 4 #define SEGGER_SYSVIEW_PREPARE_PACKET(p) (p) + 4
// //
// SystemView events. First 32 IDs from 0 .. 31 are reserved for these // SystemView events. First 32 IDs from 0 .. 31 are reserved for these
// //
#define SYSVIEW_EVTID_NOP 0 // Dummy packet. #define SYSVIEW_EVTID_NOP 0 // Dummy packet.
#define SYSVIEW_EVTID_OVERFLOW 1 #define SYSVIEW_EVTID_OVERFLOW 1
#define SYSVIEW_EVTID_ISR_ENTER 2 #define SYSVIEW_EVTID_ISR_ENTER 2
#define SYSVIEW_EVTID_ISR_EXIT 3 #define SYSVIEW_EVTID_ISR_EXIT 3
#define SYSVIEW_EVTID_TASK_START_EXEC 4 #define SYSVIEW_EVTID_TASK_START_EXEC 4
#define SYSVIEW_EVTID_TASK_STOP_EXEC 5 #define SYSVIEW_EVTID_TASK_STOP_EXEC 5
#define SYSVIEW_EVTID_TASK_START_READY 6 #define SYSVIEW_EVTID_TASK_START_READY 6
#define SYSVIEW_EVTID_TASK_STOP_READY 7 #define SYSVIEW_EVTID_TASK_STOP_READY 7
#define SYSVIEW_EVTID_TASK_CREATE 8 #define SYSVIEW_EVTID_TASK_CREATE 8
#define SYSVIEW_EVTID_TASK_INFO 9 #define SYSVIEW_EVTID_TASK_INFO 9
#define SYSVIEW_EVTID_TRACE_START 10 #define SYSVIEW_EVTID_TRACE_START 10
#define SYSVIEW_EVTID_TRACE_STOP 11 #define SYSVIEW_EVTID_TRACE_STOP 11
#define SYSVIEW_EVTID_SYSTIME_CYCLES 12 #define SYSVIEW_EVTID_SYSTIME_CYCLES 12
#define SYSVIEW_EVTID_SYSTIME_US 13 #define SYSVIEW_EVTID_SYSTIME_US 13
#define SYSVIEW_EVTID_SYSDESC 14 #define SYSVIEW_EVTID_SYSDESC 14
#define SYSVIEW_EVTID_MARK_START 15 #define SYSVIEW_EVTID_MARK_START 15
#define SYSVIEW_EVTID_MARK_STOP 16 #define SYSVIEW_EVTID_MARK_STOP 16
#define SYSVIEW_EVTID_IDLE 17 #define SYSVIEW_EVTID_IDLE 17
#define SYSVIEW_EVTID_ISR_TO_SCHEDULER 18 #define SYSVIEW_EVTID_ISR_TO_SCHEDULER 18
#define SYSVIEW_EVTID_TIMER_ENTER 19 #define SYSVIEW_EVTID_TIMER_ENTER 19
#define SYSVIEW_EVTID_TIMER_EXIT 20 #define SYSVIEW_EVTID_TIMER_EXIT 20
#define SYSVIEW_EVTID_STACK_INFO 21 #define SYSVIEW_EVTID_STACK_INFO 21
#define SYSVIEW_EVTID_MODULEDESC 22 #define SYSVIEW_EVTID_MODULEDESC 22
#define SYSVIEW_EVTID_INIT 24 #define SYSVIEW_EVTID_INIT 24
#define SYSVIEW_EVTID_NAME_RESOURCE 25 #define SYSVIEW_EVTID_NAME_RESOURCE 25
#define SYSVIEW_EVTID_PRINT_FORMATTED 26 #define SYSVIEW_EVTID_PRINT_FORMATTED 26
#define SYSVIEW_EVTID_NUMMODULES 27 #define SYSVIEW_EVTID_NUMMODULES 27
#define SYSVIEW_EVTID_END_CALL 28 #define SYSVIEW_EVTID_END_CALL 28
#define SYSVIEW_EVTID_TASK_TERMINATE 29 #define SYSVIEW_EVTID_TASK_TERMINATE 29
#define SYSVIEW_EVTID_EX 31 #define SYSVIEW_EVTID_EX 31
// //
// SystemView extended events. Sent with ID 31. // SystemView extended events. Sent with ID 31.
// //
#define SYSVIEW_EVTID_EX_MARK 0 #define SYSVIEW_EVTID_EX_MARK 0
#define SYSVIEW_EVTID_EX_NAME_MARKER 1 #define SYSVIEW_EVTID_EX_NAME_MARKER 1
// //
// Event masks to disable/enable events // Event masks to disable/enable events
// //
#define SYSVIEW_EVTMASK_NOP (1 << SYSVIEW_EVTID_NOP) #define SYSVIEW_EVTMASK_NOP (1 << SYSVIEW_EVTID_NOP)
#define SYSVIEW_EVTMASK_OVERFLOW (1 << SYSVIEW_EVTID_OVERFLOW) #define SYSVIEW_EVTMASK_OVERFLOW (1 << SYSVIEW_EVTID_OVERFLOW)
#define SYSVIEW_EVTMASK_ISR_ENTER (1 << SYSVIEW_EVTID_ISR_ENTER) #define SYSVIEW_EVTMASK_ISR_ENTER (1 << SYSVIEW_EVTID_ISR_ENTER)
#define SYSVIEW_EVTMASK_ISR_EXIT (1 << SYSVIEW_EVTID_ISR_EXIT) #define SYSVIEW_EVTMASK_ISR_EXIT (1 << SYSVIEW_EVTID_ISR_EXIT)
#define SYSVIEW_EVTMASK_TASK_START_EXEC (1 << SYSVIEW_EVTID_TASK_START_EXEC) #define SYSVIEW_EVTMASK_TASK_START_EXEC (1 << SYSVIEW_EVTID_TASK_START_EXEC)
#define SYSVIEW_EVTMASK_TASK_STOP_EXEC (1 << SYSVIEW_EVTID_TASK_STOP_EXEC) #define SYSVIEW_EVTMASK_TASK_STOP_EXEC (1 << SYSVIEW_EVTID_TASK_STOP_EXEC)
#define SYSVIEW_EVTMASK_TASK_START_READY (1 << SYSVIEW_EVTID_TASK_START_READY) #define SYSVIEW_EVTMASK_TASK_START_READY (1 << SYSVIEW_EVTID_TASK_START_READY)
#define SYSVIEW_EVTMASK_TASK_STOP_READY (1 << SYSVIEW_EVTID_TASK_STOP_READY) #define SYSVIEW_EVTMASK_TASK_STOP_READY (1 << SYSVIEW_EVTID_TASK_STOP_READY)
#define SYSVIEW_EVTMASK_TASK_CREATE (1 << SYSVIEW_EVTID_TASK_CREATE) #define SYSVIEW_EVTMASK_TASK_CREATE (1 << SYSVIEW_EVTID_TASK_CREATE)
#define SYSVIEW_EVTMASK_TASK_INFO (1 << SYSVIEW_EVTID_TASK_INFO) #define SYSVIEW_EVTMASK_TASK_INFO (1 << SYSVIEW_EVTID_TASK_INFO)
#define SYSVIEW_EVTMASK_TRACE_START (1 << SYSVIEW_EVTID_TRACE_START) #define SYSVIEW_EVTMASK_TRACE_START (1 << SYSVIEW_EVTID_TRACE_START)
#define SYSVIEW_EVTMASK_TRACE_STOP (1 << SYSVIEW_EVTID_TRACE_STOP) #define SYSVIEW_EVTMASK_TRACE_STOP (1 << SYSVIEW_EVTID_TRACE_STOP)
#define SYSVIEW_EVTMASK_SYSTIME_CYCLES (1 << SYSVIEW_EVTID_SYSTIME_CYCLES) #define SYSVIEW_EVTMASK_SYSTIME_CYCLES (1 << SYSVIEW_EVTID_SYSTIME_CYCLES)
#define SYSVIEW_EVTMASK_SYSTIME_US (1 << SYSVIEW_EVTID_SYSTIME_US) #define SYSVIEW_EVTMASK_SYSTIME_US (1 << SYSVIEW_EVTID_SYSTIME_US)
#define SYSVIEW_EVTMASK_SYSDESC (1 << SYSVIEW_EVTID_SYSDESC) #define SYSVIEW_EVTMASK_SYSDESC (1 << SYSVIEW_EVTID_SYSDESC)
#define SYSVIEW_EVTMASK_USER_START (1 << SYSVIEW_EVTID_USER_START) #define SYSVIEW_EVTMASK_USER_START (1 << SYSVIEW_EVTID_USER_START)
#define SYSVIEW_EVTMASK_USER_STOP (1 << SYSVIEW_EVTID_USER_STOP) #define SYSVIEW_EVTMASK_USER_STOP (1 << SYSVIEW_EVTID_USER_STOP)
#define SYSVIEW_EVTMASK_IDLE (1 << SYSVIEW_EVTID_IDLE) #define SYSVIEW_EVTMASK_IDLE (1 << SYSVIEW_EVTID_IDLE)
#define SYSVIEW_EVTMASK_ISR_TO_SCHEDULER (1 << SYSVIEW_EVTID_ISR_TO_SCHEDULER) #define SYSVIEW_EVTMASK_ISR_TO_SCHEDULER (1 << SYSVIEW_EVTID_ISR_TO_SCHEDULER)
#define SYSVIEW_EVTMASK_TIMER_ENTER (1 << SYSVIEW_EVTID_TIMER_ENTER) #define SYSVIEW_EVTMASK_TIMER_ENTER (1 << SYSVIEW_EVTID_TIMER_ENTER)
#define SYSVIEW_EVTMASK_TIMER_EXIT (1 << SYSVIEW_EVTID_TIMER_EXIT) #define SYSVIEW_EVTMASK_TIMER_EXIT (1 << SYSVIEW_EVTID_TIMER_EXIT)
#define SYSVIEW_EVTMASK_STACK_INFO (1 << SYSVIEW_EVTID_STACK_INFO) #define SYSVIEW_EVTMASK_STACK_INFO (1 << SYSVIEW_EVTID_STACK_INFO)
#define SYSVIEW_EVTMASK_MODULEDESC (1 << SYSVIEW_EVTID_MODULEDESC) #define SYSVIEW_EVTMASK_MODULEDESC (1 << SYSVIEW_EVTID_MODULEDESC)
#define SYSVIEW_EVTMASK_INIT (1 << SYSVIEW_EVTID_INIT) #define SYSVIEW_EVTMASK_INIT (1 << SYSVIEW_EVTID_INIT)
#define SYSVIEW_EVTMASK_NAME_RESOURCE (1 << SYSVIEW_EVTID_NAME_RESOURCE) #define SYSVIEW_EVTMASK_NAME_RESOURCE (1 << SYSVIEW_EVTID_NAME_RESOURCE)
#define SYSVIEW_EVTMASK_PRINT_FORMATTED (1 << SYSVIEW_EVTID_PRINT_FORMATTED) #define SYSVIEW_EVTMASK_PRINT_FORMATTED (1 << SYSVIEW_EVTID_PRINT_FORMATTED)
#define SYSVIEW_EVTMASK_NUMMODULES (1 << SYSVIEW_EVTID_NUMMODULES) #define SYSVIEW_EVTMASK_NUMMODULES (1 << SYSVIEW_EVTID_NUMMODULES)
#define SYSVIEW_EVTMASK_END_CALL (1 << SYSVIEW_EVTID_END_CALL) #define SYSVIEW_EVTMASK_END_CALL (1 << SYSVIEW_EVTID_END_CALL)
#define SYSVIEW_EVTMASK_TASK_TERMINATE (1 << SYSVIEW_EVTID_TASK_TERMINATE) #define SYSVIEW_EVTMASK_TASK_TERMINATE (1 << SYSVIEW_EVTID_TASK_TERMINATE)
#define SYSVIEW_EVTMASK_EX (1 << SYSVIEW_EVTID_EX) #define SYSVIEW_EVTMASK_EX (1 << SYSVIEW_EVTID_EX)
#define SYSVIEW_EVTMASK_ALL_INTERRUPTS ( SYSVIEW_EVTMASK_ISR_ENTER \ #define SYSVIEW_EVTMASK_ALL_INTERRUPTS ( SYSVIEW_EVTMASK_ISR_ENTER \
| SYSVIEW_EVTMASK_ISR_EXIT \ | SYSVIEW_EVTMASK_ISR_EXIT \
| SYSVIEW_EVTMASK_ISR_TO_SCHEDULER) | SYSVIEW_EVTMASK_ISR_TO_SCHEDULER)
#define SYSVIEW_EVTMASK_ALL_TASKS ( SYSVIEW_EVTMASK_TASK_START_EXEC \ #define SYSVIEW_EVTMASK_ALL_TASKS ( SYSVIEW_EVTMASK_TASK_START_EXEC \
| SYSVIEW_EVTMASK_TASK_STOP_EXEC \ | SYSVIEW_EVTMASK_TASK_STOP_EXEC \
| SYSVIEW_EVTMASK_TASK_START_READY \ | SYSVIEW_EVTMASK_TASK_START_READY \
| SYSVIEW_EVTMASK_TASK_STOP_READY \ | SYSVIEW_EVTMASK_TASK_STOP_READY \
| SYSVIEW_EVTMASK_TASK_CREATE \ | SYSVIEW_EVTMASK_TASK_CREATE \
| SYSVIEW_EVTMASK_TASK_INFO \ | SYSVIEW_EVTMASK_TASK_INFO \
| SYSVIEW_EVTMASK_STACK_INFO \ | SYSVIEW_EVTMASK_STACK_INFO \
| SYSVIEW_EVTMASK_TASK_TERMINATE) | SYSVIEW_EVTMASK_TASK_TERMINATE)
/********************************************************************* /*********************************************************************
* *
* Structures * Structures
* *
********************************************************************** **********************************************************************
*/ */
typedef struct { typedef struct {
U32 TaskID; U32 TaskID;
const char* sName; const char* sName;
U32 Prio; U32 Prio;
U32 StackBase; U32 StackBase;
U32 StackSize; U32 StackSize;
} SEGGER_SYSVIEW_TASKINFO; } SEGGER_SYSVIEW_TASKINFO;
typedef struct SEGGER_SYSVIEW_MODULE_STRUCT SEGGER_SYSVIEW_MODULE; typedef struct SEGGER_SYSVIEW_MODULE_STRUCT SEGGER_SYSVIEW_MODULE;
struct SEGGER_SYSVIEW_MODULE_STRUCT { struct SEGGER_SYSVIEW_MODULE_STRUCT {
const char* sModule; const char* sModule;
U32 NumEvents; U32 NumEvents;
U32 EventOffset; U32 EventOffset;
void (*pfSendModuleDesc)(void); void (*pfSendModuleDesc)(void);
SEGGER_SYSVIEW_MODULE* pNext; SEGGER_SYSVIEW_MODULE* pNext;
}; };
typedef void (SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC)(void); typedef void (SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC)(void);
/********************************************************************* /*********************************************************************
* *
* Global data * Global data
* *
********************************************************************** **********************************************************************
*/ */
#ifdef EXTERN #ifdef EXTERN
#undef EXTERN #undef EXTERN
#endif #endif
#ifndef SEGGER_SYSVIEW_C // Defined in SEGGER_SYSVIEW.c which includes this header beside other C-files #ifndef SEGGER_SYSVIEW_C // Defined in SEGGER_SYSVIEW.c which includes this header beside other C-files
#define EXTERN extern #define EXTERN extern
#else #else
#define EXTERN #define EXTERN
#endif #endif
EXTERN unsigned int SEGGER_SYSVIEW_TickCnt; EXTERN unsigned int SEGGER_SYSVIEW_TickCnt;
EXTERN unsigned int SEGGER_SYSVIEW_InterruptId; EXTERN unsigned int SEGGER_SYSVIEW_InterruptId;
#undef EXTERN #undef EXTERN
/********************************************************************* /*********************************************************************
* *
* API functions * API functions
* *
********************************************************************** **********************************************************************
*/ */
typedef struct { typedef struct {
U64 (*pfGetTime) (void); U64 (*pfGetTime) (void);
void (*pfSendTaskList) (void); void (*pfSendTaskList) (void);
} SEGGER_SYSVIEW_OS_API; } SEGGER_SYSVIEW_OS_API;
/********************************************************************* /*********************************************************************
* *
* Control and initialization functions * Control and initialization functions
*/ */
void SEGGER_SYSVIEW_Init (U32 SysFreq, U32 CPUFreq, const SEGGER_SYSVIEW_OS_API *pOSAPI, SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC pfSendSysDesc); void SEGGER_SYSVIEW_Init (U32 SysFreq, U32 CPUFreq, const SEGGER_SYSVIEW_OS_API *pOSAPI, SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC pfSendSysDesc);
void SEGGER_SYSVIEW_SetRAMBase (U32 RAMBaseAddress); void SEGGER_SYSVIEW_SetRAMBase (U32 RAMBaseAddress);
void SEGGER_SYSVIEW_Start (void); void SEGGER_SYSVIEW_Start (void);
void SEGGER_SYSVIEW_Stop (void); void SEGGER_SYSVIEW_Stop (void);
void SEGGER_SYSVIEW_GetSysDesc (void); void SEGGER_SYSVIEW_GetSysDesc (void);
void SEGGER_SYSVIEW_SendTaskList (void); void SEGGER_SYSVIEW_SendTaskList (void);
void SEGGER_SYSVIEW_SendTaskInfo (const SEGGER_SYSVIEW_TASKINFO* pInfo); void SEGGER_SYSVIEW_SendTaskInfo (const SEGGER_SYSVIEW_TASKINFO* pInfo);
void SEGGER_SYSVIEW_SendSysDesc (const char* sSysDesc); void SEGGER_SYSVIEW_SendSysDesc (const char* sSysDesc);
int SEGGER_SYSVIEW_IsStarted (void); int SEGGER_SYSVIEW_IsStarted (void);
int SEGGER_SYSVIEW_GetChannelID (void); int SEGGER_SYSVIEW_GetChannelID (void);
/********************************************************************* /*********************************************************************
* *
* Event recording functions * Event recording functions
*/ */
void SEGGER_SYSVIEW_RecordVoid (unsigned int EventId); void SEGGER_SYSVIEW_RecordVoid (unsigned int EventId);
void SEGGER_SYSVIEW_RecordU32 (unsigned int EventId, U32 Para0); void SEGGER_SYSVIEW_RecordU32 (unsigned int EventId, U32 Para0);
void SEGGER_SYSVIEW_RecordU32x2 (unsigned int EventId, U32 Para0, U32 Para1); void SEGGER_SYSVIEW_RecordU32x2 (unsigned int EventId, U32 Para0, U32 Para1);
void SEGGER_SYSVIEW_RecordU32x3 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2); void SEGGER_SYSVIEW_RecordU32x3 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2);
void SEGGER_SYSVIEW_RecordU32x4 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3); void SEGGER_SYSVIEW_RecordU32x4 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3);
void SEGGER_SYSVIEW_RecordU32x5 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4); void SEGGER_SYSVIEW_RecordU32x5 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4);
void SEGGER_SYSVIEW_RecordU32x6 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5); void SEGGER_SYSVIEW_RecordU32x6 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5);
void SEGGER_SYSVIEW_RecordU32x7 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6); void SEGGER_SYSVIEW_RecordU32x7 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6);
void SEGGER_SYSVIEW_RecordU32x8 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7); void SEGGER_SYSVIEW_RecordU32x8 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7);
void SEGGER_SYSVIEW_RecordU32x9 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8); void SEGGER_SYSVIEW_RecordU32x9 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8);
void SEGGER_SYSVIEW_RecordU32x10 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8, U32 Para9); void SEGGER_SYSVIEW_RecordU32x10 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8, U32 Para9);
void SEGGER_SYSVIEW_RecordString (unsigned int EventId, const char* pString); void SEGGER_SYSVIEW_RecordString (unsigned int EventId, const char* pString);
void SEGGER_SYSVIEW_RecordSystime (void); void SEGGER_SYSVIEW_RecordSystime (void);
void SEGGER_SYSVIEW_RecordEnterISR (void); void SEGGER_SYSVIEW_RecordEnterISR (void);
void SEGGER_SYSVIEW_RecordExitISR (void); void SEGGER_SYSVIEW_RecordExitISR (void);
void SEGGER_SYSVIEW_RecordExitISRToScheduler (void); void SEGGER_SYSVIEW_RecordExitISRToScheduler (void);
void SEGGER_SYSVIEW_RecordEnterTimer (U32 TimerId); void SEGGER_SYSVIEW_RecordEnterTimer (U32 TimerId);
void SEGGER_SYSVIEW_RecordExitTimer (void); void SEGGER_SYSVIEW_RecordExitTimer (void);
void SEGGER_SYSVIEW_RecordEndCall (unsigned int EventID); void SEGGER_SYSVIEW_RecordEndCall (unsigned int EventID);
void SEGGER_SYSVIEW_RecordEndCallU32 (unsigned int EventID, U32 Para0); void SEGGER_SYSVIEW_RecordEndCallU32 (unsigned int EventID, U32 Para0);
void SEGGER_SYSVIEW_OnIdle (void); void SEGGER_SYSVIEW_OnIdle (void);
void SEGGER_SYSVIEW_OnTaskCreate (U32 TaskId); void SEGGER_SYSVIEW_OnTaskCreate (U32 TaskId);
void SEGGER_SYSVIEW_OnTaskTerminate (U32 TaskId); void SEGGER_SYSVIEW_OnTaskTerminate (U32 TaskId);
void SEGGER_SYSVIEW_OnTaskStartExec (U32 TaskId); void SEGGER_SYSVIEW_OnTaskStartExec (U32 TaskId);
void SEGGER_SYSVIEW_OnTaskStopExec (void); void SEGGER_SYSVIEW_OnTaskStopExec (void);
void SEGGER_SYSVIEW_OnTaskStartReady (U32 TaskId); void SEGGER_SYSVIEW_OnTaskStartReady (U32 TaskId);
void SEGGER_SYSVIEW_OnTaskStopReady (U32 TaskId, unsigned int Cause); void SEGGER_SYSVIEW_OnTaskStopReady (U32 TaskId, unsigned int Cause);
void SEGGER_SYSVIEW_MarkStart (unsigned int MarkerId); void SEGGER_SYSVIEW_MarkStart (unsigned int MarkerId);
void SEGGER_SYSVIEW_MarkStop (unsigned int MarkerId); void SEGGER_SYSVIEW_MarkStop (unsigned int MarkerId);
void SEGGER_SYSVIEW_Mark (unsigned int MarkerId); void SEGGER_SYSVIEW_Mark (unsigned int MarkerId);
void SEGGER_SYSVIEW_NameMarker (unsigned int MarkerId, const char* sName); void SEGGER_SYSVIEW_NameMarker (unsigned int MarkerId, const char* sName);
void SEGGER_SYSVIEW_NameResource (U32 ResourceId, const char* sName); void SEGGER_SYSVIEW_NameResource (U32 ResourceId, const char* sName);
int SEGGER_SYSVIEW_SendPacket (U8* pPacket, U8* pPayloadEnd, unsigned int EventId); int SEGGER_SYSVIEW_SendPacket (U8* pPacket, U8* pPayloadEnd, unsigned int EventId);
/********************************************************************* /*********************************************************************
* *
* Event parameter encoding functions * Event parameter encoding functions
*/ */
U8* SEGGER_SYSVIEW_EncodeU32 (U8* pPayload, U32 Value); U8* SEGGER_SYSVIEW_EncodeU32 (U8* pPayload, U32 Value);
U8* SEGGER_SYSVIEW_EncodeData (U8* pPayload, const char* pSrc, unsigned int Len); U8* SEGGER_SYSVIEW_EncodeData (U8* pPayload, const char* pSrc, unsigned int Len);
U8* SEGGER_SYSVIEW_EncodeString (U8* pPayload, const char* s, unsigned int MaxLen); U8* SEGGER_SYSVIEW_EncodeString (U8* pPayload, const char* s, unsigned int MaxLen);
U8* SEGGER_SYSVIEW_EncodeId (U8* pPayload, U32 Id); U8* SEGGER_SYSVIEW_EncodeId (U8* pPayload, U32 Id);
U32 SEGGER_SYSVIEW_ShrinkId (U32 Id); U32 SEGGER_SYSVIEW_ShrinkId (U32 Id);
/********************************************************************* /*********************************************************************
* *
* Middleware module registration * Middleware module registration
*/ */
void SEGGER_SYSVIEW_RegisterModule (SEGGER_SYSVIEW_MODULE* pModule); void SEGGER_SYSVIEW_RegisterModule (SEGGER_SYSVIEW_MODULE* pModule);
void SEGGER_SYSVIEW_RecordModuleDescription (const SEGGER_SYSVIEW_MODULE* pModule, const char* sDescription); void SEGGER_SYSVIEW_RecordModuleDescription (const SEGGER_SYSVIEW_MODULE* pModule, const char* sDescription);
void SEGGER_SYSVIEW_SendModule (U8 ModuleId); void SEGGER_SYSVIEW_SendModule (U8 ModuleId);
void SEGGER_SYSVIEW_SendModuleDescription (void); void SEGGER_SYSVIEW_SendModuleDescription (void);
void SEGGER_SYSVIEW_SendNumModules (void); void SEGGER_SYSVIEW_SendNumModules (void);
/********************************************************************* /*********************************************************************
* *
* printf-Style functions * printf-Style functions
*/ */
#ifndef SEGGER_SYSVIEW_EXCLUDE_PRINTF // Define in project to avoid warnings about variable parameter list #ifndef SEGGER_SYSVIEW_EXCLUDE_PRINTF // Define in project to avoid warnings about variable parameter list
void SEGGER_SYSVIEW_PrintfHostEx (const char* s, U32 Options, ...); void SEGGER_SYSVIEW_PrintfHostEx (const char* s, U32 Options, ...);
void SEGGER_SYSVIEW_PrintfTargetEx (const char* s, U32 Options, ...); void SEGGER_SYSVIEW_PrintfTargetEx (const char* s, U32 Options, ...);
void SEGGER_SYSVIEW_PrintfHost (const char* s, ...); void SEGGER_SYSVIEW_PrintfHost (const char* s, ...);
void SEGGER_SYSVIEW_PrintfTarget (const char* s, ...); void SEGGER_SYSVIEW_PrintfTarget (const char* s, ...);
void SEGGER_SYSVIEW_WarnfHost (const char* s, ...); void SEGGER_SYSVIEW_WarnfHost (const char* s, ...);
void SEGGER_SYSVIEW_WarnfTarget (const char* s, ...); void SEGGER_SYSVIEW_WarnfTarget (const char* s, ...);
void SEGGER_SYSVIEW_ErrorfHost (const char* s, ...); void SEGGER_SYSVIEW_ErrorfHost (const char* s, ...);
void SEGGER_SYSVIEW_ErrorfTarget (const char* s, ...); void SEGGER_SYSVIEW_ErrorfTarget (const char* s, ...);
#endif #endif
void SEGGER_SYSVIEW_Print (const char* s); void SEGGER_SYSVIEW_Print (const char* s);
void SEGGER_SYSVIEW_Warn (const char* s); void SEGGER_SYSVIEW_Warn (const char* s);
void SEGGER_SYSVIEW_Error (const char* s); void SEGGER_SYSVIEW_Error (const char* s);
/********************************************************************* /*********************************************************************
* *
* Run-time configuration functions * Run-time configuration functions
*/ */
void SEGGER_SYSVIEW_EnableEvents (U32 EnableMask); void SEGGER_SYSVIEW_EnableEvents (U32 EnableMask);
void SEGGER_SYSVIEW_DisableEvents (U32 DisableMask); void SEGGER_SYSVIEW_DisableEvents (U32 DisableMask);
/********************************************************************* /*********************************************************************
* *
* Application-provided functions * Application-provided functions
*/ */
void SEGGER_SYSVIEW_Conf (void); void SEGGER_SYSVIEW_Conf (void);
U32 SEGGER_SYSVIEW_X_GetTimestamp (void); U32 SEGGER_SYSVIEW_X_GetTimestamp (void);
U32 SEGGER_SYSVIEW_X_GetInterruptId (void); U32 SEGGER_SYSVIEW_X_GetInterruptId (void);
void SEGGER_SYSVIEW_X_StartComm (void); void SEGGER_SYSVIEW_X_StartComm (void);
void SEGGER_SYSVIEW_X_OnEventRecorded (unsigned NumBytes); void SEGGER_SYSVIEW_X_OnEventRecorded (unsigned NumBytes);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Compatibility API defines * Compatibility API defines
*/ */
#define SEGGER_SYSVIEW_OnUserStart SEGGER_SYSVIEW_MarkStart #define SEGGER_SYSVIEW_OnUserStart SEGGER_SYSVIEW_MarkStart
#define SEGGER_SYSVIEW_OnUserStop SEGGER_SYSVIEW_MarkStop #define SEGGER_SYSVIEW_OnUserStop SEGGER_SYSVIEW_MarkStop
#endif #endif
/*************************** End of file ****************************/ /*************************** End of file ****************************/

1114
core/embed/segger/SEGGER/SEGGER_SYSVIEW_ConfDefaults.h
View File

File diff suppressed because it is too large Load Diff

296
core/embed/segger/SEGGER/SEGGER_SYSVIEW_Config_NoOS.c
View File

@ -1,148 +1,148 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
-------------------------- END-OF-HEADER ----------------------------- -------------------------- END-OF-HEADER -----------------------------
File : SEGGER_SYSVIEW_Config_NoOS.c File : SEGGER_SYSVIEW_Config_NoOS.c
Purpose : Sample setup configuration of SystemView without an OS. Purpose : Sample setup configuration of SystemView without an OS.
Revision: $Rev: 9599 $ Revision: $Rev: 9599 $
*/ */
#include "SEGGER_SYSVIEW.h" #include "SEGGER_SYSVIEW.h"
#include "SEGGER_SYSVIEW_Conf.h" #include "SEGGER_SYSVIEW_Conf.h"
// SystemcoreClock can be used in most CMSIS compatible projects. // SystemcoreClock can be used in most CMSIS compatible projects.
// In non-CMSIS projects define SYSVIEW_CPU_FREQ. // In non-CMSIS projects define SYSVIEW_CPU_FREQ.
extern unsigned int SystemCoreClock; extern unsigned int SystemCoreClock;
/********************************************************************* /*********************************************************************
* *
* Defines, configurable * Defines, configurable
* *
********************************************************************** **********************************************************************
*/ */
// The application name to be displayed in SystemViewer // The application name to be displayed in SystemViewer
#define SYSVIEW_APP_NAME "Trezor Core" #define SYSVIEW_APP_NAME "Trezor Core"
// The target device name // The target device name
#define SYSVIEW_DEVICE_NAME "STM32F427VI" #define SYSVIEW_DEVICE_NAME "STM32F427VI"
// Frequency of the timestamp. Must match SEGGER_SYSVIEW_Conf.h // Frequency of the timestamp. Must match SEGGER_SYSVIEW_Conf.h
#define SYSVIEW_TIMESTAMP_FREQ (SystemCoreClock) #define SYSVIEW_TIMESTAMP_FREQ (SystemCoreClock)
// System Frequency. SystemcoreClock is used in most CMSIS compatible projects. // System Frequency. SystemcoreClock is used in most CMSIS compatible projects.
#define SYSVIEW_CPU_FREQ (SystemCoreClock) #define SYSVIEW_CPU_FREQ (SystemCoreClock)
// The lowest RAM address used for IDs (pointers) // The lowest RAM address used for IDs (pointers)
#define SYSVIEW_RAM_BASE (0x10000000) #define SYSVIEW_RAM_BASE (0x10000000)
// Define as 1 if the Cortex-M cycle counter is used as SystemView timestamp. Must match SEGGER_SYSVIEW_Conf.h // Define as 1 if the Cortex-M cycle counter is used as SystemView timestamp. Must match SEGGER_SYSVIEW_Conf.h
#ifndef USE_CYCCNT_TIMESTAMP #ifndef USE_CYCCNT_TIMESTAMP
#define USE_CYCCNT_TIMESTAMP 1 #define USE_CYCCNT_TIMESTAMP 1
#endif #endif
// Define as 1 if the Cortex-M cycle counter is used and there might be no debugger attached while recording. // Define as 1 if the Cortex-M cycle counter is used and there might be no debugger attached while recording.
#ifndef ENABLE_DWT_CYCCNT #ifndef ENABLE_DWT_CYCCNT
#define ENABLE_DWT_CYCCNT (USE_CYCCNT_TIMESTAMP & SEGGER_SYSVIEW_POST_MORTEM_MODE) #define ENABLE_DWT_CYCCNT (USE_CYCCNT_TIMESTAMP & SEGGER_SYSVIEW_POST_MORTEM_MODE)
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Defines, fixed * Defines, fixed
* *
********************************************************************** **********************************************************************
*/ */
#define DEMCR (*(volatile unsigned long*) (0xE000EDFCuL)) // Debug Exception and Monitor Control Register #define DEMCR (*(volatile unsigned long*) (0xE000EDFCuL)) // Debug Exception and Monitor Control Register
#define TRACEENA_BIT (1uL << 24) // Trace enable bit #define TRACEENA_BIT (1uL << 24) // Trace enable bit
#define DWT_CTRL (*(volatile unsigned long*) (0xE0001000uL)) // DWT Control Register #define DWT_CTRL (*(volatile unsigned long*) (0xE0001000uL)) // DWT Control Register
#define NOCYCCNT_BIT (1uL << 25) // Cycle counter support bit #define NOCYCCNT_BIT (1uL << 25) // Cycle counter support bit
#define CYCCNTENA_BIT (1uL << 0) // Cycle counter enable bit #define CYCCNTENA_BIT (1uL << 0) // Cycle counter enable bit
/********************************************************************* /*********************************************************************
* *
* _cbSendSystemDesc() * _cbSendSystemDesc()
* *
* Function description * Function description
* Sends SystemView description strings. * Sends SystemView description strings.
*/ */
static void _cbSendSystemDesc(void) { static void _cbSendSystemDesc(void) {
SEGGER_SYSVIEW_SendSysDesc("N="SYSVIEW_APP_NAME",D="SYSVIEW_DEVICE_NAME); SEGGER_SYSVIEW_SendSysDesc("N="SYSVIEW_APP_NAME",D="SYSVIEW_DEVICE_NAME);
SEGGER_SYSVIEW_SendSysDesc("I#15=SysTick"); SEGGER_SYSVIEW_SendSysDesc("I#15=SysTick");
SEGGER_SYSVIEW_SendSysDesc("I#93=USB_HS"); SEGGER_SYSVIEW_SendSysDesc("I#93=USB_HS");
} }
/********************************************************************* /*********************************************************************
* *
* Global functions * Global functions
* *
********************************************************************** **********************************************************************
*/ */
void SEGGER_SYSVIEW_Conf(void) { void SEGGER_SYSVIEW_Conf(void) {
#if USE_CYCCNT_TIMESTAMP #if USE_CYCCNT_TIMESTAMP
#if ENABLE_DWT_CYCCNT #if ENABLE_DWT_CYCCNT
// //
// If no debugger is connected, the DWT must be enabled by the application // If no debugger is connected, the DWT must be enabled by the application
// //
if ((DEMCR & TRACEENA_BIT) == 0) { if ((DEMCR & TRACEENA_BIT) == 0) {
DEMCR |= TRACEENA_BIT; DEMCR |= TRACEENA_BIT;
} }
#endif #endif
// //
// The cycle counter must be activated in order // The cycle counter must be activated in order
// to use time related functions. // to use time related functions.
// //
if ((DWT_CTRL & NOCYCCNT_BIT) == 0) { // Cycle counter supported? if ((DWT_CTRL & NOCYCCNT_BIT) == 0) { // Cycle counter supported?
if ((DWT_CTRL & CYCCNTENA_BIT) == 0) { // Cycle counter not enabled? if ((DWT_CTRL & CYCCNTENA_BIT) == 0) { // Cycle counter not enabled?
DWT_CTRL |= CYCCNTENA_BIT; // Enable Cycle counter DWT_CTRL |= CYCCNTENA_BIT; // Enable Cycle counter
} }
} }
#endif #endif
SEGGER_SYSVIEW_Init(SYSVIEW_TIMESTAMP_FREQ, SYSVIEW_CPU_FREQ, SEGGER_SYSVIEW_Init(SYSVIEW_TIMESTAMP_FREQ, SYSVIEW_CPU_FREQ,
0, _cbSendSystemDesc); 0, _cbSendSystemDesc);
SEGGER_SYSVIEW_SetRAMBase(SYSVIEW_RAM_BASE); SEGGER_SYSVIEW_SetRAMBase(SYSVIEW_RAM_BASE);
} }
/*************************** End of file ****************************/ /*************************** End of file ****************************/

198
core/embed/segger/SEGGER/SEGGER_SYSVIEW_Int.h
View File

@ -1,99 +1,99 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
-------------------------- END-OF-HEADER ----------------------------- -------------------------- END-OF-HEADER -----------------------------
File : SEGGER_SYSVIEW_Int.h File : SEGGER_SYSVIEW_Int.h
Purpose : SEGGER SystemView internal header. Purpose : SEGGER SystemView internal header.
Revision: $Rev: 21281 $ Revision: $Rev: 21281 $
*/ */
#ifndef SEGGER_SYSVIEW_INT_H #ifndef SEGGER_SYSVIEW_INT_H
#define SEGGER_SYSVIEW_INT_H #define SEGGER_SYSVIEW_INT_H
/********************************************************************* /*********************************************************************
* *
* #include Section * #include Section
* *
********************************************************************** **********************************************************************
*/ */
#include "SEGGER_SYSVIEW.h" #include "SEGGER_SYSVIEW.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/********************************************************************* /*********************************************************************
* *
* Private data types * Private data types
* *
********************************************************************** **********************************************************************
*/ */
// //
// Commands that Host can send to target // Commands that Host can send to target
// //
typedef enum { typedef enum {
SEGGER_SYSVIEW_COMMAND_ID_START = 1, SEGGER_SYSVIEW_COMMAND_ID_START = 1,
SEGGER_SYSVIEW_COMMAND_ID_STOP, SEGGER_SYSVIEW_COMMAND_ID_STOP,
SEGGER_SYSVIEW_COMMAND_ID_GET_SYSTIME, SEGGER_SYSVIEW_COMMAND_ID_GET_SYSTIME,
SEGGER_SYSVIEW_COMMAND_ID_GET_TASKLIST, SEGGER_SYSVIEW_COMMAND_ID_GET_TASKLIST,
SEGGER_SYSVIEW_COMMAND_ID_GET_SYSDESC, SEGGER_SYSVIEW_COMMAND_ID_GET_SYSDESC,
SEGGER_SYSVIEW_COMMAND_ID_GET_NUMMODULES, SEGGER_SYSVIEW_COMMAND_ID_GET_NUMMODULES,
SEGGER_SYSVIEW_COMMAND_ID_GET_MODULEDESC, SEGGER_SYSVIEW_COMMAND_ID_GET_MODULEDESC,
SEGGER_SYSVIEW_COMMAND_ID_HEARTBEAT = 127, SEGGER_SYSVIEW_COMMAND_ID_HEARTBEAT = 127,
// Extended commands: Commands >= 128 have a second parameter // Extended commands: Commands >= 128 have a second parameter
SEGGER_SYSVIEW_COMMAND_ID_GET_MODULE = 128 SEGGER_SYSVIEW_COMMAND_ID_GET_MODULE = 128
} SEGGER_SYSVIEW_COMMAND_ID; } SEGGER_SYSVIEW_COMMAND_ID;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
/*************************** End of file ****************************/ /*************************** End of file ****************************/

248
core/embed/segger/SEGGER/Syscalls/SEGGER_RTT_Syscalls_GCC.c
View File

@ -1,124 +1,124 @@
/********************************************************************* /*********************************************************************
* SEGGER Microcontroller GmbH * * SEGGER Microcontroller GmbH *
* The Embedded Experts * * The Embedded Experts *
********************************************************************** **********************************************************************
* * * *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH * * (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* * * *
* www.segger.com Support: support@segger.com * * www.segger.com Support: support@segger.com *
* * * *
********************************************************************** **********************************************************************
* * * *
* SEGGER SystemView * Real-time application analysis * * SEGGER SystemView * Real-time application analysis *
* * * *
********************************************************************** **********************************************************************
* * * *
* All rights reserved. * * All rights reserved. *
* * * *
* SEGGER strongly recommends to not make any changes * * SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay * * to or modify the source code of this software in order to stay *
* compatible with the SystemView and RTT protocol, and J-Link. * * compatible with the SystemView and RTT protocol, and J-Link. *
* * * *
* Redistribution and use in source and binary forms, with or * * Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following * * without modification, are permitted provided that the following *
* condition is met: * * condition is met: *
* * * *
* o Redistributions of source code must retain the above copyright * * o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. * * notice, this condition and the following disclaimer. *
* * * *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. * * DAMAGE. *
* * * *
********************************************************************** **********************************************************************
* * * *
* SystemView version: 3.20 * * SystemView version: 3.20 *
* * * *
********************************************************************** **********************************************************************
---------------------------END-OF-HEADER------------------------------ ---------------------------END-OF-HEADER------------------------------
File : SEGGER_RTT_Syscalls_GCC.c File : SEGGER_RTT_Syscalls_GCC.c
Purpose : Low-level functions for using printf() via RTT in GCC. Purpose : Low-level functions for using printf() via RTT in GCC.
To use RTT for printf output, include this file in your To use RTT for printf output, include this file in your
application. application.
Revision: $Rev: 20755 $ Revision: $Rev: 20755 $
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#if (defined __GNUC__) && !(defined __SES_ARM) && !(defined __CROSSWORKS_ARM) && !(defined __ARMCC_VERSION) && !(defined __CC_ARM) #if (defined __GNUC__) && !(defined __SES_ARM) && !(defined __CROSSWORKS_ARM) && !(defined __ARMCC_VERSION) && !(defined __CC_ARM)
#include <reent.h> // required for _write_r #include <reent.h> // required for _write_r
#include "SEGGER_RTT.h" #include "SEGGER_RTT.h"
/********************************************************************* /*********************************************************************
* *
* Types * Types
* *
********************************************************************** **********************************************************************
*/ */
// //
// If necessary define the _reent struct // If necessary define the _reent struct
// to match the one passed by the used standard library. // to match the one passed by the used standard library.
// //
struct _reent; struct _reent;
/********************************************************************* /*********************************************************************
* *
* Function prototypes * Function prototypes
* *
********************************************************************** **********************************************************************
*/ */
_ssize_t _write (int file, const void *ptr, size_t len); _ssize_t _write (int file, const void *ptr, size_t len);
_ssize_t _write_r(struct _reent *r, int file, const void *ptr, size_t len); _ssize_t _write_r(struct _reent *r, int file, const void *ptr, size_t len);
/********************************************************************* /*********************************************************************
* *
* Global functions * Global functions
* *
********************************************************************** **********************************************************************
*/ */
/********************************************************************* /*********************************************************************
* *
* _write() * _write()
* *
* Function description * Function description
* Low-level write function. * Low-level write function.
* libc subroutines will use this system routine for output to all files, * libc subroutines will use this system routine for output to all files,
* including stdout. * including stdout.
* Write data via RTT. * Write data via RTT.
*/ */
_ssize_t _write(int file, const void *ptr, size_t len) { _ssize_t _write(int file, const void *ptr, size_t len) {
(void) file; /* Not used, avoid warning */ (void) file; /* Not used, avoid warning */
SEGGER_RTT_Write(0, ptr, len); SEGGER_RTT_Write(0, ptr, len);
return len; return len;
} }
/********************************************************************* /*********************************************************************
* *
* _write_r() * _write_r()
* *
* Function description * Function description
* Low-level reentrant write function. * Low-level reentrant write function.
* libc subroutines will use this system routine for output to all files, * libc subroutines will use this system routine for output to all files,
* including stdout. * including stdout.
* Write data via RTT. * Write data via RTT.
*/ */
_ssize_t _write_r(struct _reent *r, int file, const void *ptr, size_t len) { _ssize_t _write_r(struct _reent *r, int file, const void *ptr, size_t len) {
(void) file; /* Not used, avoid warning */ (void) file; /* Not used, avoid warning */
(void) r; /* Not used, avoid warning */ (void) r; /* Not used, avoid warning */
SEGGER_RTT_Write(0, ptr, len); SEGGER_RTT_Write(0, ptr, len);
return len; return len;
} }
#endif #endif
/****** End Of File *************************************************/ /****** End Of File *************************************************/