kelvin
/
spider-bot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
spider-bot/fw/nrf52/nrf5_sdk/external/infineon/optiga/common/Logger.c

770 lines
20 KiB
C
Raw Blame History

/**
* MIT License
*
* Copyright (c) 2018 Infineon Technologies AG
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE
*
* \file
*
* \brief This file contains a light weight logger implementation.
*
*
* \addtogroup grLogger
* @{
*
*/
#include <stdio.h>
#include "optiga/common/Logger.h"
#include "optiga/pal/pal_os_timer.h"
/// @cond hidden
/*****************************************************************************
* Defines
*****************************************************************************/
//If ENABLE_UARTLOG is defined, assign UartWriteData as log writer
#ifdef ENABLE_UARTLOG
#include "Uart.h"
pFWriteData pfWriter = (pFWriteData)UartWriteData;
#else
//The function does nothing
static int32_t WriteData(uint32_t PdwHandle, const uint8_t* PprgbBuf, uint32_t PdwDataLen)
{
//lint --e{715} suppress "The parameters are not used as this is filler function"
return 1;
}
pFWriteData pfWriter = (pFWriteData)WriteData;
#endif
/*****************************************************************************
* Common Functions
*****************************************************************************/
/**
* Convert Byte to Hex String
*
*/
void ConvUint8ToHexString (uint8_t* PprgbHexByteArray, uint8_t* PprgbHexString, \
uint32_t dwNoOfBytes, uint8_t PbIsSpaceReq)
{
//lint --e{818} suppress "PprgbHexString is modified in function"
uint32_t dwLoop = 0;
uint8_t bNibble = 0, bHexByte = 0;
do
{
if((NULL == PprgbHexByteArray) || (NULL == PprgbHexString))
{
return;
}
for (dwLoop = 0; dwLoop < dwNoOfBytes; dwLoop++)
{
bHexByte = PprgbHexByteArray[dwLoop];
/*Convert Byte to HexString */
bNibble = (bHexByte & 0xF0)>>4;
if (bNibble > 0x09)
PprgbHexString [0] = bNibble + 0x37;
else
PprgbHexString [0] = bNibble + 0x30;
bNibble = bHexByte & 0x0F;
if (bNibble > 0x09)
PprgbHexString [1] = bNibble + 0x37;
else
PprgbHexString [1] = bNibble + 0x30;
if(PbIsSpaceReq)
{
PprgbHexString [2] = ' ';
PprgbHexString += 3;
}
else
{
PprgbHexString += 2;
}
}
*PprgbHexString = 0x00;
} while(0);
}
/**
* Convert Uint32 to Hex String
*
*/
void ConvUint32ToHexString (uint32_t dwVal, uint8_t* PprgbHexString)
{
uint8_t rgbByteArray [5];
do
{
if(NULL == PprgbHexString)
{
return;
}
rgbByteArray [0] = (uint8_t)(dwVal >> 24);
rgbByteArray [1] = (uint8_t)((dwVal & 0x00FF0000) >> 16);
rgbByteArray [2] = (uint8_t)((dwVal & 0x0000FF00) >> 8);
rgbByteArray [3] = (uint8_t)((dwVal & 0x000000FF));
ConvUint8ToHexString(rgbByteArray, PprgbHexString, 4, 0);
} while(0);
}
/**
* Convert Uint32 to Decimal String
*
*/
void ConvUint32ToDecString (uint32_t dwVal, uint8_t* PprgbDecStr, \
uint8_t bExpStrLen, uint8_t bFillChar)
{
uint8_t rgbTempStr [12] = {0};
uint8_t bCount;
do
{
if(NULL ==PprgbDecStr)
{
return;
}
bCount = 0;
for (;;)
{
rgbTempStr [bCount] = (dwVal % 10) + 0x30;
dwVal = dwVal / 10;
bCount++;
if(0x00 == dwVal)
{
break;
}
}
while(bExpStrLen > bCount)
{
*PprgbDecStr = bFillChar;
PprgbDecStr++;
bExpStrLen--;
}
bCount--;
for(;;)
{
*PprgbDecStr = rgbTempStr[bCount];
PprgbDecStr++;
if(0x00 == bCount)
{
break;
}
bCount--;
}
*PprgbDecStr = 0x00;
} while(0);
}
/*****************************************************************************
* Static functions
*****************************************************************************/
#ifdef ENABLE_LOG
/**
* Return current system time in milliseconds as a string
*
*/
static void GetSystemDateTime(char_t *pszSystemTime)
{
uint32_t dwTimeInMilliSecs = 0;
if(pszSystemTime == NULL)
{
return;
}
dwTimeInMilliSecs = pal_os_timer_get_time_in_milliseconds();
ConvUint32ToDecString (dwTimeInMilliSecs, (uint8_t *)pszSystemTime, 10, '0');
}
/**
* Perform packet analysis. This is specific to IFX I2C protocol
*
*/
static void DumpPacketAnalysis(uint8_t* prgbBuf, uint16_t wLen, bool_t fDirection)
{
uint16_t wOffset = 0, wFrameLength, wTemp;
uint8_t bFctr, bPctr, bTemp, bAckNumber;
char_t pszTemp[256];
bool_t bControlFrame = TRUE;
//for packet analysis there must be minimum 5 bytes
if(wLen < 5)
{
return;
}
if(prgbBuf == NULL)
{
return;
}
//0 for send
if(fDirection == TX_DIRECTION)
{
wOffset = 1;
CONSOLE_LOGSTRINGLINE("->->->->-> Packet Analysis ->->->->->");
}
else
{
CONSOLE_LOGSTRINGLINE("<-<-<-<-<- Packet Analysis <-<-<-<-<-");
}
do
{
//frame type
bFctr = *(prgbBuf+wOffset);
bAckNumber = bFctr & 0x03;
if(bFctr & 0x80)
{
CONSOLE_LOGSTRINGLINE("Frame type: Control frame");
}
else
{
bControlFrame = FALSE;
CONSOLE_LOGSTRINGLINE("Frame type: Data frame");
}
//seq counter 0110 0000 = 0x60
bTemp = ((bFctr & 0x60) >> 5);
switch(bTemp)
{
case 0x00:
CONSOLE_LOGSTRING("Seq Counter: Ack for ");
ConvUint32ToDecString((uint32_t)bAckNumber,(uint8_t*)pszTemp, 0, '0');
CONSOLE_LOGSTRINGLINE(pszTemp);
break;
case 0x01:
CONSOLE_LOGSTRING("Seq Counter: Nak for ");
ConvUint32ToDecString((uint32_t)bAckNumber,(uint8_t*)pszTemp, 0, '0');
CONSOLE_LOGSTRINGLINE(pszTemp);
break;
case 0x02:
CONSOLE_LOGSTRINGLINE("Seq Counter: Re-synch");
break;
default:
CONSOLE_LOGSTRINGLINE("************************** Seq Counter: RFU ***********************");
}
//frame number 0000 1100 = 0x60
bTemp = ((bFctr & 0x0C) >> 2);
CONSOLE_LOGSTRING("Frame number: ");
ConvUint32ToDecString((uint32_t)bTemp,(uint8_t*)pszTemp, 0, '0');
CONSOLE_LOGSTRINGLINE(pszTemp);
//ack number
CONSOLE_LOGSTRING("Ack number: ");
ConvUint32ToDecString((uint32_t)bAckNumber,(uint8_t*)pszTemp, 0, '0');
CONSOLE_LOGSTRINGLINE(pszTemp);
//Frame length:
wOffset++;
wFrameLength = ((uint16_t)*(prgbBuf + wOffset) << 8) | (uint16_t)*(prgbBuf + wOffset + 1);
CONSOLE_LOGSTRING("Frame length: ");
ConvUint32ToDecString((uint32_t)wFrameLength,(uint8_t*)pszTemp, 0, '0');
CONSOLE_LOGSTRINGLINE(pszTemp);
wOffset += 2;
//N/w and transport info not present for control frame
if(bControlFrame)
{
break;
}
//channel info
bPctr = *(prgbBuf+wOffset);
bTemp = bPctr >> 4;
CONSOLE_LOGSTRING("Channel info: ");
ConvUint32ToDecString((uint32_t)bTemp,(uint8_t*)pszTemp, 0, '0');
CONSOLE_LOGSTRINGLINE(pszTemp);
bTemp = bPctr & 0x07;
switch(bTemp)
{
case 0x00:
CONSOLE_LOGSTRINGLINE("Chaining info: Single packet");
break;
case 0x01:
CONSOLE_LOGSTRINGLINE("Chaining info: First packet");
break;
case 0x02:
CONSOLE_LOGSTRINGLINE("Chaining info: Intermediate packet");
break;
case 0x04:
CONSOLE_LOGSTRINGLINE("Chaining info: Last packet");
break;
case 0x07:
CONSOLE_LOGSTRINGLINE("********************* Chaining info: Chaining error ********************* ");
break;
default:
CONSOLE_LOGSTRINGLINE("********************* Chaining info: RFU***********************");
}
wOffset += 1;
//exclude till offset and checksum
wTemp = wOffset+2;
if(wLen > wTemp)
{
wTemp = wLen - wTemp;
}
else
{
// no data bytes
break;
}
if(fDirection == TX_DIRECTION)
{
CONSOLE_LOGSTRING("Command data : ");
}
else
{
CONSOLE_LOGSTRING("Response data : ");
}
Util_DumpHex((prgbBuf+wOffset), wTemp);
CONSOLE_LOGSTRINGLINE(" ");
}while(0);
//0 for send
if(fDirection == TX_DIRECTION)
{
CONSOLE_LOGSTRINGLINE("->->->->-> Packet Analysis ->->->->->");
}
else
{
CONSOLE_LOGSTRINGLINE("<-<-<-<-<- Packet Analysis <-<-<-<-<-");
}
}
#endif
/*****************************************************************************
* Exposed Logging APIs
*****************************************************************************/
/**
* Logs a New Line
*/
void Util_NewLine(uint32_t PdwUartPort)
{
uint8_t rgbcrlf [2] = {0x0D, 0x0A};
//lint --e{534} The return value is not used*/
pfWriter(PdwUartPort, rgbcrlf, 2);
}
/**
* Logs a string with new line
*/
void Util_LogStringLine(uint32_t PdwUartPort, const char_t *pszString)
{
if(pszString == NULL)
{
return;
}
//lint --e{534} The return value is not used*/
pfWriter(PdwUartPort, (uint8_t *)pszString, strlen(pszString));
Util_NewLine(PdwUartPort);
}
/**
* Logs a string
*/
void Util_LogString(uint32_t PdwUartPort, const char_t *PpszString)
{
if(PpszString == NULL)
{
return;
}
//lint --e{534} The return value is not used*/
pfWriter(PdwUartPort, (uint8_t *)PpszString, strlen(PpszString));
}
#ifdef ENABLE_LOG
/**
* Logs a byte array
*/
void Util_LogArray(uint8_t* prgbBuf, uint16_t wLen, bool_t fDirection, bool_t fDumpPacketAnalysis)
{
char_t szTemp[50];
if(prgbBuf == NULL)
{
return;
}
memset(szTemp,0, 50);
GetSystemDateTime(szTemp);
//lint --e{534} The return value is not used*/
pfWriter(CONSOLE_PORT, (uint8_t*)szTemp, strlen(szTemp));
//lint --e{534} The return value is not used*/
pfWriter(CONSOLE_PORT, (uint8_t*)" ", 1);
if(fDirection == TX_DIRECTION)
{
//lint --e{534} The return value is not used*/
pfWriter(CONSOLE_PORT, (uint8_t*)">> ", 4);
}
else
{
//lint --e{534} The return value is not used*/
pfWriter(CONSOLE_PORT, (uint8_t*)"<< ", 4);
}
Util_DumpHex(prgbBuf, wLen);
Util_NewLine(CONSOLE_PORT);
if(fDumpPacketAnalysis)
{
DumpPacketAnalysis(prgbBuf, wLen, fDirection);
}
return;
}
#endif
/**
* Logs a four byte value
*/
void Util_LogInt(uint32_t PdwUartPort, const char_t *pszMsg, uint32_t dwValue)
{
uint8_t rgbString [12] = {0};
if(pszMsg == NULL)
{
return;
}
Util_LogString(PdwUartPort, pszMsg);
Util_LogString(PdwUartPort, " 0x");
ConvUint32ToHexString((uint32_t)dwValue, rgbString);
Util_LogString(PdwUartPort, (char_t*)rgbString);
Util_LogString(PdwUartPort, "(");
ConvUint32ToDecString((uint32_t)dwValue, rgbString, 0, '0');
Util_LogString(PdwUartPort, (char_t*)rgbString);
Util_LogStringLine(PdwUartPort, ")");
}
/**
* Logs an array in hex format
*/
void Util_DumpHex(uint8_t* prgbBuf, uint16_t wLen)
{
uint16_t wIndex;
uint8_t rgbHexString[5];
if(prgbBuf == NULL)
{
return;
}
for(wIndex = 0; wIndex < wLen; wIndex++)
{
ConvUint8ToHexString ((uint8_t*)(prgbBuf+wIndex), rgbHexString, 1, 1);
//lint --e{534} The return value is not used*/
pfWriter(CONSOLE_PORT, rgbHexString, 3);
}
}
/*****************************************************************************
* Level based logging Exposed APIs
*****************************************************************************/
/// @endcond
#ifdef ENABLE_LOG
//This is second log writer
pFWriteData2 pfWriter2 = NULL;
//This is the arguement to be passed to pfWriter.It refers to the handle to writer context/structure.
void* pHandle = NULL;
//Stores the level of Logging
static uint32_t dwLevelEnabler = (uint32_t)((1<<eInfo)|(1<<eWarning)|(1<<eError));
//Store the layer type of Logging
static uint32_t dwLayerEnabler = 0;
/**
* \brief This structure contains Logging information
*/
typedef struct sLogMessage {
///Message to be logged
char_t* pzStringMessage;
///Message Type
eLogLayer eLogMsgLayer;
///Message Level
eLogLevel eLogMsgLevel;
}sLogMessage;
/**
* Sets the state of the Logging Level.
*
* \param[in] eLevel Logging Level
* \param[in] eValue Set value
*/
void Util_SetLogLevelState(eLogLevel PeLevel,eSetState PeValue)
{
//Validate Level
if((eInfo <= PeLevel)&&(eError >= PeLevel))
{
switch(PeValue)
{
case eEnable:
{
dwLevelEnabler |= (uint32_t)(1<<PeLevel);
break;
}
case eDisable:
{
dwLevelEnabler &= (uint32_t)(~(1<<PeLevel));
break;
}
case eInvalid:
default:
break;
}
}
}
/**
* Returns the current state of Logging level.
*
* \param[in] eLevel Logging Level
*
* \retval #eSetState
*/
eSetState Util_GetLogLevelState(eLogLevel PeLevel)
{
//Validate Level
if((eInfo <= PeLevel)&&(eError >= PeLevel))
return (((dwLevelEnabler)&(1<<PeLevel))?eEnable:eDisable);
else
return eInvalid;
}
/**
* Sets the state of the Logging Layer.
*
* \param[in] eLayer Logging Layer
* \param[in] eValue Set value
*/
void Util_SetLogLayerState(eLogLayer PeLayer,eSetState PeValue)
{
//Validate Layer
if((eHS <= PeLayer)&&(eTL >= PeLayer))
{
switch(PeValue)
{
case eEnable:
{
dwLayerEnabler |= (uint32_t)(1<<PeLayer);
break;
}
case eDisable:
{
dwLayerEnabler &= (uint32_t)(~(1<<PeLayer));
break;
}
case eInvalid:
default:
break;
}
}
}
/**
* Returns the current state of the Logging Layer.
*
* \param[in] eLayer Logging Level
*
* \retval #eSetState
*/
eSetState Util_GetLogLayerState(eLogLayer PeLayer)
{
//Validate Layer
if((eHS <= PeLayer)&&(eTL >= PeLayer))
return (((dwLayerEnabler)&(1<<PeLayer))?eEnable:eDisable);
else
return eInvalid;
}
/**
* Sets the Log Writer and handle.
*
* \param[in] pWriter function pointer to pFWriteData2
* \param[in] pHdl Handle to writer context/structure
*
*/
void Util_SetLogWriter(pFWriteData2 pWriter,void* pHdl)
{
pfWriter2 = pWriter;
pHandle = pHdl;
}
/**
* \brief Logs a message.
*/
static void Util_WriteMessage(sLogMessage* psLogMessage)
{
char_t charBuffer[103];
char timeString[9]; // space for "HH:MM:SS\0"
char_t* szMsgLevel[eError] = {LOGGER_LEVEL_INFO,
LOGGER_LEVEL_WARNING,
LOGGER_LEVEL_ERROR};
char_t* szMsgType[eTL] = {LOGGER_TYPE_HANDSHAKE,
LOGGER_TYPE_RECORDLAYER,
LOGGER_TYPE_TRANSPORTLAYER};
GetSystemDateTime(timeString);
#ifndef WIN32
sprintf(charBuffer,LOG_FORMAT,timeString,szMsgLevel[psLogMessage->eLogMsgLevel -1 ],
szMsgType[psLogMessage->eLogMsgLayer -1 ],psLogMessage->pzStringMessage,"\n");
#else
sprintf_s(charBuffer,103,LOG_FORMAT,timeString,szMsgLevel[psLogMessage->eLogMsgLevel -1 ],
szMsgType[psLogMessage->eLogMsgLayer -1 ],psLogMessage->pzStringMessage,"\n");
#endif
pfWriter2(pHandle,(uint8_t*)charBuffer,strlen(charBuffer));
}
/**
* Logs a message with type and level information and content of the buffer.
* Currently the message cannot be greater than 80 bytes.This will be upgraded in future
*
* \param[in] pzMsg Message to be logged
* \param[in] eLayer Logging Layer
* \param[in] eLevel Logging Level
* \param[in] PrgbBuffer Pointer to the buffer to be logged
* \param[in] wLen Length message to be logged
*
*/
void Util_LogMsgArray(char* pzMsg, uint8_t* PrgbBuffer, uint16_t wLen, eLogLayer eLayer, eLogLevel eLevel)
{
sLogMessage sLogMes;
uint16_t wCount = wLen;
uint8_t bBytes = 25;
uint8_t * prgbbuf = PrgbBuffer;
eSetState eCurrentState = Util_GetLogLevelState(eLevel);
uint8_t rgbHexString[100];
do
{
if((NULL==pHandle)||(NULL ==pfWriter2) || (eEnable != eCurrentState) || (PrgbBuffer == NULL))
{
break;
}
sLogMes.eLogMsgLevel = eLevel;
sLogMes.eLogMsgLayer = eLayer;
sLogMes.pzStringMessage = pzMsg;
Util_WriteMessage(&sLogMes);
while(wCount > 0)
{
if(wCount < 25)
{
bBytes = (uint8_t)wCount;
}
ConvUint8ToHexString ((uint8_t*)(prgbbuf), rgbHexString, bBytes, 1);
pfWriter2(pHandle, rgbHexString, (bBytes*3));
prgbbuf+= bBytes;
wCount-=bBytes;
}
pfWriter2(pHandle, (uint8_t *)"\n", 1);
}while (0);
}
/**
* Logs a message with type and level information.
* Currently the message cannot be greater than 80 bytes.This will be upgraded in future
*
* \param[in] pzMsg Message to be logged
* \param[in] eLayer Logging Layer
* \param[in] eLevel Logging Level
*
*/
void Util_LogMessage(char* pzMsg, eLogLayer eLayer, eLogLevel eLevel)
{
sLogMessage sLogMes;
eSetState eCurrentState = Util_GetLogLevelState(eLevel);
do
{
if((NULL==pHandle)||(NULL ==pfWriter2) || (eEnable != eCurrentState))
{
break;
}
sLogMes.eLogMsgLevel = eLevel;
sLogMes.eLogMsgLayer = eLayer;
sLogMes.pzStringMessage = pzMsg;
Util_WriteMessage(&sLogMes);
}while (0);
}
/**
* Logs a 4 byte debug value with type and level information.
*
* Currently the message cannot be greater than 80 bytes.This will be upgraded in future
* \param[in] dwDBValue 4 byte value to be logged
* \param[in] eLayer Logging Layer
* \param[in] eLevel Logging Level
*
*/
void Util_LogDebugVal(uint32_t dwDBValue, eLogLayer eLayer, eLogLevel eLevel)
{
uint8_t rgbString [12];
if((NULL!=pHandle)&&(NULL !=pfWriter2))
{
ConvUint32ToHexString(dwDBValue, rgbString);
Util_LogMessage((char_t*)rgbString,eLayer,eLevel);
}
}
#endif //#ENABLE_LOG
/**
* @}
*/
Reference in New Issue View Git Blame Copy Permalink