[Cellular] Fix module logging mechanism format (#40)

andysun2015 · web-flow · commit ed6d1e14ca60 · 2021-10-01T07:31:55.000+08:00
* [Cellular] Fix module logging mechanism format

* [Cellular] Fix missing logging mechanism format.
diff --git a/modules/bg96/cellular_bg96_api.c b/modules/bg96/cellular_bg96_api.c
@@ -1051,8 +1051,8 @@ static CellularATError_t getPdnStatusParseToken( char * pToken,
             break;
 
         default:
-            LogError( "Unknown token in getPdnStatusParseToken %s %d",
-                      pToken, tokenIndex );
+            LogError( ( "Unknown token in getPdnStatusParseToken %s %d",
+                        pToken, tokenIndex ) );
             atCoreStatus = CELLULAR_AT_ERROR;
             break;
     }
@@ -1229,8 +1229,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA
     /* Check if the received data size is greater than the output buffer size. */
     if( *pDataRecv->pDataLen > outBufSize )
     {
-        LogError( "Data is turncated, received data length %d, out buffer size %d",
-                  *pDataRecv->pDataLen, outBufSize );
+        LogError( ( "Data is turncated, received data length %d, out buffer size %d",
+                    *pDataRecv->pDataLen, outBufSize ) );
         dataLenToCopy = outBufSize;
         *pDataRecv->pDataLen = outBufSize;
     }
@@ -1643,11 +1643,13 @@ static CellularPktStatus_t _Cellular_RecvFuncGetPsmSettings( CellularContext_t *
 
             while( pToken != NULL )
             {
-                atCoreStatus = parseGetPsmToken( pToken, tokenIndex, pPsmSettings );
-
-                if( atCoreStatus != CELLULAR_AT_SUCCESS )
+                if( tokenIndex == 0 )
+                {
+                    atCoreStatus = parseGetPsmToken( pToken, tokenIndex, pPsmSettings );
+                }
+                else
                 {
-                    LogInfo( ( "parseGetPsmToken %s index %d failed", pToken, tokenIndex ) );
+                    parseGetPsmToken( pToken, tokenIndex, pPsmSettings );
                 }
 
                 tokenIndex++;
@@ -1670,12 +1672,12 @@ static CellularPktStatus_t _Cellular_RecvFuncGetPsmSettings( CellularContext_t *
             }
         }
 
-        LogDebug( "PSM setting: mode: %d, RAU: %d, RDY_Timer: %d, TAU: %d, Active_time: %d",
-                  pPsmSettings->mode,
-                  pPsmSettings->periodicRauValue,
-                  pPsmSettings->gprsReadyTimer,
-                  pPsmSettings->periodicTauValue,
-                  pPsmSettings->activeTimeValue );
+        LogDebug( ( "PSM setting: mode: %d, RAU: %d, RDY_Timer: %d, TAU: %d, Active_time: %d",
+                    pPsmSettings->mode,
+                    pPsmSettings->periodicRauValue,
+                    pPsmSettings->gprsReadyTimer,
+                    pPsmSettings->periodicTauValue,
+                    pPsmSettings->activeTimeValue ) );
         pktStatus = _Cellular_TranslateAtCoreStatus( atCoreStatus );
     }
 
@@ -1794,14 +1796,14 @@ static CellularError_t storeAccessModeAndAddress( CellularContext_t * pContext,
     }
     else if( socketHandle->socketState != SOCKETSTATE_ALLOCATED )
     {
-        LogError( "storeAccessModeAndAddress, bad socket state %d",
-                  socketHandle->socketState );
+        LogError( ( "storeAccessModeAndAddress, bad socket state %d",
+                    socketHandle->socketState ) );
         cellularStatus = CELLULAR_INTERNAL_FAILURE;
     }
     else if( dataAccessMode != CELLULAR_ACCESSMODE_BUFFER )
     {
-        LogError( "storeAccessModeAndAddress, Access mode not supported %d",
-                  dataAccessMode );
+        LogError( ( "storeAccessModeAndAddress, Access mode not supported %d",
+                    dataAccessMode ) );
         cellularStatus = CELLULAR_UNSUPPORTED;
     }
     else
@@ -2921,8 +2923,8 @@ CellularError_t Cellular_GetSimCardStatus( CellularHandle_t cellularHandle,
         }
 
         cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
-        LogDebug( "_Cellular_GetSimStatus, Sim Insert State[%d], Lock State[%d]",
-                  pSimCardStatus->simCardState, pSimCardStatus->simCardLockState );
+        LogDebug( ( "_Cellular_GetSimStatus, Sim Insert State[%d], Lock State[%d]",
+                    pSimCardStatus->simCardState, pSimCardStatus->simCardLockState ) );
     }
 
     return cellularStatus;
@@ -2999,9 +3001,9 @@ CellularError_t Cellular_GetSimCardInfo( CellularHandle_t cellularHandle,
         }
         else
         {
-            LogDebug( "SimInfo updated: IMSI:%s, Hplmn:%s%s, ICCID:%s",
-                      pSimCardInfo->imsi, pSimCardInfo->plmn.mcc, pSimCardInfo->plmn.mnc,
-                      pSimCardInfo->iccid );
+            LogDebug( ( "SimInfo updated: IMSI:%s, Hplmn:%s%s, ICCID:%s",
+                        pSimCardInfo->imsi, pSimCardInfo->plmn.mcc, pSimCardInfo->plmn.mnc,
+                        pSimCardInfo->iccid ) );
         }
     }
 
diff --git a/modules/bg96/cellular_bg96_urc_handler.c b/modules/bg96/cellular_bg96_urc_handler.c
@@ -96,7 +96,7 @@ static CellularPktStatus_t _parseSocketOpenNextTok( const char * pToken,
         if( sockStatus != 0 )
         {
             pSocketData->socketState = SOCKETSTATE_DISCONNECTED;
-            LogError( ( ( "_parseSocketOpen: Socket open failed, conn %d, status %d", sockIndex, sockStatus ) ) );
+            LogError( ( "_parseSocketOpen: Socket open failed, conn %d, status %d", sockIndex, sockStatus ) );
         }
         else
         {
diff --git a/modules/hl7802/cellular_hl7802_api.c b/modules/hl7802/cellular_hl7802_api.c
@@ -411,8 +411,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA
     /* Check if the received data size is greater than the output buffer size. */
     if( *pDataRecv->pDataLen > outBufSize )
     {
-        LogError( "Data is turncated, received data length %d, out buffer size %d",
-                  *pDataRecv->pDataLen, outBufSize );
+        LogError( ( "Data is turncated, received data length %d, out buffer size %d",
+                    *pDataRecv->pDataLen, outBufSize ) );
         dataLenToCopy = outBufSize;
         *pDataRecv->pDataLen = outBufSize;
     }
@@ -433,8 +433,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA
         }
         else
         {
-            LogError( "Receive Data: paramerter error, data pointer %p, data to copy %d",
-                      pInputLine, dataLenToCopy );
+            LogError( ( "Receive Data: paramerter error, data pointer %p, data to copy %d",
+                        pInputLine, dataLenToCopy ) );
             atCoreStatus = CELLULAR_AT_BAD_PARAMETER;
         }
     }
@@ -531,8 +531,8 @@ static CellularError_t buildSocketConfig( CellularSocketHandle_t socketHandle,
     }
     else if( socketHandle->socketProtocol != CELLULAR_SOCKET_PROTOCOL_TCP )
     {
-        LogError( "buildSocketConfig: socket protocol unsupported %d",
-                  socketHandle->socketProtocol );
+        LogError( ( "buildSocketConfig: socket protocol unsupported %d",
+                    socketHandle->socketProtocol ) );
         cellularStatus = CELLULAR_UNSUPPORTED;
     }
     else
@@ -575,14 +575,14 @@ static CellularError_t storeAccessModeAndAddress( CellularContext_t * pContext,
     }
     else if( socketHandle->socketState != SOCKETSTATE_ALLOCATED )
     {
-        LogError( "storeAccessModeAndAddress, bad socket state %d",
-                  socketHandle->socketState );
+        LogError( ( "storeAccessModeAndAddress, bad socket state %d",
+                    socketHandle->socketState ) );
         cellularStatus = CELLULAR_INTERNAL_FAILURE;
     }
     else if( dataAccessMode != CELLULAR_ACCESSMODE_BUFFER )
     {
-        LogError( "storeAccessModeAndAddress, Access mode not supported %d",
-                  dataAccessMode );
+        LogError( ( "storeAccessModeAndAddress, Access mode not supported %d",
+                    dataAccessMode ) );
         cellularStatus = CELLULAR_UNSUPPORTED;
     }
     else
@@ -898,8 +898,8 @@ static CellularPktStatus_t _Cellular_RecvFuncGetEidrxSettings( CellularContext_t
             }
             else
             {
-                LogDebug( "GetEidrx setting[%d]: RAT: %d, Value: 0x%x",
-                          count, pEidrxSettingsList->eidrxList[ count ].rat, pEidrxSettingsList->eidrxList[ count ].requestedEdrxVaue );
+                LogDebug( ( "GetEidrx setting[%d]: RAT: %d, Value: 0x%x",
+                            count, pEidrxSettingsList->eidrxList[ count ].rat, pEidrxSettingsList->eidrxList[ count ].requestedEdrxVaue ) );
             }
 
             pCommnadItem = pCommnadItem->pNext;
@@ -2021,8 +2021,8 @@ static CellularATError_t getPdnStatusParseToken( char * pToken,
             break;
 
         default:
-            LogError( "Unknown token in getPdnStatusParseToken %s %d",
-                      pToken, tokenIndex );
+            LogError( ( "Unknown token in getPdnStatusParseToken %s %d",
+                        pToken, tokenIndex ) );
             atCoreStatus = CELLULAR_AT_ERROR;
             break;
     }
diff --git a/modules/hl7802/cellular_hl7802_urc_handler.c b/modules/hl7802/cellular_hl7802_urc_handler.c
@@ -118,8 +118,8 @@ static void _cellular_UrcProcessKtcpInd( CellularContext_t * pContext,
             }
             else if( pSocketData->pModemData != ( void * ) ( ( uint32_t ) sessionId ) )
             {
-                LogError( "_cellular_UrcProcessKtcpInd : session not match %d socket index %d",
-                          ( uint32_t ) pSocketData->pModemData, socketIndex );
+                LogError( ( "_cellular_UrcProcessKtcpInd : session not match %d socket index %d",
+                            ( uint32_t ) pSocketData->pModemData, socketIndex ) );
             }
             else if( pSocketData->openCallback == NULL )
             {
@@ -255,8 +255,8 @@ static void _cellular_UrcProcessKtcpNotif( CellularContext_t * pContext,
             }
             else if( pSocketData->pModemData != ( void * ) ( ( uint32_t ) sessionId ) )
             {
-                LogError( "_cellular_UrcProcessKtcpNotif : session not match %d socket index %d",
-                          ( uint32_t ) pSocketData->pModemData, socketIndex );
+                LogError( ( "_cellular_UrcProcessKtcpNotif : session not match %d socket index %d",
+                            ( uint32_t ) pSocketData->pModemData, socketIndex ) );
             }
             else
             {
@@ -318,8 +318,8 @@ static void _cellular_UrcProcessKtcpData( CellularContext_t * pContext,
             }
             else if( pSocketData->pModemData != ( void * ) ( ( uint32_t ) sessionId ) )
             {
-                LogError( "_cellular_UrcProcessKtcpData : session not match %d socket index %d",
-                          ( uint32_t ) pSocketData->pModemData, socketIndex );
+                LogError( ( "_cellular_UrcProcessKtcpData : session not match %d socket index %d",
+                            ( uint32_t ) pSocketData->pModemData, socketIndex ) );
             }
             else if( pSocketData->dataReadyCallback == NULL )
             {
diff --git a/modules/sara_r4/cellular_r4_api.c b/modules/sara_r4/cellular_r4_api.c
@@ -231,8 +231,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA
     /* Check if the received data size is greater than the output buffer size. */
     if( *pDataRecv->pDataLen > outBufSize )
     {
-        LogError( "Data is turncated, received data length %d, out buffer size %d",
-                  *pDataRecv->pDataLen, outBufSize );
+        LogError( ( "Data is turncated, received data length %d, out buffer size %d",
+                    *pDataRecv->pDataLen, outBufSize ) );
         dataLenToCopy = outBufSize;
         *pDataRecv->pDataLen = outBufSize;
     }
@@ -253,8 +253,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA
         }
         else
         {
-            LogError( "Receive Data: paramerter error, data pointer %p, data to copy %d",
-                      pInputLine, dataLenToCopy );
+            LogError( ( "Receive Data: paramerter error, data pointer %p, data to copy %d",
+                        pInputLine, dataLenToCopy ) );
             atCoreStatus = CELLULAR_AT_BAD_PARAMETER;
         }
     }
@@ -372,8 +372,8 @@ static CellularError_t buildSocketConfig( CellularSocketHandle_t socketHandle,
     }
     else if( socketHandle->socketProtocol != CELLULAR_SOCKET_PROTOCOL_TCP )
     {
-        LogError( "buildSocketConfig: socket protocol unsupported %d",
-                  socketHandle->socketProtocol );
+        LogError( ( "buildSocketConfig: socket protocol unsupported %d",
+                    socketHandle->socketProtocol ) );
         cellularStatus = CELLULAR_UNSUPPORTED;
     }
     else
@@ -415,14 +415,14 @@ static CellularError_t storeAccessModeAndAddress( CellularContext_t * pContext,
     }
     else if( socketHandle->socketState != SOCKETSTATE_ALLOCATED )
     {
-        LogError( "storeAccessModeAndAddress, bad socket state %d",
-                  socketHandle->socketState );
+        LogError( ( "storeAccessModeAndAddress, bad socket state %d",
+                    socketHandle->socketState ) );
         cellularStatus = CELLULAR_INTERNAL_FAILURE;
     }
     else if( dataAccessMode != CELLULAR_ACCESSMODE_BUFFER )
     {
-        LogError( "storeAccessModeAndAddress, Access mode not supported %d",
-                  dataAccessMode );
+        LogError( ( "storeAccessModeAndAddress, Access mode not supported %d",
+                    dataAccessMode ) );
         cellularStatus = CELLULAR_UNSUPPORTED;
     }
     else
@@ -982,8 +982,8 @@ CellularError_t Cellular_GetSimCardStatus( CellularHandle_t cellularHandle,
                 pSimCardStatus->simCardState = CELLULAR_SIM_CARD_UNKNOWN;
             }
 
-            LogInfo( "Cellular_GetSimCardStatus, Sim Insert State[%d], Lock State[%d]",
-                     pSimCardStatus->simCardState, pSimCardStatus->simCardLockState );
+            LogInfo( ( "Cellular_GetSimCardStatus, Sim Insert State[%d], Lock State[%d]",
+                       pSimCardStatus->simCardState, pSimCardStatus->simCardLockState ) );
         }
     }
 
@@ -1044,8 +1044,8 @@ CellularError_t Cellular_DeactivatePdn( CellularHandle_t cellularHandle,
                 /* Print only those contexts that are present in +CGACT response */
                 if( pdpContextsActInfo.contextsPresent[ i ] )
                 {
-                    LogDebug( "Context [%d], Act State [%d], Operator <Act> [%d]\r\n", i + 1,
-                              pdpContextsActInfo.contextActState[ i ], serviceStatus.rat );
+                    LogDebug( ( "Context [%d], Act State [%d], Operator <Act> [%d]\r\n", i + 1,
+                                pdpContextsActInfo.contextActState[ i ], serviceStatus.rat ) );
                 }
             }
 
@@ -1409,8 +1409,8 @@ CellularError_t Cellular_ActivatePdn( CellularHandle_t cellularHandle,
                 /* Print only those contexts that are present in +CGACT response */
                 if( pdpContextsActInfo.contextsPresent[ i ] )
                 {
-                    LogDebug( "Cellular_ActivatePdn: Context [%d], Act State [%d]\r\n", i + 1,
-                              pdpContextsActInfo.contextActState[ i ] );
+                    LogDebug( ( "Cellular_ActivatePdn: Context [%d], Act State [%d]\r\n", i + 1,
+                                pdpContextsActInfo.contextActState[ i ] ) );
                 }
             }
         }
@@ -2543,8 +2543,8 @@ CellularError_t Cellular_SetPdnConfig( CellularHandle_t cellularHandle,
                 break;
 
             default:
-                LogDebug( "Cellular_SetPdnConfig: Invalid pdn context type %d",
-                          CELLULAR_PDN_CONTEXT_IPV4V6 );
+                LogDebug( ( "Cellular_SetPdnConfig: Invalid pdn context type %d",
+                            CELLULAR_PDN_CONTEXT_IPV4V6 ) );
                 cellularStatus = CELLULAR_BAD_PARAMETER;
                 break;
         }
@@ -2588,8 +2588,8 @@ CellularError_t Cellular_SetPdnConfig( CellularHandle_t cellularHandle,
                 /* Print only those contexts that are present in +CGDCONT response */
                 if( pdpContextsInfo.contextsPresent[ i ] )
                 {
-                    LogDebug( "Context [%d], IP Type [%s], APN Name [%s], IP Address [%s]\r\n", i + 1,
-                              pdpContextsInfo.ipType[ i ], pdpContextsInfo.apnName, pdpContextsInfo.ipAddress );
+                    LogDebug( ( "Context [%d], IP Type [%s], APN Name [%s], IP Address [%s]\r\n", i + 1,
+                                pdpContextsInfo.ipType[ i ], pdpContextsInfo.apnName, pdpContextsInfo.ipAddress ) );
                 }
             }
         }
diff --git a/modules/sara_r4/cellular_r4_urc_handler.c b/modules/sara_r4/cellular_r4_urc_handler.c
@@ -437,8 +437,8 @@ static void _cellular_UrcProcessUusoco( CellularContext_t * pContext,
             }
             else if( pSocketData->pModemData != ( void * ) sessionId )
             {
-                LogError( "_cellular_UrcProcessUusoco : session not match %d socket index %d",
-                          ( uint32_t ) pSocketData->pModemData, socketIndex );
+                LogError( ( "_cellular_UrcProcessUusoco : session not match %d socket index %d",
+                            ( uint32_t ) pSocketData->pModemData, socketIndex ) );
             }
             else
             {
@@ -516,8 +516,8 @@ static void _cellular_UrcProcessUusord( CellularContext_t * pContext,
             }
             else if( pSocketData->pModemData != ( void * ) sessionId )
             {
-                LogError( "_cellular_UrcProcessUusord : session not match %d socket index %d",
-                          ( uint32_t ) pSocketData->pModemData, socketIndex );
+                LogError( ( "_cellular_UrcProcessUusord : session not match %d socket index %d",
+                            ( uint32_t ) pSocketData->pModemData, socketIndex ) );
             }
             else
             {
@@ -583,8 +583,8 @@ static void _cellular_UrcProcessUusocl( CellularContext_t * pContext,
             }
             else if( pSocketData->pModemData != ( void * ) sessionId )
             {
-                LogError( "_cellular_UrcProcessUusocl : session not match %d socket index %d",
-                          ( uint32_t ) pSocketData->pModemData, socketIndex );
+                LogError( ( "_cellular_UrcProcessUusocl : session not match %d socket index %d",
+                            ( uint32_t ) pSocketData->pModemData, socketIndex ) );
             }
             else
             {

Original file line number	Diff line number	Diff line change
`@@ -1051,8 +1051,8 @@ static CellularATError_t getPdnStatusParseToken( char * pToken,`
`1051`	`1051`	`break;`
`1052`	`1052`
`1053`	`1053`	`default:`
`1054`		`- LogError( "Unknown token in getPdnStatusParseToken %s %d",`
`1055`		`- pToken, tokenIndex );`
	`1054`	`+ LogError( ( "Unknown token in getPdnStatusParseToken %s %d",`
	`1055`	`+ pToken, tokenIndex ) );`
`1056`	`1056`	`atCoreStatus = CELLULAR_AT_ERROR;`
`1057`	`1057`	`break;`
`1058`	`1058`	`}`
`@@ -1229,8 +1229,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA`
`1229`	`1229`	`/* Check if the received data size is greater than the output buffer size. */`
`1230`	`1230`	`if( *pDataRecv->pDataLen > outBufSize )`
`1231`	`1231`	`{`
`1232`		`- LogError( "Data is turncated, received data length %d, out buffer size %d",`
`1233`		`- *pDataRecv->pDataLen, outBufSize );`
	`1232`	`+ LogError( ( "Data is turncated, received data length %d, out buffer size %d",`
	`1233`	`+ *pDataRecv->pDataLen, outBufSize ) );`
`1234`	`1234`	`dataLenToCopy = outBufSize;`
`1235`	`1235`	`*pDataRecv->pDataLen = outBufSize;`
`1236`	`1236`	`}`
`@@ -1643,11 +1643,13 @@ static CellularPktStatus_t _Cellular_RecvFuncGetPsmSettings( CellularContext_t *`
`1643`	`1643`
`1644`	`1644`	`while( pToken != NULL )`
`1645`	`1645`	`{`
`1646`		`- atCoreStatus = parseGetPsmToken( pToken, tokenIndex, pPsmSettings );`
`1647`		`-`
`1648`		`- if( atCoreStatus != CELLULAR_AT_SUCCESS )`
	`1646`	`+ if( tokenIndex == 0 )`
	`1647`	`+ {`
	`1648`	`+ atCoreStatus = parseGetPsmToken( pToken, tokenIndex, pPsmSettings );`
	`1649`	`+ }`
	`1650`	`+ else`
`1649`	`1651`	`{`
`1650`		`- LogInfo( ( "parseGetPsmToken %s index %d failed", pToken, tokenIndex ) );`
	`1652`	`+ parseGetPsmToken( pToken, tokenIndex, pPsmSettings );`
`1651`	`1653`	`}`
`1652`	`1654`
`1653`	`1655`	`tokenIndex++;`
`@@ -1670,12 +1672,12 @@ static CellularPktStatus_t _Cellular_RecvFuncGetPsmSettings( CellularContext_t *`
`1670`	`1672`	`}`
`1671`	`1673`	`}`
`1672`	`1674`
`1673`		`- LogDebug( "PSM setting: mode: %d, RAU: %d, RDY_Timer: %d, TAU: %d, Active_time: %d",`
`1674`		`- pPsmSettings->mode,`
`1675`		`- pPsmSettings->periodicRauValue,`
`1676`		`- pPsmSettings->gprsReadyTimer,`
`1677`		`- pPsmSettings->periodicTauValue,`
`1678`		`- pPsmSettings->activeTimeValue );`
	`1675`	`+ LogDebug( ( "PSM setting: mode: %d, RAU: %d, RDY_Timer: %d, TAU: %d, Active_time: %d",`
	`1676`	`+ pPsmSettings->mode,`
	`1677`	`+ pPsmSettings->periodicRauValue,`
	`1678`	`+ pPsmSettings->gprsReadyTimer,`
	`1679`	`+ pPsmSettings->periodicTauValue,`
	`1680`	`+ pPsmSettings->activeTimeValue ) );`
`1679`	`1681`	`pktStatus = _Cellular_TranslateAtCoreStatus( atCoreStatus );`
`1680`	`1682`	`}`
`1681`	`1683`
`@@ -1794,14 +1796,14 @@ static CellularError_t storeAccessModeAndAddress( CellularContext_t * pContext,`
`1794`	`1796`	`}`
`1795`	`1797`	`else if( socketHandle->socketState != SOCKETSTATE_ALLOCATED )`
`1796`	`1798`	`{`
`1797`		`- LogError( "storeAccessModeAndAddress, bad socket state %d",`
`1798`		`- socketHandle->socketState );`
	`1799`	`+ LogError( ( "storeAccessModeAndAddress, bad socket state %d",`
	`1800`	`+ socketHandle->socketState ) );`
`1799`	`1801`	`cellularStatus = CELLULAR_INTERNAL_FAILURE;`
`1800`	`1802`	`}`
`1801`	`1803`	`else if( dataAccessMode != CELLULAR_ACCESSMODE_BUFFER )`
`1802`	`1804`	`{`
`1803`		`- LogError( "storeAccessModeAndAddress, Access mode not supported %d",`
`1804`		`- dataAccessMode );`
	`1805`	`+ LogError( ( "storeAccessModeAndAddress, Access mode not supported %d",`
	`1806`	`+ dataAccessMode ) );`
`1805`	`1807`	`cellularStatus = CELLULAR_UNSUPPORTED;`
`1806`	`1808`	`}`
`1807`	`1809`	`else`
`@@ -2921,8 +2923,8 @@ CellularError_t Cellular_GetSimCardStatus( CellularHandle_t cellularHandle,`
`2921`	`2923`	`}`
`2922`	`2924`
`2923`	`2925`	`cellularStatus = _Cellular_TranslatePktStatus( pktStatus );`
`2924`		`- LogDebug( "_Cellular_GetSimStatus, Sim Insert State[%d], Lock State[%d]",`
`2925`		`- pSimCardStatus->simCardState, pSimCardStatus->simCardLockState );`
	`2926`	`+ LogDebug( ( "_Cellular_GetSimStatus, Sim Insert State[%d], Lock State[%d]",`
	`2927`	`+ pSimCardStatus->simCardState, pSimCardStatus->simCardLockState ) );`
`2926`	`2928`	`}`
`2927`	`2929`
`2928`	`2930`	`return cellularStatus;`
`@@ -2999,9 +3001,9 @@ CellularError_t Cellular_GetSimCardInfo( CellularHandle_t cellularHandle,`
`2999`	`3001`	`}`
`3000`	`3002`	`else`
`3001`	`3003`	`{`
`3002`		`- LogDebug( "SimInfo updated: IMSI:%s, Hplmn:%s%s, ICCID:%s",`
`3003`		`- pSimCardInfo->imsi, pSimCardInfo->plmn.mcc, pSimCardInfo->plmn.mnc,`
`3004`		`- pSimCardInfo->iccid );`
	`3004`	`+ LogDebug( ( "SimInfo updated: IMSI:%s, Hplmn:%s%s, ICCID:%s",`
	`3005`	`+ pSimCardInfo->imsi, pSimCardInfo->plmn.mcc, pSimCardInfo->plmn.mnc,`
	`3006`	`+ pSimCardInfo->iccid ) );`
`3005`	`3007`	`}`
`3006`	`3008`	`}`
`3007`	`3009`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ static CellularPktStatus_t _parseSocketOpenNextTok( const char * pToken,`
`96`	`96`	`if( sockStatus != 0 )`
`97`	`97`	`{`
`98`	`98`	`pSocketData->socketState = SOCKETSTATE_DISCONNECTED;`
`99`		`- LogError( ( ( "_parseSocketOpen: Socket open failed, conn %d, status %d", sockIndex, sockStatus ) ) );`
	`99`	`+ LogError( ( "_parseSocketOpen: Socket open failed, conn %d, status %d", sockIndex, sockStatus ) );`
`100`	`100`	`}`
`101`	`101`	`else`
`102`	`102`	`{`
Original file line number	Diff line number	Diff line change
`@@ -411,8 +411,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA`
`411`	`411`	`/* Check if the received data size is greater than the output buffer size. */`
`412`	`412`	`if( *pDataRecv->pDataLen > outBufSize )`
`413`	`413`	`{`
`414`		`- LogError( "Data is turncated, received data length %d, out buffer size %d",`
`415`		`- *pDataRecv->pDataLen, outBufSize );`
	`414`	`+ LogError( ( "Data is turncated, received data length %d, out buffer size %d",`
	`415`	`+ *pDataRecv->pDataLen, outBufSize ) );`
`416`	`416`	`dataLenToCopy = outBufSize;`
`417`	`417`	`*pDataRecv->pDataLen = outBufSize;`
`418`	`418`	`}`
`@@ -433,8 +433,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA`
`433`	`433`	`}`
`434`	`434`	`else`
`435`	`435`	`{`
`436`		`- LogError( "Receive Data: paramerter error, data pointer %p, data to copy %d",`
`437`		`- pInputLine, dataLenToCopy );`
	`436`	`+ LogError( ( "Receive Data: paramerter error, data pointer %p, data to copy %d",`
	`437`	`+ pInputLine, dataLenToCopy ) );`
`438`	`438`	`atCoreStatus = CELLULAR_AT_BAD_PARAMETER;`
`439`	`439`	`}`
`440`	`440`	`}`
`@@ -531,8 +531,8 @@ static CellularError_t buildSocketConfig( CellularSocketHandle_t socketHandle,`
`531`	`531`	`}`
`532`	`532`	`else if( socketHandle->socketProtocol != CELLULAR_SOCKET_PROTOCOL_TCP )`
`533`	`533`	`{`
`534`		`- LogError( "buildSocketConfig: socket protocol unsupported %d",`
`535`		`- socketHandle->socketProtocol );`
	`534`	`+ LogError( ( "buildSocketConfig: socket protocol unsupported %d",`
	`535`	`+ socketHandle->socketProtocol ) );`
`536`	`536`	`cellularStatus = CELLULAR_UNSUPPORTED;`
`537`	`537`	`}`
`538`	`538`	`else`
`@@ -575,14 +575,14 @@ static CellularError_t storeAccessModeAndAddress( CellularContext_t * pContext,`
`575`	`575`	`}`
`576`	`576`	`else if( socketHandle->socketState != SOCKETSTATE_ALLOCATED )`
`577`	`577`	`{`
`578`		`- LogError( "storeAccessModeAndAddress, bad socket state %d",`
`579`		`- socketHandle->socketState );`
	`578`	`+ LogError( ( "storeAccessModeAndAddress, bad socket state %d",`
	`579`	`+ socketHandle->socketState ) );`
`580`	`580`	`cellularStatus = CELLULAR_INTERNAL_FAILURE;`
`581`	`581`	`}`
`582`	`582`	`else if( dataAccessMode != CELLULAR_ACCESSMODE_BUFFER )`
`583`	`583`	`{`
`584`		`- LogError( "storeAccessModeAndAddress, Access mode not supported %d",`
`585`		`- dataAccessMode );`
	`584`	`+ LogError( ( "storeAccessModeAndAddress, Access mode not supported %d",`
	`585`	`+ dataAccessMode ) );`
`586`	`586`	`cellularStatus = CELLULAR_UNSUPPORTED;`
`587`	`587`	`}`
`588`	`588`	`else`
`@@ -898,8 +898,8 @@ static CellularPktStatus_t _Cellular_RecvFuncGetEidrxSettings( CellularContext_t`
`898`	`898`	`}`
`899`	`899`	`else`
`900`	`900`	`{`
`901`		`- LogDebug( "GetEidrx setting[%d]: RAT: %d, Value: 0x%x",`
`902`		`- count, pEidrxSettingsList->eidrxList[ count ].rat, pEidrxSettingsList->eidrxList[ count ].requestedEdrxVaue );`
	`901`	`+ LogDebug( ( "GetEidrx setting[%d]: RAT: %d, Value: 0x%x",`
	`902`	`+ count, pEidrxSettingsList->eidrxList[ count ].rat, pEidrxSettingsList->eidrxList[ count ].requestedEdrxVaue ) );`
`903`	`903`	`}`
`904`	`904`
`905`	`905`	`pCommnadItem = pCommnadItem->pNext;`
`@@ -2021,8 +2021,8 @@ static CellularATError_t getPdnStatusParseToken( char * pToken,`
`2021`	`2021`	`break;`
`2022`	`2022`
`2023`	`2023`	`default:`
`2024`		`- LogError( "Unknown token in getPdnStatusParseToken %s %d",`
`2025`		`- pToken, tokenIndex );`
	`2024`	`+ LogError( ( "Unknown token in getPdnStatusParseToken %s %d",`
	`2025`	`+ pToken, tokenIndex ) );`
`2026`	`2026`	`atCoreStatus = CELLULAR_AT_ERROR;`
`2027`	`2027`	`break;`
`2028`	`2028`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,8 +118,8 @@ static void _cellular_UrcProcessKtcpInd( CellularContext_t * pContext,`
`118`	`118`	`}`
`119`	`119`	`else if( pSocketData->pModemData != ( void * ) ( ( uint32_t ) sessionId ) )`
`120`	`120`	`{`
`121`		`- LogError( "_cellular_UrcProcessKtcpInd : session not match %d socket index %d",`
`122`		`- ( uint32_t ) pSocketData->pModemData, socketIndex );`
	`121`	`+ LogError( ( "_cellular_UrcProcessKtcpInd : session not match %d socket index %d",`
	`122`	`+ ( uint32_t ) pSocketData->pModemData, socketIndex ) );`
`123`	`123`	`}`
`124`	`124`	`else if( pSocketData->openCallback == NULL )`
`125`	`125`	`{`
`@@ -255,8 +255,8 @@ static void _cellular_UrcProcessKtcpNotif( CellularContext_t * pContext,`
`255`	`255`	`}`
`256`	`256`	`else if( pSocketData->pModemData != ( void * ) ( ( uint32_t ) sessionId ) )`
`257`	`257`	`{`
`258`		`- LogError( "_cellular_UrcProcessKtcpNotif : session not match %d socket index %d",`
`259`		`- ( uint32_t ) pSocketData->pModemData, socketIndex );`
	`258`	`+ LogError( ( "_cellular_UrcProcessKtcpNotif : session not match %d socket index %d",`
	`259`	`+ ( uint32_t ) pSocketData->pModemData, socketIndex ) );`
`260`	`260`	`}`
`261`	`261`	`else`
`262`	`262`	`{`
`@@ -318,8 +318,8 @@ static void _cellular_UrcProcessKtcpData( CellularContext_t * pContext,`
`318`	`318`	`}`
`319`	`319`	`else if( pSocketData->pModemData != ( void * ) ( ( uint32_t ) sessionId ) )`
`320`	`320`	`{`
`321`		`- LogError( "_cellular_UrcProcessKtcpData : session not match %d socket index %d",`
`322`		`- ( uint32_t ) pSocketData->pModemData, socketIndex );`
	`321`	`+ LogError( ( "_cellular_UrcProcessKtcpData : session not match %d socket index %d",`
	`322`	`+ ( uint32_t ) pSocketData->pModemData, socketIndex ) );`
`323`	`323`	`}`
`324`	`324`	`else if( pSocketData->dataReadyCallback == NULL )`
`325`	`325`	`{`
Original file line number	Diff line number	Diff line change
`@@ -231,8 +231,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA`
`231`	`231`	`/* Check if the received data size is greater than the output buffer size. */`
`232`	`232`	`if( *pDataRecv->pDataLen > outBufSize )`
`233`	`233`	`{`
`234`		`- LogError( "Data is turncated, received data length %d, out buffer size %d",`
`235`		`- *pDataRecv->pDataLen, outBufSize );`
	`234`	`+ LogError( ( "Data is turncated, received data length %d, out buffer size %d",`
	`235`	`+ *pDataRecv->pDataLen, outBufSize ) );`
`236`	`236`	`dataLenToCopy = outBufSize;`
`237`	`237`	`*pDataRecv->pDataLen = outBufSize;`
`238`	`238`	`}`
`@@ -253,8 +253,8 @@ static CellularATError_t getDataFromResp( const CellularATCommandResponse_t * pA`
`253`	`253`	`}`
`254`	`254`	`else`
`255`	`255`	`{`
`256`		`- LogError( "Receive Data: paramerter error, data pointer %p, data to copy %d",`
`257`		`- pInputLine, dataLenToCopy );`
	`256`	`+ LogError( ( "Receive Data: paramerter error, data pointer %p, data to copy %d",`
	`257`	`+ pInputLine, dataLenToCopy ) );`
`258`	`258`	`atCoreStatus = CELLULAR_AT_BAD_PARAMETER;`
`259`	`259`	`}`
`260`	`260`	`}`
`@@ -372,8 +372,8 @@ static CellularError_t buildSocketConfig( CellularSocketHandle_t socketHandle,`
`372`	`372`	`}`
`373`	`373`	`else if( socketHandle->socketProtocol != CELLULAR_SOCKET_PROTOCOL_TCP )`
`374`	`374`	`{`
`375`		`- LogError( "buildSocketConfig: socket protocol unsupported %d",`
`376`		`- socketHandle->socketProtocol );`
	`375`	`+ LogError( ( "buildSocketConfig: socket protocol unsupported %d",`
	`376`	`+ socketHandle->socketProtocol ) );`
`377`	`377`	`cellularStatus = CELLULAR_UNSUPPORTED;`
`378`	`378`	`}`
`379`	`379`	`else`
`@@ -415,14 +415,14 @@ static CellularError_t storeAccessModeAndAddress( CellularContext_t * pContext,`
`415`	`415`	`}`
`416`	`416`	`else if( socketHandle->socketState != SOCKETSTATE_ALLOCATED )`
`417`	`417`	`{`
`418`		`- LogError( "storeAccessModeAndAddress, bad socket state %d",`
`419`		`- socketHandle->socketState );`
	`418`	`+ LogError( ( "storeAccessModeAndAddress, bad socket state %d",`
	`419`	`+ socketHandle->socketState ) );`
`420`	`420`	`cellularStatus = CELLULAR_INTERNAL_FAILURE;`
`421`	`421`	`}`
`422`	`422`	`else if( dataAccessMode != CELLULAR_ACCESSMODE_BUFFER )`
`423`	`423`	`{`
`424`		`- LogError( "storeAccessModeAndAddress, Access mode not supported %d",`
`425`		`- dataAccessMode );`
	`424`	`+ LogError( ( "storeAccessModeAndAddress, Access mode not supported %d",`
	`425`	`+ dataAccessMode ) );`
`426`	`426`	`cellularStatus = CELLULAR_UNSUPPORTED;`
`427`	`427`	`}`
`428`	`428`	`else`
`@@ -982,8 +982,8 @@ CellularError_t Cellular_GetSimCardStatus( CellularHandle_t cellularHandle,`
`982`	`982`	`pSimCardStatus->simCardState = CELLULAR_SIM_CARD_UNKNOWN;`
`983`	`983`	`}`
`984`	`984`
`985`		`- LogInfo( "Cellular_GetSimCardStatus, Sim Insert State[%d], Lock State[%d]",`
`986`		`- pSimCardStatus->simCardState, pSimCardStatus->simCardLockState );`
	`985`	`+ LogInfo( ( "Cellular_GetSimCardStatus, Sim Insert State[%d], Lock State[%d]",`
	`986`	`+ pSimCardStatus->simCardState, pSimCardStatus->simCardLockState ) );`
`987`	`987`	`}`
`988`	`988`	`}`
`989`	`989`
`@@ -1044,8 +1044,8 @@ CellularError_t Cellular_DeactivatePdn( CellularHandle_t cellularHandle,`
`1044`	`1044`	`/* Print only those contexts that are present in +CGACT response */`
`1045`	`1045`	`if( pdpContextsActInfo.contextsPresent[ i ] )`
`1046`	`1046`	`{`
`1047`		`- LogDebug( "Context [%d], Act State [%d], Operator <Act> [%d]\r\n", i + 1,`
`1048`		`- pdpContextsActInfo.contextActState[ i ], serviceStatus.rat );`
	`1047`	`+ LogDebug( ( "Context [%d], Act State [%d], Operator <Act> [%d]\r\n", i + 1,`
	`1048`	`+ pdpContextsActInfo.contextActState[ i ], serviceStatus.rat ) );`
`1049`	`1049`	`}`
`1050`	`1050`	`}`
`1051`	`1051`
`@@ -1409,8 +1409,8 @@ CellularError_t Cellular_ActivatePdn( CellularHandle_t cellularHandle,`
`1409`	`1409`	`/* Print only those contexts that are present in +CGACT response */`
`1410`	`1410`	`if( pdpContextsActInfo.contextsPresent[ i ] )`
`1411`	`1411`	`{`
`1412`		`- LogDebug( "Cellular_ActivatePdn: Context [%d], Act State [%d]\r\n", i + 1,`
`1413`		`- pdpContextsActInfo.contextActState[ i ] );`
	`1412`	`+ LogDebug( ( "Cellular_ActivatePdn: Context [%d], Act State [%d]\r\n", i + 1,`
	`1413`	`+ pdpContextsActInfo.contextActState[ i ] ) );`
`1414`	`1414`	`}`
`1415`	`1415`	`}`
`1416`	`1416`	`}`
`@@ -2543,8 +2543,8 @@ CellularError_t Cellular_SetPdnConfig( CellularHandle_t cellularHandle,`
`2543`	`2543`	`break;`
`2544`	`2544`
`2545`	`2545`	`default:`
`2546`		`- LogDebug( "Cellular_SetPdnConfig: Invalid pdn context type %d",`
`2547`		`- CELLULAR_PDN_CONTEXT_IPV4V6 );`
	`2546`	`+ LogDebug( ( "Cellular_SetPdnConfig: Invalid pdn context type %d",`
	`2547`	`+ CELLULAR_PDN_CONTEXT_IPV4V6 ) );`
`2548`	`2548`	`cellularStatus = CELLULAR_BAD_PARAMETER;`
`2549`	`2549`	`break;`
`2550`	`2550`	`}`
`@@ -2588,8 +2588,8 @@ CellularError_t Cellular_SetPdnConfig( CellularHandle_t cellularHandle,`
`2588`	`2588`	`/* Print only those contexts that are present in +CGDCONT response */`
`2589`	`2589`	`if( pdpContextsInfo.contextsPresent[ i ] )`
`2590`	`2590`	`{`
`2591`		`- LogDebug( "Context [%d], IP Type [%s], APN Name [%s], IP Address [%s]\r\n", i + 1,`
`2592`		`- pdpContextsInfo.ipType[ i ], pdpContextsInfo.apnName, pdpContextsInfo.ipAddress );`
	`2591`	`+ LogDebug( ( "Context [%d], IP Type [%s], APN Name [%s], IP Address [%s]\r\n", i + 1,`
	`2592`	`+ pdpContextsInfo.ipType[ i ], pdpContextsInfo.apnName, pdpContextsInfo.ipAddress ) );`
`2593`	`2593`	`}`
`2594`	`2594`	`}`
`2595`	`2595`	`}`
Original file line number	Diff line number	Diff line change
`@@ -437,8 +437,8 @@ static void _cellular_UrcProcessUusoco( CellularContext_t * pContext,`
`437`	`437`	`}`
`438`	`438`	`else if( pSocketData->pModemData != ( void * ) sessionId )`
`439`	`439`	`{`
`440`		`- LogError( "_cellular_UrcProcessUusoco : session not match %d socket index %d",`
`441`		`- ( uint32_t ) pSocketData->pModemData, socketIndex );`
	`440`	`+ LogError( ( "_cellular_UrcProcessUusoco : session not match %d socket index %d",`
	`441`	`+ ( uint32_t ) pSocketData->pModemData, socketIndex ) );`
`442`	`442`	`}`
`443`	`443`	`else`
`444`	`444`	`{`
`@@ -516,8 +516,8 @@ static void _cellular_UrcProcessUusord( CellularContext_t * pContext,`
`516`	`516`	`}`
`517`	`517`	`else if( pSocketData->pModemData != ( void * ) sessionId )`
`518`	`518`	`{`
`519`		`- LogError( "_cellular_UrcProcessUusord : session not match %d socket index %d",`
`520`		`- ( uint32_t ) pSocketData->pModemData, socketIndex );`
	`519`	`+ LogError( ( "_cellular_UrcProcessUusord : session not match %d socket index %d",`
	`520`	`+ ( uint32_t ) pSocketData->pModemData, socketIndex ) );`
`521`	`521`	`}`
`522`	`522`	`else`
`523`	`523`	`{`
`@@ -583,8 +583,8 @@ static void _cellular_UrcProcessUusocl( CellularContext_t * pContext,`
`583`	`583`	`}`
`584`	`584`	`else if( pSocketData->pModemData != ( void * ) sessionId )`
`585`	`585`	`{`
`586`		`- LogError( "_cellular_UrcProcessUusocl : session not match %d socket index %d",`
`587`		`- ( uint32_t ) pSocketData->pModemData, socketIndex );`
	`586`	`+ LogError( ( "_cellular_UrcProcessUusocl : session not match %d socket index %d",`
	`587`	`+ ( uint32_t ) pSocketData->pModemData, socketIndex ) );`
`588`	`588`	`}`
`589`	`589`	`else`
`590`	`590`	`{`