git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/FreeRTOS-Plus-Trace/streamports/Jlink_RTT/include/SEGGER_RTT_Conf.h

   1 /*********************************************************************\r
   2 *               SEGGER MICROCONTROLLER GmbH & Co. KG                 *\r
   3 *       Solutions for real time microcontroller applications         *\r
   4 **********************************************************************\r
   5 *                                                                    *\r
   6 *       (c) 2014 - 2016  SEGGER Microcontroller GmbH & Co. KG        *\r
   7 *                                                                    *\r
   8 *       www.segger.com     Support: support@segger.com               *\r
   9 *                                                                    *\r
  10 **********************************************************************\r
  11 *                                                                    *\r
  12 *       SEGGER RTT * Real Time Transfer for embedded targets         *\r
  13 *                                                                    *\r
  14 **********************************************************************\r
  15 *                                                                    *\r
  16 * All rights reserved.                                               *\r
  17 *                                                                    *\r
  18 * * This software may in its unmodified form be freely redistributed *\r
  19 *   in source, linkable, or executable form.                         *\r
  20 * * The source code may be modified, provided the source code        *\r
  21 *   retains the above copyright notice, this list of conditions and  *\r
  22 *   the following disclaimer.                                        *\r
  23 * * Modified versions of this software in source, executable, or     *\r
  24 *   linkable form may not be distributed without prior consent of    *\r
  25 *   SEGGER.                                                          *\r
  26 * * This software may only be used for communication with SEGGER     *\r
  27 *   J-Link debug probes.                                             *\r
  28 *                                                                    *\r
  29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *\r
  30 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *\r
  31 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *\r
  32 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *\r
  33 * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *\r
  34 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *\r
  35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *\r
  36 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *\r
  37 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *\r
  38 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *\r
  39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *\r
  40 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *\r
  41 * DAMAGE.                                                            *\r
  42 *                                                                    *\r
  43 **********************************************************************\r
  44 *                                                                    *\r
  45 *       RTT version: 6.00e                                           *\r
  46 *                                                                    *\r
  47 **********************************************************************\r
  48 ----------------------------------------------------------------------\r
  49 File    : SEGGER_RTT_Conf.h\r
  50 Purpose : Implementation of SEGGER real-time transfer (RTT) which \r
  51           allows real-time communication on targets which support \r
  52           debugger memory accesses while the CPU is running.\r
  53 Revision: $Rev: 3892 $\r
  54 ---------------------------END-OF-HEADER------------------------------\r
  55 */\r
  56 \r
  57 #ifndef SEGGER_RTT_CONF_H\r
  58 #define SEGGER_RTT_CONF_H\r
  59 \r
  60 #ifdef __IAR_SYSTEMS_ICC__\r
  61   #include <intrinsics.h>\r
  62 #endif\r
  63 \r
  64 /*********************************************************************\r
  65 *\r
  66 *       Defines, configurable\r
  67 *\r
  68 **********************************************************************\r
  69 */\r
  70 \r
  71 #define SEGGER_RTT_MAX_NUM_UP_BUFFERS             (3)     // Max. number of up-buffers (T->H) available on this target    (Default: 3)\r
  72 #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS           (3)     // Max. number of down-buffers (H->T) available on this target  (Default: 3)\r
  73 \r
  74 #define BUFFER_SIZE_UP                            (64)    // Size of the buffer for terminal output of target, up to host (Default: 1k)\r
  75 #define BUFFER_SIZE_DOWN                          (16)    // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16)\r
  76 \r
  77 #define SEGGER_RTT_PRINTF_BUFFER_SIZE             (64u)    // Size of buffer for RTT printf to bulk-send chars via RTT     (Default: 64)\r
  78 \r
  79 #define SEGGER_RTT_MODE_DEFAULT                   SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0)\r
  80 \r
  81 //\r
  82 // Target is not allowed to perform other RTT operations while string still has not been stored completely.\r
  83 // Otherwise we would probably end up with a mixed string in the buffer.\r
  84 // If using  RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here.\r
  85 // \r
  86 // SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4.\r
  87 // Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches.\r
  88 // When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly.\r
  89 // (Higher priority = lower priority number)\r
  90 // Default value for embOS: 128u\r
  91 // Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )\r
  92 // In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC\r
  93 // or define SEGGER_RTT_LOCK() to completely disable interrupts.\r
  94 // \r
  95 \r
  96 #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY         (0x20)   // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20)\r
  97 \r
  98 /*********************************************************************\r
  99 *\r
 100 *       RTT lock configuration for SEGGER Embedded Studio, \r
 101 *       Rowley CrossStudio and GCC\r
 102 */\r
 103 #if (defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)\r
 104   #ifdef __ARM_ARCH_6M__\r
 105     #define SEGGER_RTT_LOCK()   {                                                                   \\r
 106                                     unsigned int LockState;                                         \\r
 107                                   __asm volatile ("mrs   %0, primask  \n\t"                         \\r
 108                                                   "mov   r1, $1     \n\t"                           \\r
 109                                                   "msr   primask, r1  \n\t"                         \\r
 110                                                   : "=r" (LockState)                                \\r
 111                                                   :                                                 \\r
 112                                                   : "r1"                                            \\r
 113                                                   );                            \r
 114     \r
 115     #define SEGGER_RTT_UNLOCK()   __asm volatile ("msr   primask, %0  \n\t"                         \\r
 116                                                   :                                                 \\r
 117                                                   : "r" (LockState)                                 \\r
 118                                                   :                                                 \\r
 119                                                   );                                                \\r
 120                                 }                                             \r
 121                                   \r
 122   #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))\r
 123     #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY\r
 124       #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)\r
 125     #endif\r
 126     #define SEGGER_RTT_LOCK()   {                                                                   \\r
 127                                     unsigned int LockState;                                         \\r
 128                                   __asm volatile ("mrs   %0, basepri  \n\t"                         \\r
 129                                                   "mov   r1, %1       \n\t"                         \\r
 130                                                   "msr   basepri, r1  \n\t"                         \\r
 131                                                   : "=r" (LockState)                                \\r
 132                                                   : "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY)          \\r
 133                                                   : "r1"                                            \\r
 134                                                   );                            \r
 135     \r
 136     #define SEGGER_RTT_UNLOCK()   __asm volatile ("msr   basepri, %0  \n\t"                         \\r
 137                                                   :                                                 \\r
 138                                                   : "r" (LockState)                                 \\r
 139                                                   :                                                 \\r
 140                                                   );                                                \\r
 141                                 }\r
 142   \r
 143   #elif defined(__ARM_ARCH_7A__)\r
 144     #define SEGGER_RTT_LOCK() {                                                \\r
 145                                  unsigned int LockState;                       \\r
 146                                  __asm volatile ("mrs r1, CPSR \n\t"           \\r
 147                                                  "mov %0, r1 \n\t"             \\r
 148                                                  "orr r1, r1, #0xC0 \n\t"      \\r
 149                                                  "msr CPSR_c, r1 \n\t"         \\r
 150                                                  : "=r" (LockState)            \\r
 151                                                  :                             \\r
 152                                                  : "r1"                        \\r
 153                                                  );\r
 154 \r
 155     #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t"              \\r
 156                                                 "mrs r1, CPSR \n\t"            \\r
 157                                                 "bic r1, r1, #0xC0 \n\t"       \\r
 158                                                 "and r0, r0, #0xC0 \n\t"       \\r
 159                                                 "orr r1, r1, r0 \n\t"          \\r
 160                                                 "msr CPSR_c, r1 \n\t"          \\r
 161                                                 :                              \\r
 162                                                 : "r" (LockState)              \\r
 163                                                 : "r0", "r1"                   \\r
 164                                                 );                             \\r
 165                             }\r
 166 #else\r
 167     #define SEGGER_RTT_LOCK()  \r
 168     #define SEGGER_RTT_UNLOCK()\r
 169   #endif\r
 170 #endif\r
 171 \r
 172 /*********************************************************************\r
 173 *\r
 174 *       RTT lock configuration for IAR EWARM\r
 175 */\r
 176 #ifdef __ICCARM__\r
 177   #if (defined (__ARM6M__) && (__CORE__ == __ARM6M__))\r
 178     #define SEGGER_RTT_LOCK()   {                                                                   \\r
 179                                   unsigned int LockState;                                           \\r
 180                                   LockState = __get_PRIMASK();                                      \\r
 181                                   __set_PRIMASK(1);                           \r
 182                                     \r
 183     #define SEGGER_RTT_UNLOCK()   __set_PRIMASK(LockState);                                         \\r
 184                                 }\r
 185   #elif ((defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) || (defined (__ARM7M__) && (__CORE__ == __ARM7M__)))\r
 186     #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY\r
 187       #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)\r
 188     #endif\r
 189     #define SEGGER_RTT_LOCK()   {                                                                   \\r
 190                                   unsigned int LockState;                                           \\r
 191                                   LockState = __get_BASEPRI();                                      \\r
 192                                   __set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);                           \r
 193                                     \r
 194     #define SEGGER_RTT_UNLOCK()   __set_BASEPRI(LockState);                                         \\r
 195                                 }  \r
 196   #endif\r
 197 #endif\r
 198 \r
 199 /*********************************************************************\r
 200 *\r
 201 *       RTT lock configuration for IAR RX\r
 202 */\r
 203 #ifdef __ICCRX__\r
 204   #define SEGGER_RTT_LOCK()   {                                                                     \\r
 205                                 unsigned long LockState;                                            \\r
 206                                 LockState = __get_interrupt_state();                                \\r
 207                                 __disable_interrupt();                           \r
 208                                   \r
 209   #define SEGGER_RTT_UNLOCK()   __set_interrupt_state(LockState);                                   \\r
 210                               }\r
 211 #endif\r
 212 \r
 213 /*********************************************************************\r
 214 *\r
 215 *       RTT lock configuration for KEIL ARM\r
 216 */\r
 217 #ifdef __CC_ARM\r
 218   #if (defined __TARGET_ARCH_6S_M)\r
 219     #define SEGGER_RTT_LOCK()   {                                                                   \\r
 220                                   unsigned int LockState;                                           \\r
 221                                   register unsigned char PRIMASK __asm( "primask");                 \\r
 222                                   LockState = PRIMASK;                                              \\r
 223                                   PRIMASK = 1u;                                                     \\r
 224                                   __schedule_barrier();\r
 225 \r
 226     #define SEGGER_RTT_UNLOCK()   PRIMASK = LockState;                                              \\r
 227                                   __schedule_barrier();                                             \\r
 228                                 }\r
 229   #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M))\r
 230     #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY\r
 231       #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)\r
 232     #endif\r
 233     #define SEGGER_RTT_LOCK()   {                                                                   \\r
 234                                   unsigned int LockState;                                           \\r
 235                                   register unsigned char BASEPRI __asm( "basepri");                 \\r
 236                                   LockState = BASEPRI;                                              \\r
 237                                   BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY;                      \\r
 238                                   __schedule_barrier();\r
 239 \r
 240     #define SEGGER_RTT_UNLOCK()   BASEPRI = LockState;                                              \\r
 241                                   __schedule_barrier();                                             \\r
 242                                 }\r
 243   #endif\r
 244 #endif\r
 245 \r
 246 /*********************************************************************\r
 247 *\r
 248 *       RTT lock configuration fallback\r
 249 */\r
 250 #ifndef   SEGGER_RTT_LOCK\r
 251   #define SEGGER_RTT_LOCK()                // Lock RTT (nestable)   (i.e. disable interrupts)\r
 252 #endif\r
 253 \r
 254 #ifndef   SEGGER_RTT_UNLOCK\r
 255   #define SEGGER_RTT_UNLOCK()              // Unlock RTT (nestable) (i.e. enable previous interrupt lock state)\r
 256 #endif\r
 257 \r
 258 #endif\r
 259 /*************************** End of file ****************************/\r