SEGGER_RTT.c File Reference

#include "SEGGER_RTT.h"
#include <string.h>

Go to the source code of this file.

Macros
#define	SEGGER_RTT_ALIGNMENT   SEGGER_RTT_CPU_CACHE_LINE_SIZE
#define	SEGGER_RTT_BUFFER_ALIGNMENT   SEGGER_RTT_CPU_CACHE_LINE_SIZE
#define	STRLEN(a)   strlen((a))
#define	STRCPY(pDest, pSrc)   strcpy((pDest), (pSrc))
#define	SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes)   memcpy((pDest), (pSrc), (NumBytes))
#define	MIN(a, b)   (((a) < (b)) ? (a) : (b))
#define	MAX(a, b)   (((a) > (b)) ? (a) : (b))
#define	NULL   0
#define	SEGGER_RTT_ALIGN(Var, Alignment)   Var
#define	SEGGER_RTT_PUT_SECTION(Var, Section)   Var
#define	SEGGER_RTT_CB_ALIGN(Var)   Var
#define	SEGGER_RTT_BUFFER_ALIGN(Var)   Var
#define	SEGGER_RTT_PUT_CB_SECTION(Var)   Var
#define	SEGGER_RTT_PUT_BUFFER_SECTION(Var)   Var
#define	INIT()

Functions
static void	_DoInit (void)
static unsigned	_WriteBlocking (SEGGER_RTT_BUFFER_UP *pRing, const char *pBuffer, unsigned NumBytes)
static void	_WriteNoCheck (SEGGER_RTT_BUFFER_UP *pRing, const char *pData, unsigned NumBytes)
static void	_PostTerminalSwitch (SEGGER_RTT_BUFFER_UP *pRing, unsigned char TerminalId)
static unsigned	_GetAvailWriteSpace (SEGGER_RTT_BUFFER_UP *pRing)
unsigned	SEGGER_RTT_ReadUpBufferNoLock (unsigned BufferIndex, void *pData, unsigned BufferSize)
unsigned	SEGGER_RTT_ReadNoLock (unsigned BufferIndex, void *pData, unsigned BufferSize)
unsigned	SEGGER_RTT_ReadUpBuffer (unsigned BufferIndex, void *pBuffer, unsigned BufferSize)
unsigned	SEGGER_RTT_Read (unsigned BufferIndex, void *pBuffer, unsigned BufferSize)
void	SEGGER_RTT_WriteWithOverwriteNoLock (unsigned BufferIndex, const void *pBuffer, unsigned NumBytes)
unsigned	SEGGER_RTT_WriteSkipNoLock (unsigned BufferIndex, const void *pBuffer, unsigned NumBytes)
unsigned	SEGGER_RTT_WriteDownBufferNoLock (unsigned BufferIndex, const void *pBuffer, unsigned NumBytes)
unsigned	SEGGER_RTT_WriteNoLock (unsigned BufferIndex, const void *pBuffer, unsigned NumBytes)
unsigned	SEGGER_RTT_WriteDownBuffer (unsigned BufferIndex, const void *pBuffer, unsigned NumBytes)
unsigned	SEGGER_RTT_Write (unsigned BufferIndex, const void *pBuffer, unsigned NumBytes)
unsigned	SEGGER_RTT_WriteString (unsigned BufferIndex, const char *s)
unsigned	SEGGER_RTT_PutCharSkipNoLock (unsigned BufferIndex, char c)
unsigned	SEGGER_RTT_PutCharSkip (unsigned BufferIndex, char c)
unsigned	SEGGER_RTT_PutChar (unsigned BufferIndex, char c)
int	SEGGER_RTT_GetKey (void)
int	SEGGER_RTT_WaitKey (void)
int	SEGGER_RTT_HasKey (void)
unsigned	SEGGER_RTT_HasData (unsigned BufferIndex)
unsigned	SEGGER_RTT_HasDataUp (unsigned BufferIndex)
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_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_SetNameUpBuffer (unsigned BufferIndex, const char *sName)
int	SEGGER_RTT_SetNameDownBuffer (unsigned BufferIndex, const char *sName)
int	SEGGER_RTT_SetFlagsUpBuffer (unsigned BufferIndex, unsigned Flags)
int	SEGGER_RTT_SetFlagsDownBuffer (unsigned BufferIndex, unsigned Flags)
void	SEGGER_RTT_Init (void)
int	SEGGER_RTT_SetTerminal (unsigned char TerminalId)
int	SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char *s)
unsigned	SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex)
unsigned	SEGGER_RTT_GetBytesInBuffer (unsigned BufferIndex)

Variables
static unsigned char	_aTerminalId [16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }
SEGGER_RTT_CB	_SEGGER_RTT
static char	_acUpBuffer [((1024))]
static char	_acDownBuffer [((16))]
static unsigned char	_ActiveTerminal

Macro Definition Documentation

INIT

#define INIT

(

)

Value:

                  {                                                                                    \
                  volatile SEGGER_RTT_CB* pRTTCBInit;                                                \
                  pRTTCBInit = (volatile SEGGER_RTT_CB*)((char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); \
                  do {                                                                               \
                    if (pRTTCBInit->acID[0] == '\0') {                                               \
                      _DoInit();                                                                     \
                    }                                                                                \
                  } while (0);                                                                       \
                }

Definition at line 287 of file SEGGER_RTT.c.

MAX

#define MAX	(		a,
			b
	)		(((a) > (b)) ? (a) : (b))

Definition at line 171 of file SEGGER_RTT.c.

MIN

#define MIN	(		a,
			b
	)		(((a) < (b)) ? (a) : (b))

Definition at line 167 of file SEGGER_RTT.c.

NULL

#define NULL   0

Definition at line 177 of file SEGGER_RTT.c.

SEGGER_RTT_ALIGN

#define SEGGER_RTT_ALIGN	(		Var,
			Alignment
	)		Var

Definition at line 203 of file SEGGER_RTT.c.

SEGGER_RTT_ALIGNMENT

#define SEGGER_RTT_ALIGNMENT   SEGGER_RTT_CPU_CACHE_LINE_SIZE

Definition at line 127 of file SEGGER_RTT.c.

SEGGER_RTT_BUFFER_ALIGN

#define SEGGER_RTT_BUFFER_ALIGN

(

Var

)

Var

Definition at line 230 of file SEGGER_RTT.c.

SEGGER_RTT_BUFFER_ALIGNMENT

#define SEGGER_RTT_BUFFER_ALIGNMENT   SEGGER_RTT_CPU_CACHE_LINE_SIZE

Definition at line 131 of file SEGGER_RTT.c.

SEGGER_RTT_CB_ALIGN

#define SEGGER_RTT_CB_ALIGN

(

Var

)

Var

Definition at line 224 of file SEGGER_RTT.c.

SEGGER_RTT_MEMCPY

#define SEGGER_RTT_MEMCPY	(		pDest,
			pSrc,
			NumBytes
	)		memcpy((pDest), (pSrc), (NumBytes))

Definition at line 162 of file SEGGER_RTT.c.

SEGGER_RTT_PUT_BUFFER_SECTION

#define SEGGER_RTT_PUT_BUFFER_SECTION

(

Var

)

Var

Definition at line 243 of file SEGGER_RTT.c.

SEGGER_RTT_PUT_CB_SECTION

#define SEGGER_RTT_PUT_CB_SECTION

(

Var

)

Var

Definition at line 237 of file SEGGER_RTT.c.

SEGGER_RTT_PUT_SECTION

#define SEGGER_RTT_PUT_SECTION	(		Var,
			Section
	)		Var

Definition at line 218 of file SEGGER_RTT.c.

STRCPY

#define STRCPY	(		pDest,
			pSrc
	)		strcpy((pDest), (pSrc))

Definition at line 151 of file SEGGER_RTT.c.

STRLEN

#define STRLEN

(

a

)

strlen((a))

Definition at line 147 of file SEGGER_RTT.c.

Function Documentation

_DoInit()

static void _DoInit ( void  )

static

Definition at line 297 of file SEGGER_RTT.c.

                          {
  volatile SEGGER_RTT_CB* p;   // Volatile to make sure that compiler cannot change the order of accesses to the control block
  //
  // Initialize control block
  //
  p                     = (volatile SEGGER_RTT_CB*)((char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access control block uncached so that nothing in the cache ever becomes dirty and all changes are visible in HW directly
  p->MaxNumUpBuffers    = SEGGER_RTT_MAX_NUM_UP_BUFFERS;
  p->MaxNumDownBuffers  = SEGGER_RTT_MAX_NUM_DOWN_BUFFERS;
  //
  // Initialize up buffer 0
  //
  p->aUp[0].sName         = "Terminal";
  p->aUp[0].pBuffer       = _acUpBuffer;
  p->aUp[0].SizeOfBuffer  = BUFFER_SIZE_UP;
  p->aUp[0].RdOff         = 0u;
  p->aUp[0].WrOff         = 0u;
  p->aUp[0].Flags         = SEGGER_RTT_MODE_DEFAULT;
  //
  // Initialize down buffer 0
  //
  p->aDown[0].sName         = "Terminal";
  p->aDown[0].pBuffer       = _acDownBuffer;
  p->aDown[0].SizeOfBuffer  = BUFFER_SIZE_DOWN;
  p->aDown[0].RdOff         = 0u;
  p->aDown[0].WrOff         = 0u;
  p->aDown[0].Flags         = SEGGER_RTT_MODE_DEFAULT;
  //
  // Finish initialization of the control block.
  // Copy Id string in three steps to make sure "SEGGER RTT" is not found
  // in initializer memory (usually flash) by J-Link
  //
  STRCPY((char*)&p->acID[7], "RTT");
  RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
  STRCPY((char*)&p->acID[0], "SEGGER");
  RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
  p->acID[6] = ' ';
  RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
}

_GetAvailWriteSpace()

static unsigned _GetAvailWriteSpace ( SEGGER_RTT_BUFFER_UP *  pRing )

static

Definition at line 507 of file SEGGER_RTT.c.

                                                                 {
  unsigned RdOff;
  unsigned WrOff;
  unsigned r;
  //
  // Avoid warnings regarding volatile access order.  It's not a problem
  // in this case, but dampen compiler enthusiasm.
  //
  RdOff = pRing->RdOff;
  WrOff = pRing->WrOff;
  if (RdOff <= WrOff) {
    r = pRing->SizeOfBuffer - 1u - WrOff + RdOff;
  } else {
    r = RdOff - WrOff - 1u;
  }
  return r;
}

_PostTerminalSwitch()

static void _PostTerminalSwitch ( SEGGER_RTT_BUFFER_UP *  pRing, unsigned char  TerminalId  )

static

Definition at line 485 of file SEGGER_RTT.c.

                                                                                       {
  unsigned char ac[2];
 
  ac[0] = 0xFFu;
  ac[1] = _aTerminalId[TerminalId];  // Caller made already sure that TerminalId does not exceed our terminal limit
  _WriteBlocking(pRing, (const char*)ac, 2u);
}

_WriteBlocking()

static unsigned _WriteBlocking ( SEGGER_RTT_BUFFER_UP *  pRing, const char *  pBuffer, unsigned  NumBytes  )

static

Definition at line 355 of file SEGGER_RTT.c.

                                                                                                    {
  unsigned NumBytesToWrite;
  unsigned NumBytesWritten;
  unsigned RdOff;
  unsigned WrOff;
  volatile char* pDst;
  //
  // Write data to buffer and handle wrap-around if necessary
  //
  NumBytesWritten = 0u;
  WrOff = pRing->WrOff;
  do {
    RdOff = pRing->RdOff;                         // May be changed by host (debug probe) in the meantime
    if (RdOff > WrOff) {
      NumBytesToWrite = RdOff - WrOff - 1u;
    } else {
      NumBytesToWrite = pRing->SizeOfBuffer - (WrOff - RdOff + 1u);
    }
    NumBytesToWrite = MIN(NumBytesToWrite, (pRing->SizeOfBuffer - WrOff));      // Number of bytes that can be written until buffer wrap-around
    NumBytesToWrite = MIN(NumBytesToWrite, NumBytes);
    pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    NumBytesWritten += NumBytesToWrite;
    NumBytes        -= NumBytesToWrite;
    WrOff           += NumBytesToWrite;
    while (NumBytesToWrite--) {
      *pDst++ = *pBuffer++;
    };
#else
    SEGGER_RTT_MEMCPY((void*)pDst, pBuffer, NumBytesToWrite);
    NumBytesWritten += NumBytesToWrite;
    pBuffer         += NumBytesToWrite;
    NumBytes        -= NumBytesToWrite;
    WrOff           += NumBytesToWrite;
#endif
    if (WrOff == pRing->SizeOfBuffer) {
      WrOff = 0u;
    }
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = WrOff;
  } while (NumBytes);
  return NumBytesWritten;
}

_WriteNoCheck()

static void _WriteNoCheck ( SEGGER_RTT_BUFFER_UP *  pRing, const char *  pData, unsigned  NumBytes  )

static

Definition at line 417 of file SEGGER_RTT.c.

                                                                                             {
  unsigned NumBytesAtOnce;
  unsigned WrOff;
  unsigned Rem;
  volatile char* pDst;
 
  WrOff = pRing->WrOff;
  Rem = pRing->SizeOfBuffer - WrOff;
  if (Rem > NumBytes) {
    //
    // All data fits before wrap around
    //
    pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    WrOff += NumBytes;
    while (NumBytes--) {
      *pDst++ = *pData++;
    };
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = WrOff;
#else
    SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytes);
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = WrOff + NumBytes;
#endif
  } else {
    //
    // We reach the end of the buffer, so need to wrap around
    //
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
    NumBytesAtOnce = Rem;
    while (NumBytesAtOnce--) {
      *pDst++ = *pData++;
    };
    pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF;
    NumBytesAtOnce = NumBytes - Rem;
    while (NumBytesAtOnce--) {
      *pDst++ = *pData++;
    };
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = NumBytes - Rem;
#else
    NumBytesAtOnce = Rem;
    pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
    SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytesAtOnce);
    NumBytesAtOnce = NumBytes - Rem;
    pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF;
    SEGGER_RTT_MEMCPY((void*)pDst, pData + Rem, NumBytesAtOnce);
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = NumBytesAtOnce;
#endif
  }
}

SEGGER_RTT_AllocDownBuffer()

int SEGGER_RTT_AllocDownBuffer	(	const char *	sName,
		void *	pBuffer,
		unsigned	BufferSize,
		unsigned	Flags
	)

Definition at line 1545 of file SEGGER_RTT.c.

                                                                                                      {
  int BufferIndex;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  SEGGER_RTT_LOCK();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  BufferIndex = 0;
  do {
    if (pRTTCB->aDown[BufferIndex].pBuffer == NULL) {
      break;
    }
    BufferIndex++;
  } while (BufferIndex < pRTTCB->MaxNumDownBuffers);
  if (BufferIndex < pRTTCB->MaxNumDownBuffers) {
    pRTTCB->aDown[BufferIndex].sName        = sName;
    pRTTCB->aDown[BufferIndex].pBuffer      = (char*)pBuffer;
    pRTTCB->aDown[BufferIndex].SizeOfBuffer = BufferSize;
    pRTTCB->aDown[BufferIndex].RdOff        = 0u;
    pRTTCB->aDown[BufferIndex].WrOff        = 0u;
    pRTTCB->aDown[BufferIndex].Flags        = Flags;
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
  } else {
    BufferIndex = -1;
  }
  SEGGER_RTT_UNLOCK();
  return BufferIndex;
}

SEGGER_RTT_AllocUpBuffer()

int SEGGER_RTT_AllocUpBuffer	(	const char *	sName,
		void *	pBuffer,
		unsigned	BufferSize,
		unsigned	Flags
	)

Definition at line 1593 of file SEGGER_RTT.c.

                                                                                                    {
  int BufferIndex;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  SEGGER_RTT_LOCK();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  BufferIndex = 0;
  do {
    if (pRTTCB->aUp[BufferIndex].pBuffer == NULL) {
      break;
    }
    BufferIndex++;
  } while (BufferIndex < pRTTCB->MaxNumUpBuffers);
  if (BufferIndex < pRTTCB->MaxNumUpBuffers) {
    pRTTCB->aUp[BufferIndex].sName        = sName;
    pRTTCB->aUp[BufferIndex].pBuffer      = (char*)pBuffer;
    pRTTCB->aUp[BufferIndex].SizeOfBuffer = BufferSize;
    pRTTCB->aUp[BufferIndex].RdOff        = 0u;
    pRTTCB->aUp[BufferIndex].WrOff        = 0u;
    pRTTCB->aUp[BufferIndex].Flags        = Flags;
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
  } else {
    BufferIndex = -1;
  }
  SEGGER_RTT_UNLOCK();
  return BufferIndex;
}

SEGGER_RTT_ConfigDownBuffer()

int SEGGER_RTT_ConfigDownBuffer	(	unsigned	BufferIndex,
		const char *	sName,
		void *	pBuffer,
		unsigned	BufferSize,
		unsigned	Flags
	)

Definition at line 1696 of file SEGGER_RTT.c.

                                                                                                                             {
  int r;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  if (BufferIndex < (unsigned)pRTTCB->MaxNumDownBuffers) {
    SEGGER_RTT_LOCK();
    if (BufferIndex > 0u) {
      pRTTCB->aDown[BufferIndex].sName        = sName;
      pRTTCB->aDown[BufferIndex].pBuffer      = (char*)pBuffer;
      pRTTCB->aDown[BufferIndex].SizeOfBuffer = BufferSize;
      pRTTCB->aDown[BufferIndex].RdOff        = 0u;
      pRTTCB->aDown[BufferIndex].WrOff        = 0u;
    }
    pRTTCB->aDown[BufferIndex].Flags          = Flags;
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    SEGGER_RTT_UNLOCK();
    r =  0;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_ConfigUpBuffer()

int SEGGER_RTT_ConfigUpBuffer	(	unsigned	BufferIndex,
		const char *	sName,
		void *	pBuffer,
		unsigned	BufferSize,
		unsigned	Flags
	)

Definition at line 1647 of file SEGGER_RTT.c.

                                                                                                                           {
  int r;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  if (BufferIndex < (unsigned)pRTTCB->MaxNumUpBuffers) {
    SEGGER_RTT_LOCK();
    if (BufferIndex > 0u) {
      pRTTCB->aUp[BufferIndex].sName        = sName;
      pRTTCB->aUp[BufferIndex].pBuffer      = (char*)pBuffer;
      pRTTCB->aUp[BufferIndex].SizeOfBuffer = BufferSize;
      pRTTCB->aUp[BufferIndex].RdOff        = 0u;
      pRTTCB->aUp[BufferIndex].WrOff        = 0u;
    }
    pRTTCB->aUp[BufferIndex].Flags          = Flags;
    SEGGER_RTT_UNLOCK();
    r =  0;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_GetAvailWriteSpace()

unsigned SEGGER_RTT_GetAvailWriteSpace

(

unsigned

BufferIndex

)

Definition at line 2020 of file SEGGER_RTT.c.

                                                              {
  SEGGER_RTT_BUFFER_UP* pRing;
 
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  return _GetAvailWriteSpace(pRing);
}

SEGGER_RTT_GetBytesInBuffer()

unsigned SEGGER_RTT_GetBytesInBuffer

(

unsigned

BufferIndex

)

Definition at line 2041 of file SEGGER_RTT.c.

                                                           {
  unsigned RdOff;
  unsigned WrOff;
  unsigned r;
  volatile SEGGER_RTT_CB* pRTTCB;
  //
  // Avoid warnings regarding volatile access order.  It's not a problem
  // in this case, but dampen compiler enthusiasm.
  //
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  RdOff = pRTTCB->aUp[BufferIndex].RdOff;
  WrOff = pRTTCB->aUp[BufferIndex].WrOff;
  if (RdOff <= WrOff) {
    r = WrOff - RdOff;
  } else {
    r = pRTTCB->aUp[BufferIndex].SizeOfBuffer - (WrOff - RdOff);
  }
  return r;
}

SEGGER_RTT_GetKey()

int SEGGER_RTT_GetKey

(

void

)

Definition at line 1417 of file SEGGER_RTT.c.

                            {
  char c;
  int r;
 
  r = (int)SEGGER_RTT_Read(0u, &c, 1u);
  if (r == 1) {
    r = (int)(unsigned char)c;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_HasData()

unsigned SEGGER_RTT_HasData

(

unsigned

BufferIndex

)

Definition at line 1496 of file SEGGER_RTT.c.

                                                  {
  SEGGER_RTT_BUFFER_DOWN* pRing;
  unsigned                v;
 
  pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  v = pRing->WrOff;
  return v - pRing->RdOff;
}

SEGGER_RTT_HasDataUp()

unsigned SEGGER_RTT_HasDataUp

(

unsigned

BufferIndex

)

Definition at line 1517 of file SEGGER_RTT.c.

                                                    {
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned                v;
 
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  v = pRing->RdOff;
  return pRing->WrOff - v;
}

SEGGER_RTT_HasKey()

int SEGGER_RTT_HasKey

(

void

)

Definition at line 1468 of file SEGGER_RTT.c.

                            {
  SEGGER_RTT_BUFFER_DOWN* pRing;
  unsigned RdOff;
  int r;
 
  INIT();
  pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[0] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  RdOff = pRing->RdOff;
  if (RdOff != pRing->WrOff) {
    r = 1;
  } else {
    r = 0;
  }
  return r;
}

SEGGER_RTT_Init()

void SEGGER_RTT_Init

(

void

)

Definition at line 1862 of file SEGGER_RTT.c.

                            {
  _DoInit();
}

SEGGER_RTT_PutChar()

unsigned SEGGER_RTT_PutChar	(	unsigned	BufferIndex,
		char	c
	)

Definition at line 1354 of file SEGGER_RTT.c.

                                                          {
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned              WrOff;
  unsigned              Status;
  volatile char*        pDst;
  //
  // Prepare
  //
  INIT();
  SEGGER_RTT_LOCK();
  //
  // Get "to-host" ring buffer.
  //
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  //
  // Get write position and handle wrap-around if necessary
  //
  WrOff = pRing->WrOff + 1;
  if (WrOff == pRing->SizeOfBuffer) {
    WrOff = 0;
  }
  //
  // Wait for free space if mode is set to blocking
  //
  if (pRing->Flags == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) {
    while (WrOff == pRing->RdOff) {
      ;
    }
  }
  //
  // Output byte if free space is available
  //
  if (WrOff != pRing->RdOff) {
    pDst  = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
    *pDst = c;
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = WrOff;
    Status = 1;
  } else {
    Status = 0;
  }
  //
  // Finish up.
  //
  SEGGER_RTT_UNLOCK();
  return Status;
}

SEGGER_RTT_PutCharSkip()

unsigned SEGGER_RTT_PutCharSkip	(	unsigned	BufferIndex,
		char	c
	)

Definition at line 1295 of file SEGGER_RTT.c.

                                                              {
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned              WrOff;
  unsigned              Status;
  volatile char*        pDst;
  //
  // Prepare
  //
  INIT();
  SEGGER_RTT_LOCK();
  //
  // Get "to-host" ring buffer.
  //
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  //
  // Get write position and handle wrap-around if necessary
  //
  WrOff = pRing->WrOff + 1;
  if (WrOff == pRing->SizeOfBuffer) {
    WrOff = 0;
  }
  //
  // Output byte if free space is available
  //
  if (WrOff != pRing->RdOff) {
    pDst  = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
    *pDst = c;
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = WrOff;
    Status = 1;
  } else {
    Status = 0;
  }
  //
  // Finish up.
  //
  SEGGER_RTT_UNLOCK();
  //
  return Status;
}

SEGGER_RTT_PutCharSkipNoLock()

unsigned SEGGER_RTT_PutCharSkipNoLock	(	unsigned	BufferIndex,
		char	c
	)

Definition at line 1245 of file SEGGER_RTT.c.

                                                                    {
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned              WrOff;
  unsigned              Status;
  volatile char*        pDst;
  //
  // Get "to-host" ring buffer.
  //
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  //
  // Get write position and handle wrap-around if necessary
  //
  WrOff = pRing->WrOff + 1;
  if (WrOff == pRing->SizeOfBuffer) {
    WrOff = 0;
  }
  //
  // Output byte if free space is available
  //
  if (WrOff != pRing->RdOff) {
    pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
    *pDst = c;
    RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
    pRing->WrOff = WrOff;
    Status = 1;
  } else {
    Status = 0;
  }
  //
  return Status;
}

SEGGER_RTT_Read()

unsigned SEGGER_RTT_Read	(	unsigned	BufferIndex,
		void *	pBuffer,
		unsigned	BufferSize
	)

Definition at line 775 of file SEGGER_RTT.c.

                                                                                   {
  unsigned NumBytesRead;
 
  SEGGER_RTT_LOCK();
  //
  // Call the non-locking read function
  //
  NumBytesRead = SEGGER_RTT_ReadNoLock(BufferIndex, pBuffer, BufferSize);
  //
  // Finish up.
  //
  SEGGER_RTT_UNLOCK();
  //
  return NumBytesRead;
}

SEGGER_RTT_ReadNoLock()

unsigned SEGGER_RTT_ReadNoLock	(	unsigned	BufferIndex,
		void *	pData,
		unsigned	BufferSize
	)

Definition at line 646 of file SEGGER_RTT.c.

                                                                                       {
  unsigned                NumBytesRem;
  unsigned                NumBytesRead;
  unsigned                RdOff;
  unsigned                WrOff;
  unsigned char*          pBuffer;
  SEGGER_RTT_BUFFER_DOWN* pRing;
  volatile char*          pSrc;
  //
  INIT();
  pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  pBuffer = (unsigned char*)pData;
  RdOff = pRing->RdOff;
  WrOff = pRing->WrOff;
  NumBytesRead = 0u;
  //
  // Read from current read position to wrap-around of buffer, first
  //
  if (RdOff > WrOff) {
    NumBytesRem = pRing->SizeOfBuffer - RdOff;
    NumBytesRem = MIN(NumBytesRem, BufferSize);
    pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    NumBytesRead += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
    while (NumBytesRem--) {
      *pBuffer++ = *pSrc++;
    };
#else
    SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem);
    NumBytesRead += NumBytesRem;
    pBuffer      += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
#endif
    //
    // Handle wrap-around of buffer
    //
    if (RdOff == pRing->SizeOfBuffer) {
      RdOff = 0u;
    }
  }
  //
  // Read remaining items of buffer
  //
  NumBytesRem = WrOff - RdOff;
  NumBytesRem = MIN(NumBytesRem, BufferSize);
  if (NumBytesRem > 0u) {
    pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    NumBytesRead += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
    while (NumBytesRem--) {
      *pBuffer++ = *pSrc++;
    };
#else
    SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem);
    NumBytesRead += NumBytesRem;
    pBuffer      += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
#endif
  }
  if (NumBytesRead) {
    pRing->RdOff = RdOff;
  }
  //
  return NumBytesRead;
}

SEGGER_RTT_ReadUpBuffer()

unsigned SEGGER_RTT_ReadUpBuffer	(	unsigned	BufferIndex,
		void *	pBuffer,
		unsigned	BufferSize
	)

Definition at line 743 of file SEGGER_RTT.c.

                                                                                           {
  unsigned NumBytesRead;
 
  SEGGER_RTT_LOCK();
  //
  // Call the non-locking read function
  //
  NumBytesRead = SEGGER_RTT_ReadUpBufferNoLock(BufferIndex, pBuffer, BufferSize);
  //
  // Finish up.
  //
  SEGGER_RTT_UNLOCK();
  //
  return NumBytesRead;
}

SEGGER_RTT_ReadUpBufferNoLock()

unsigned SEGGER_RTT_ReadUpBufferNoLock	(	unsigned	BufferIndex,
		void *	pData,
		unsigned	BufferSize
	)

Definition at line 554 of file SEGGER_RTT.c.

                                                                                               {
  unsigned                NumBytesRem;
  unsigned                NumBytesRead;
  unsigned                RdOff;
  unsigned                WrOff;
  unsigned char*          pBuffer;
  SEGGER_RTT_BUFFER_UP*   pRing;
  volatile char*          pSrc;
 
  INIT();
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  pBuffer = (unsigned char*)pData;
  RdOff = pRing->RdOff;
  WrOff = pRing->WrOff;
  NumBytesRead = 0u;
  //
  // Read from current read position to wrap-around of buffer, first
  //
  if (RdOff > WrOff) {
    NumBytesRem = pRing->SizeOfBuffer - RdOff;
    NumBytesRem = MIN(NumBytesRem, BufferSize);
    pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    NumBytesRead += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
    while (NumBytesRem--) {
      *pBuffer++ = *pSrc++;
    };
#else
    SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem);
    NumBytesRead += NumBytesRem;
    pBuffer      += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
#endif
    //
    // Handle wrap-around of buffer
    //
    if (RdOff == pRing->SizeOfBuffer) {
      RdOff = 0u;
    }
  }
  //
  // Read remaining items of buffer
  //
  NumBytesRem = WrOff - RdOff;
  NumBytesRem = MIN(NumBytesRem, BufferSize);
  if (NumBytesRem > 0u) {
    pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
    NumBytesRead += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
    while (NumBytesRem--) {
      *pBuffer++ = *pSrc++;
    };
#else
    SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem);
    NumBytesRead += NumBytesRem;
    pBuffer      += NumBytesRem;
    BufferSize   -= NumBytesRem;
    RdOff        += NumBytesRem;
#endif
  }
  //
  // Update read offset of buffer
  //
  if (NumBytesRead) {
    pRing->RdOff = RdOff;
  }
  //
  return NumBytesRead;
}

SEGGER_RTT_SetFlagsDownBuffer()

int SEGGER_RTT_SetFlagsDownBuffer	(	unsigned	BufferIndex,
		unsigned	Flags
	)

Definition at line 1836 of file SEGGER_RTT.c.

                                                                        {
  int r;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  if (BufferIndex < (unsigned)pRTTCB->MaxNumDownBuffers) {
    SEGGER_RTT_LOCK();
    pRTTCB->aDown[BufferIndex].Flags = Flags;
    SEGGER_RTT_UNLOCK();
    r =  0;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_SetFlagsUpBuffer()

int SEGGER_RTT_SetFlagsUpBuffer	(	unsigned	BufferIndex,
		unsigned	Flags
	)

Definition at line 1803 of file SEGGER_RTT.c.

                                                                      {
  int r;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  if (BufferIndex < (unsigned)pRTTCB->MaxNumUpBuffers) {
    SEGGER_RTT_LOCK();
    pRTTCB->aUp[BufferIndex].Flags = Flags;
    SEGGER_RTT_UNLOCK();
    r =  0;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_SetNameDownBuffer()

int SEGGER_RTT_SetNameDownBuffer	(	unsigned	BufferIndex,
		const char *	sName
	)

Definition at line 1770 of file SEGGER_RTT.c.

                                                                          {
  int r;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  if (BufferIndex < (unsigned)pRTTCB->MaxNumDownBuffers) {
    SEGGER_RTT_LOCK();
    pRTTCB->aDown[BufferIndex].sName = sName;
    SEGGER_RTT_UNLOCK();
    r =  0;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_SetNameUpBuffer()

int SEGGER_RTT_SetNameUpBuffer	(	unsigned	BufferIndex,
		const char *	sName
	)

Definition at line 1737 of file SEGGER_RTT.c.

                                                                        {
  int r;
  volatile SEGGER_RTT_CB* pRTTCB;
 
  INIT();
  pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  if (BufferIndex < (unsigned)pRTTCB->MaxNumUpBuffers) {
    SEGGER_RTT_LOCK();
    pRTTCB->aUp[BufferIndex].sName = sName;
    SEGGER_RTT_UNLOCK();
    r =  0;
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_SetTerminal()

int SEGGER_RTT_SetTerminal

(

unsigned char

TerminalId

)

Definition at line 1883 of file SEGGER_RTT.c.

                                                      {
  unsigned char         ac[2];
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned Avail;
  int r;
 
  INIT();
  r = 0;
  ac[0] = 0xFFu;
  if (TerminalId < sizeof(_aTerminalId)) { // We only support a certain number of channels
    ac[1] = _aTerminalId[TerminalId];
    pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[0] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
    SEGGER_RTT_LOCK();                     // Lock to make sure that no other task is writing into buffer, while we are and number of free bytes in buffer does not change downwards after checking and before writing
    if ((pRing->Flags & SEGGER_RTT_MODE_MASK) == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) {
      _ActiveTerminal = TerminalId;
      _WriteBlocking(pRing, (const char*)ac, 2u);
    } else {                                                                            // Skipping mode or trim mode? => We cannot trim this command so handling is the same for both modes
      Avail = _GetAvailWriteSpace(pRing);
      if (Avail >= 2) {
        _ActiveTerminal = TerminalId;    // Only change active terminal in case of success
        _WriteNoCheck(pRing, (const char*)ac, 2u);
      } else {
        r = -1;
      }
    }
    SEGGER_RTT_UNLOCK();
  } else {
    r = -1;
  }
  return r;
}

SEGGER_RTT_TerminalOut()

int SEGGER_RTT_TerminalOut	(	unsigned char	TerminalId,
		const char *	s
	)

Definition at line 1932 of file SEGGER_RTT.c.

                                                                     {
  int                   Status;
  unsigned              FragLen;
  unsigned              Avail;
  SEGGER_RTT_BUFFER_UP* pRing;
  //
  INIT();
  //
  // Validate terminal ID.
  //
  if (TerminalId < (char)sizeof(_aTerminalId)) { // We only support a certain number of channels
    //
    // Get "to-host" ring buffer.
    //
    pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[0] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
    //
    // Need to be able to change terminal, write data, change back.
    // Compute the fixed and variable sizes.
    //
    FragLen = STRLEN(s);
    //
    // How we output depends upon the mode...
    //
    SEGGER_RTT_LOCK();
    Avail = _GetAvailWriteSpace(pRing);
    switch (pRing->Flags & SEGGER_RTT_MODE_MASK) {
    case SEGGER_RTT_MODE_NO_BLOCK_SKIP:
      //
      // If we are in skip mode and there is no space for the whole
      // of this output, don't bother switching terminals at all.
      //
      if (Avail < (FragLen + 4u)) {
        Status = 0;
      } else {
        _PostTerminalSwitch(pRing, TerminalId);
        Status = (int)_WriteBlocking(pRing, s, FragLen);
        _PostTerminalSwitch(pRing, _ActiveTerminal);
      }
      break;
    case SEGGER_RTT_MODE_NO_BLOCK_TRIM:
      //
      // If we are in trim mode and there is not enough space for everything,
      // trim the output but always include the terminal switch.  If no room
      // for terminal switch, skip that totally.
      //
      if (Avail < 4u) {
        Status = -1;
      } else {
        _PostTerminalSwitch(pRing, TerminalId);
        Status = (int)_WriteBlocking(pRing, s, (FragLen < (Avail - 4u)) ? FragLen : (Avail - 4u));
        _PostTerminalSwitch(pRing, _ActiveTerminal);
      }
      break;
    case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL:
      //
      // If we are in blocking mode, output everything.
      //
      _PostTerminalSwitch(pRing, TerminalId);
      Status = (int)_WriteBlocking(pRing, s, FragLen);
      _PostTerminalSwitch(pRing, _ActiveTerminal);
      break;
    default:
      Status = -1;
      break;
    }
    //
    // Finish up.
    //
    SEGGER_RTT_UNLOCK();
  } else {
    Status = -1;
  }
  return Status;
}

SEGGER_RTT_WaitKey()

int SEGGER_RTT_WaitKey

(

void

)

Definition at line 1445 of file SEGGER_RTT.c.

                             {
  int r;
 
  do {
    r = SEGGER_RTT_GetKey();
  } while (r < 0);
  return r;
}

SEGGER_RTT_Write()

unsigned SEGGER_RTT_Write	(	unsigned	BufferIndex,
		const void *	pBuffer,
		unsigned	NumBytes
	)

Definition at line 1185 of file SEGGER_RTT.c.

                                                                                        {
  unsigned Status;
 
  INIT();
  SEGGER_RTT_LOCK();
  Status = SEGGER_RTT_WriteNoLock(BufferIndex, pBuffer, NumBytes);  // Call the non-locking write function
  SEGGER_RTT_UNLOCK();
  return Status;
}

SEGGER_RTT_WriteDownBuffer()

unsigned SEGGER_RTT_WriteDownBuffer	(	unsigned	BufferIndex,
		const void *	pBuffer,
		unsigned	NumBytes
	)

Definition at line 1156 of file SEGGER_RTT.c.

                                                                                                  {
  unsigned Status;
 
  INIT();
  SEGGER_RTT_LOCK();
  Status = SEGGER_RTT_WriteDownBufferNoLock(BufferIndex, pBuffer, NumBytes);  // Call the non-locking write function
  SEGGER_RTT_UNLOCK();
  return Status;
}

SEGGER_RTT_WriteDownBufferNoLock()

unsigned SEGGER_RTT_WriteDownBufferNoLock	(	unsigned	BufferIndex,
		const void *	pBuffer,
		unsigned	NumBytes
	)

Definition at line 1005 of file SEGGER_RTT.c.

                                                                                                        {
  unsigned                Status;
  unsigned                Avail;
  const char*             pData;
  SEGGER_RTT_BUFFER_UP*   pRing;
  //
  // Get "to-target" ring buffer.
  // It is save to cast that to a "to-host" buffer. Up and Down buffer differ in volatility of offsets that might be modified by J-Link.
  //
  pData = (const char *)pBuffer;
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  //
  // How we output depends upon the mode...
  //
  switch (pRing->Flags) {
  case SEGGER_RTT_MODE_NO_BLOCK_SKIP:
    //
    // If we are in skip mode and there is no space for the whole
    // of this output, don't bother.
    //
    Avail = _GetAvailWriteSpace(pRing);
    if (Avail < NumBytes) {
      Status = 0u;
    } else {
      Status = NumBytes;
      _WriteNoCheck(pRing, pData, NumBytes);
    }
    break;
  case SEGGER_RTT_MODE_NO_BLOCK_TRIM:
    //
    // If we are in trim mode, trim to what we can output without blocking.
    //
    Avail = _GetAvailWriteSpace(pRing);
    Status = Avail < NumBytes ? Avail : NumBytes;
    _WriteNoCheck(pRing, pData, Status);
    break;
  case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL:
    //
    // If we are in blocking mode, output everything.
    //
    Status = _WriteBlocking(pRing, pData, NumBytes);
    break;
  default:
    Status = 0u;
    break;
  }
  //
  // Finish up.
  //
  return Status;
}

SEGGER_RTT_WriteNoLock()

unsigned SEGGER_RTT_WriteNoLock	(	unsigned	BufferIndex,
		const void *	pBuffer,
		unsigned	NumBytes
	)

Definition at line 1080 of file SEGGER_RTT.c.

                                                                                              {
  unsigned              Status;
  unsigned              Avail;
  const char*           pData;
  SEGGER_RTT_BUFFER_UP* pRing;
  //
  // Get "to-host" ring buffer.
  //
  pData = (const char *)pBuffer;
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  //
  // How we output depends upon the mode...
  //
  switch (pRing->Flags) {
  case SEGGER_RTT_MODE_NO_BLOCK_SKIP:
    //
    // If we are in skip mode and there is no space for the whole
    // of this output, don't bother.
    //
    Avail = _GetAvailWriteSpace(pRing);
    if (Avail < NumBytes) {
      Status = 0u;
    } else {
      Status = NumBytes;
      _WriteNoCheck(pRing, pData, NumBytes);
    }
    break;
  case SEGGER_RTT_MODE_NO_BLOCK_TRIM:
    //
    // If we are in trim mode, trim to what we can output without blocking.
    //
    Avail = _GetAvailWriteSpace(pRing);
    Status = Avail < NumBytes ? Avail : NumBytes;
    _WriteNoCheck(pRing, pData, Status);
    break;
  case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL:
    //
    // If we are in blocking mode, output everything.
    //
    Status = _WriteBlocking(pRing, pData, NumBytes);
    break;
  default:
    Status = 0u;
    break;
  }
  //
  // Finish up.
  //
  return Status;
}

SEGGER_RTT_WriteSkipNoLock()

unsigned SEGGER_RTT_WriteSkipNoLock	(	unsigned	BufferIndex,
		const void *	pBuffer,
		unsigned	NumBytes
	)

Definition at line 915 of file SEGGER_RTT.c.

                                                                                                  {
  const char*           pData;
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned              Avail;
  unsigned              RdOff;
  unsigned              WrOff;
  unsigned              Rem;
  volatile char*        pDst;
  //
  // Cases:
  //   1) RdOff <= WrOff => Space until wrap-around is sufficient
  //   2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks)
  //   3) RdOff <  WrOff => No space in buf
  //   4) RdOff >  WrOff => Space is sufficient
  //   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
  //
  pData = (const char *)pBuffer;
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  RdOff = pRing->RdOff;
  WrOff = pRing->WrOff;
  if (RdOff <= WrOff) {                                 // Case 1), 2) or 3)
    Avail = pRing->SizeOfBuffer - WrOff - 1u;           // Space until wrap-around (assume 1 byte not usable for case that RdOff == 0)
    if (Avail >= NumBytes) {                            // Case 1)?
CopyStraight:
      pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
      memcpy((void*)pDst, pData, NumBytes);
      RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
      pRing->WrOff = WrOff + NumBytes;
      return 1;
    }
    Avail += RdOff;                                     // Space incl. wrap-around
    if (Avail >= NumBytes) {                            // Case 2? => If not, we have case 3) (does not fit)
      Rem = pRing->SizeOfBuffer - WrOff;                // Space until end of buffer
      pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
      memcpy((void*)pDst, pData, Rem);                  // Copy 1st chunk
      NumBytes -= Rem;
      //
      // 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
      // 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
      //
      if (NumBytes) {
        pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF;
        memcpy((void*)pDst, pData + Rem, NumBytes);
      }
      RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
      pRing->WrOff = NumBytes;
      return 1;
    }
  } else {                                             // Potential case 4)
    Avail = RdOff - WrOff - 1u;
    if (Avail >= NumBytes) {                           // Case 4)? => If not, we have case 5) (does not fit)
      goto CopyStraight;
    }
  }
  return 0;     // No space in buffer
}

SEGGER_RTT_WriteString()

unsigned SEGGER_RTT_WriteString	(	unsigned	BufferIndex,
		const char *	s
	)

Definition at line 1215 of file SEGGER_RTT.c.

                                                                     {
  unsigned Len;
 
  Len = STRLEN(s);
  return SEGGER_RTT_Write(BufferIndex, s, Len);
}

SEGGER_RTT_WriteWithOverwriteNoLock()

void SEGGER_RTT_WriteWithOverwriteNoLock	(	unsigned	BufferIndex,
		const void *	pBuffer,
		unsigned	NumBytes
	)

Definition at line 814 of file SEGGER_RTT.c.

                                                                                                       {
  const char*           pData;
  SEGGER_RTT_BUFFER_UP* pRing;
  unsigned              Avail;
  volatile char*        pDst;
  //
  // Get "to-host" ring buffer and copy some elements into local variables.
  //
  pData = (const char *)pBuffer;
  pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
  //
  // Check if we will overwrite data and need to adjust the RdOff.
  //
  if (pRing->WrOff == pRing->RdOff) {
    Avail = pRing->SizeOfBuffer - 1u;
  } else if ( pRing->WrOff < pRing->RdOff) {
    Avail = pRing->RdOff - pRing->WrOff - 1u;
  } else {
    Avail = pRing->RdOff - pRing->WrOff - 1u + pRing->SizeOfBuffer;
  }
  if (NumBytes > Avail) {
    pRing->RdOff += (NumBytes - Avail);
    while (pRing->RdOff >= pRing->SizeOfBuffer) {
      pRing->RdOff -= pRing->SizeOfBuffer;
    }
  }
  //
  // Write all data, no need to check the RdOff, but possibly handle multiple wrap-arounds
  //
  Avail = pRing->SizeOfBuffer - pRing->WrOff;
  do {
    if (Avail > NumBytes) {
      //
      // Last round
      //
      pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
      Avail = NumBytes;
      while (NumBytes--) {
        *pDst++ = *pData++;
      };
      RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
      pRing->WrOff += Avail;
#else
      SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytes);
      RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
      pRing->WrOff += NumBytes;
#endif
      break;
    } else {
      //
      //  Wrap-around necessary, write until wrap-around and reset WrOff
      //
      pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
      NumBytes -= Avail;
      while (Avail--) {
        *pDst++ = *pData++;
      };
      RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
      pRing->WrOff = 0;
#else
      SEGGER_RTT_MEMCPY((void*)pDst, pData, Avail);
      pData += Avail;
      RTT__DMB();                     // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses
      pRing->WrOff = 0;
      NumBytes -= Avail;
#endif
      Avail = (pRing->SizeOfBuffer - 1);
    }
  } while (NumBytes);
}

Variable Documentation

_acDownBuffer

char _acDownBuffer[((16))]

static

Definition at line 267 of file SEGGER_RTT.c.

_ActiveTerminal

unsigned char _ActiveTerminal

static

Definition at line 269 of file SEGGER_RTT.c.

_acUpBuffer

char _acUpBuffer[((1024))]

static

Definition at line 266 of file SEGGER_RTT.c.

_aTerminalId

unsigned char _aTerminalId[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }

static

Definition at line 253 of file SEGGER_RTT.c.

_SEGGER_RTT

SEGGER_RTT_CB _SEGGER_RTT

Definition at line 265 of file SEGGER_RTT.c.