[修改] 增加freeRTOS

1. 版本FreeRTOSv202212.01，命名为kernel；

kernel/FreeRTOS-Plus/Source/FreeRTOS-Cellular-Modules/hl7802/source/cellular_hl7802.c

@@ -0,0 +1,594 @@
+/*
+ * FreeRTOS-Cellular-Interface v1.3.0
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * 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.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ */
+
+/* The config header is always included first. */
+
+#include <stdint.h>
+
+#include "cellular_config.h"
+#include "cellular_config_defaults.h"
+#include "cellular_common.h"
+#include "cellular_common_portable.h"
+#include "cellular_hl7802.h"
+
+/*-----------------------------------------------------------*/
+
+#define ENBABLE_MODULE_UE_RETRY_COUNT    ( 6U )
+#define HL7802_MAX_BAND_CFG              ( 21U )
+#define HL7802_KSELACQ_CMD_MAX_SIZE      ( 19U ) /* The length of AT+KSELACQ=0,1,2,3\0. */
+
+/*-----------------------------------------------------------*/
+
+typedef struct Hl7802BandConfig
+{
+    char catm1BandCfg[ HL7802_MAX_BAND_CFG ];
+    char nbiotBandCfg[ HL7802_MAX_BAND_CFG ];
+    char gsmBandCfg[ HL7802_MAX_BAND_CFG ];
+} Hl7802BandConfig_t;
+
+/*-----------------------------------------------------------*/
+
+static CellularError_t sendAtCommandWithRetryTimeout( CellularContext_t * pContext,
+                                                      const CellularAtReq_t * pAtReq,
+                                                      uint32_t timeoutMs );
+static CellularError_t getBandCfg( CellularContext_t * pContext,
+                                   Hl7802BandConfig_t * pBandCfg );
+static CellularPktStatus_t recvFuncGetBandCfg( CellularContext_t * pContext,
+                                               const CellularATCommandResponse_t * pAtResp,
+                                               void * pData,
+                                               uint16_t dataLen );
+
+/*-----------------------------------------------------------*/
+
+static cellularModuleContext_t cellularHl7802Context = { 0 };
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+const char * CellularSrcTokenErrorTable[] =
+{ "ERROR", "BUSY", "NO CARRIER", "NO ANSWER", "NO DIALTONE", "ABORTED", "+CMS ERROR", "+CME ERROR", "SEND FAIL" };
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+uint32_t CellularSrcTokenErrorTableSize = sizeof( CellularSrcTokenErrorTable ) / sizeof( char * );
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+const char * CellularSrcTokenSuccessTable[] =
+{ "OK" };
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+uint32_t CellularSrcTokenSuccessTableSize = sizeof( CellularSrcTokenSuccessTable ) / sizeof( char * );
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+const char * CellularUrcTokenWoPrefixTable[] = { 0 };
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+uint32_t CellularUrcTokenWoPrefixTableSize = 0;
+
+/*-----------------------------------------------------------*/
+
+static CellularError_t sendAtCommandWithRetryTimeout( CellularContext_t * pContext,
+                                                      const CellularAtReq_t * pAtReq,
+                                                      uint32_t timeoutMs )
+{
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+    CellularPktStatus_t pktStatus = CELLULAR_PKT_STATUS_OK;
+    uint8_t tryCount = 0;
+
+    if( pAtReq == NULL )
+    {
+        cellularStatus = CELLULAR_BAD_PARAMETER;
+    }
+    else
+    {
+        for( ; tryCount < ENBABLE_MODULE_UE_RETRY_COUNT; tryCount++ )
+        {
+            pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, *pAtReq, timeoutMs );
+            cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+
+            if( cellularStatus == CELLULAR_SUCCESS )
+            {
+                break;
+            }
+        }
+    }
+
+    return cellularStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+static CellularPktStatus_t recvFuncGetBandCfg( CellularContext_t * pContext,
+                                               const CellularATCommandResponse_t * pAtResp,
+                                               void * pData,
+                                               uint16_t dataLen )
+{
+    CellularPktStatus_t pktStatus = CELLULAR_PKT_STATUS_OK;
+    CellularATError_t atCoreStatus = CELLULAR_AT_SUCCESS;
+    Hl7802BandConfig_t * pBandCfg = NULL;
+    const CellularATCommandLine_t * pCommnadItem = NULL;
+    char * pInputLine = NULL;
+    char * pToken = NULL;
+    char * pRatBand = NULL;
+
+    if( pContext == NULL )
+    {
+        LogError( ( "recvFuncGetBandCfg: Invalid context." ) );
+        pktStatus = CELLULAR_PKT_STATUS_BAD_PARAM;
+    }
+    else if( pAtResp == NULL )
+    {
+        LogError( ( "recvFuncGetBandCfg: Invalid pAtResp." ) );
+        pktStatus = CELLULAR_PKT_STATUS_BAD_PARAM;
+    }
+    else if( ( pData == NULL ) || ( dataLen != sizeof( Hl7802BandConfig_t ) ) )
+    {
+        LogError( ( "recvFuncGetBandCfg: Invalid pData %p or dataLen %u.", pData, dataLen ) );
+        pktStatus = CELLULAR_PKT_STATUS_BAD_PARAM;
+    }
+    else
+    {
+        pBandCfg = ( Hl7802BandConfig_t * ) pData;
+        pCommnadItem = pAtResp->pItm;
+
+        while( pCommnadItem != NULL )
+        {
+            pInputLine = pCommnadItem->pLine;
+            LogDebug( ( "recvFuncGetBandCfg: input line %s", pInputLine ) );
+
+            /* Remove the line prefix. */
+            atCoreStatus = Cellular_ATRemovePrefix( &pInputLine );
+
+            /* Parse the RAT field. */
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                atCoreStatus = Cellular_ATGetNextTok( &pInputLine, &pToken );
+            }
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                atCoreStatus = Cellular_ATRemoveLeadingWhiteSpaces( &pToken );
+            }
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                switch( *pToken )
+                {
+                    case '0':
+                        pRatBand = pBandCfg->catm1BandCfg;
+                        break;
+
+                    case '1':
+                        pRatBand = pBandCfg->nbiotBandCfg;
+                        break;
+
+                    case '2':
+                        pRatBand = pBandCfg->gsmBandCfg;
+                        break;
+
+                    default:
+                        pRatBand = NULL;
+                        LogError( ( "recvFuncGetBandCfg: unknown RAT %s", pToken ) );
+                        atCoreStatus = CELLULAR_AT_ERROR;
+                        break;
+                }
+            }
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                /* Copy the band configuration. */
+                strncpy( pRatBand, pInputLine, HL7802_MAX_BAND_CFG );
+            }
+            else
+            {
+                LogError( ( "recvFuncGetBandCfg process response line error" ) );
+                pktStatus = _Cellular_TranslateAtCoreStatus( atCoreStatus );
+                break;
+            }
+
+            pCommnadItem = pCommnadItem->pNext;
+        }
+    }
+
+    return pktStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+static CellularError_t getBandCfg( CellularContext_t * pContext,
+                                   Hl7802BandConfig_t * pBandCfg )
+{
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+    CellularPktStatus_t pktStatus = CELLULAR_PKT_STATUS_OK;
+    CellularAtReq_t atReqGetBndCfg =
+    {
+        "AT+KBNDCFG?",
+        CELLULAR_AT_MULTI_WITH_PREFIX,
+        "+KBNDCFG",
+        recvFuncGetBandCfg,
+        pBandCfg,
+        sizeof( Hl7802BandConfig_t )
+    };
+
+    /* pContext and pBandCfg are checked in Cellular_ModuleEnableUe function. */
+    ( void ) memset( pBandCfg, 0, sizeof( Hl7802BandConfig_t ) );
+    pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetBndCfg,
+                                                           CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+
+    if( pktStatus != CELLULAR_PKT_STATUS_OK )
+    {
+        LogError( ( "getBandCfg: couldn't retrieve band configurations." ) );
+        cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+    }
+
+    return cellularStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+static bool appendRatList( char * pRatList,
+                           CellularRat_t cellularRat )
+{
+    bool retValue = true;
+
+    switch( cellularRat )
+    {
+        case CELLULAR_RAT_CATM1:
+            strcat( pRatList, ",1" );
+            break;
+
+        case CELLULAR_RAT_NBIOT:
+            strcat( pRatList, ",2" );
+            break;
+
+        case CELLULAR_RAT_GSM:
+            strcat( pRatList, ",3" );
+            break;
+
+        default:
+            /* Unsupported RAT. */
+            retValue = false;
+            break;
+    }
+
+    return retValue;
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_ModuleInit( const CellularContext_t * pContext,
+                                     void ** ppModuleContext )
+{
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+    uint32_t i = 0;
+
+    if( pContext == NULL )
+    {
+        cellularStatus = CELLULAR_INVALID_HANDLE;
+    }
+    else if( ppModuleContext == NULL )
+    {
+        cellularStatus = CELLULAR_BAD_PARAMETER;
+    }
+    else
+    {
+        /* Initialize the module context. */
+        ( void ) memset( &cellularHl7802Context, 0, sizeof( cellularModuleContext_t ) );
+
+        for( i = 0; i < TCP_SESSION_TABLE_LEGNTH; i++ )
+        {
+            cellularHl7802Context.pSessionMap[ i ] = INVALID_SOCKET_INDEX;
+        }
+
+        *ppModuleContext = ( void * ) &cellularHl7802Context;
+    }
+
+    return cellularStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_ModuleCleanUp( const CellularContext_t * pContext )
+{
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+
+    if( pContext == NULL )
+    {
+        cellularStatus = CELLULAR_INVALID_HANDLE;
+    }
+
+    return cellularStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_ModuleEnableUE( CellularContext_t * pContext )
+{
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+    CellularPktStatus_t pktStatus = CELLULAR_PKT_STATUS_OK;
+    CellularAtReq_t atReqGetWoPrefix =
+    {
+        NULL,
+        CELLULAR_AT_WO_PREFIX,
+        NULL,
+        NULL,
+        NULL,
+        0
+    };
+    CellularAtReq_t atReqGetNoResult =
+    {
+        NULL,
+        CELLULAR_AT_NO_RESULT,
+        NULL,
+        NULL,
+        NULL,
+        0
+    };
+    Hl7802BandConfig_t bandCfg = { 0 };
+    char ratSelectCmd[ HL7802_KSELACQ_CMD_MAX_SIZE ] = "AT+KSELACQ=0";
+    bool retAppendRat = true;
+
+    if( pContext != NULL )
+    {
+        /* Disable echo. */
+        atReqGetWoPrefix.pAtCmd = "ATE0";
+        cellularStatus = sendAtCommandWithRetryTimeout( pContext, &atReqGetWoPrefix,
+                                                        CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            /* Disable DTR function. */
+            atReqGetNoResult.pAtCmd = "AT&D0";
+            pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                   CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+            cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+        }
+
+        #ifndef CELLULAR_CONFIG_DISABLE_FLOW_CONTROL
+            if( cellularStatus == CELLULAR_SUCCESS )
+            {
+                /* Enable RTS/CTS hardware flow control. */
+                atReqGetNoResult.pAtCmd = "AT+IFC=2,2";
+                pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                       CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+                cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+            }
+        #endif
+
+        /* Set Radio Access Technology. */
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            /* In the Write format, <mode>=0 is used to switch to the first RAT
+             * in the preferred RAT list (PRL), and fall back to subsequent RATS
+             * in the PRL if cell coverage is lost. If the PRL is empty, switch to
+             * CAT-M1. To set the PRL, see AT+KSELACQ. */
+            atReqGetNoResult.pAtCmd = "AT+KSRAT=0";
+            pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                   CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+            cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+        }
+
+        /* Set Default Radio Access Technology. */
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            retAppendRat = appendRatList( ratSelectCmd, CELLULAR_CONFIG_DEFAULT_RAT );
+            configASSERT( retAppendRat == true );
+
+            #ifdef CELLULAR_CONFIG_DEFAULT_RAT_2
+                retAppendRat = appendRatList( ratSelectCmd, CELLULAR_CONFIG_DEFAULT_RAT_2 );
+                configASSERT( retAppendRat == true );
+            #endif
+
+            #ifdef CELLULAR_CONFIG_DEFAULT_RAT_3
+                retAppendRat = appendRatList( ratSelectCmd, CELLULAR_CONFIG_DEFAULT_RAT_3 );
+                configASSERT( retAppendRat == true );
+            #endif
+
+            atReqGetNoResult.pAtCmd = ratSelectCmd;
+            pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                   CELLULAR_HL7802_AT_KSELACQ_TIMEOUT_MS );
+            cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+        }
+
+        /* Set Configured LTE Band. */
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            cellularStatus = getBandCfg( pContext, &bandCfg );
+        }
+
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            if( strcmp( bandCfg.catm1BandCfg, CELLULAR_CONFIG_HL7802_CATM1_BAND ) != 0 )
+            {
+                LogInfo( ( "Cellular_ModuleEnableUE : CAT-M1 band desired %s actual %s",
+                           CELLULAR_CONFIG_HL7802_CATM1_BAND, bandCfg.catm1BandCfg ) );
+                atReqGetNoResult.pAtCmd = "AT+KBNDCFG=0,"CELLULAR_CONFIG_HL7802_CATM1_BAND;
+                pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                       CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+                cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+            }
+        }
+
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            if( strcmp( bandCfg.nbiotBandCfg, CELLULAR_CONFIG_HL7802_NBIOT_BAND ) != 0 )
+            {
+                LogInfo( ( "Cellular_ModuleEnableUE : NBIOT band desired %s actual %s",
+                           CELLULAR_CONFIG_HL7802_NBIOT_BAND, bandCfg.nbiotBandCfg ) );
+                atReqGetNoResult.pAtCmd = "AT+KBNDCFG=1,"CELLULAR_CONFIG_HL7802_NBIOT_BAND;
+                pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                       CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+                cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+            }
+        }
+
+        /* Disable standalone sleep mode. */
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            atReqGetNoResult.pAtCmd = "AT+KSLEEP=2";
+            pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                   CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+            cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+        }
+
+        /* Force initialization of radio to consider new configured bands. */
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            atReqGetNoResult.pAtCmd = "AT+CFUN=1,1";
+            pktStatus = _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                                   CELLULAR_HL7802_AT_TIMEOUT_30_SECONDS_MS );
+            cellularStatus = _Cellular_TranslatePktStatus( pktStatus );
+        }
+
+        /* Disable echo after reboot device. */
+        if( cellularStatus == CELLULAR_SUCCESS )
+        {
+            Platform_Delay( CELLULAR_HL7802_RESET_DELAY_MS );
+            atReqGetWoPrefix.pAtCmd = "ATE0";
+            cellularStatus = sendAtCommandWithRetryTimeout( pContext, &atReqGetWoPrefix,
+                                                            CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+        }
+    }
+
+    return cellularStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_ModuleEnableUrc( CellularContext_t * pContext )
+{
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+    CellularAtReq_t atReqGetNoResult =
+    {
+        NULL,
+        CELLULAR_AT_NO_RESULT,
+        NULL,
+        NULL,
+        NULL,
+        0
+    };
+
+    atReqGetNoResult.pAtCmd = "AT+COPS=3,2";
+    ( void ) _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                        CELLULAR_HL7802_AT_TIMEOUT_120_SECONDS_MS );
+
+    atReqGetNoResult.pAtCmd = "AT+CREG=2";
+    ( void ) _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                        CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+
+    atReqGetNoResult.pAtCmd = "AT+CEREG=2";
+    ( void ) _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                        CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+
+    atReqGetNoResult.pAtCmd = "AT+CTZR=1";
+    ( void ) _Cellular_TimeoutAtcmdRequestWithCallback( pContext, atReqGetNoResult,
+                                                        CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS );
+
+    return cellularStatus;
+}
+
+/*-----------------------------------------------------------*/
+
+uint32_t _Cellular_GetSocketId( CellularContext_t * pContext,
+                                uint8_t sessionId )
+{
+    cellularModuleContext_t * pModuleContext = NULL;
+    uint32_t socketIndex = INVALID_SOCKET_INDEX;
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+
+    if( pContext != NULL )
+    {
+        cellularStatus = _Cellular_GetModuleContext( pContext, ( void ** ) &pModuleContext );
+    }
+    else
+    {
+        cellularStatus = CELLULAR_BAD_PARAMETER;
+    }
+
+    if( ( cellularStatus == CELLULAR_SUCCESS ) &&
+        ( sessionId >= MIN_TCP_SESSION_ID ) && ( sessionId <= MAX_TCP_SESSION_ID ) )
+    {
+        socketIndex = pModuleContext->pSessionMap[ sessionId ];
+    }
+
+    return socketIndex;
+}
+
+/*-----------------------------------------------------------*/
+
+uint32_t _Cellular_GetSessionId( CellularContext_t * pContext,
+                                 uint32_t socketIndex )
+{
+    cellularModuleContext_t * pModuleContext = NULL;
+    CellularError_t cellularStatus = CELLULAR_SUCCESS;
+    uint32_t sessionId = INVALID_SESSION_ID;
+
+    if( pContext == NULL )
+    {
+        LogError( ( "_Cellular_GetSessionId invalid cellular context" ) );
+        cellularStatus = CELLULAR_BAD_PARAMETER;
+    }
+    else if( socketIndex == INVALID_SOCKET_INDEX )
+    {
+        LogError( ( "_Cellular_GetSessionId invalid socketIndex" ) );
+        cellularStatus = CELLULAR_BAD_PARAMETER;
+    }
+    else
+    {
+        cellularStatus = _Cellular_GetModuleContext( pContext, ( void ** ) &pModuleContext );
+    }
+
+    if( cellularStatus == CELLULAR_SUCCESS )
+    {
+        for( sessionId = 0; sessionId < TCP_SESSION_TABLE_LEGNTH; sessionId++ )
+        {
+            if( pModuleContext->pSessionMap[ sessionId ] == socketIndex )
+            {
+                break;
+            }
+        }
+
+        /* Mapping is not found in the session mapping table. */
+        if( sessionId == TCP_SESSION_TABLE_LEGNTH )
+        {
+            sessionId = INVALID_SESSION_ID;
+        }
+    }
+    else
+    {
+        sessionId = INVALID_SESSION_ID;
+    }
+
+    return sessionId;
+}

kernel/FreeRTOS-Plus/Source/FreeRTOS-Cellular-Modules/hl7802/source/cellular_hl7802.h

@@ -0,0 +1,150 @@
+/*
+ * FreeRTOS-Cellular-Interface v1.3.0
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * 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.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ */
+
+#ifndef __CELLULAR_HL7802_H__
+#define __CELLULAR_HL7802_H__
+
+/* *INDENT-OFF* */
+#ifdef __cplusplus
+    extern "C" {
+#endif
+/* *INDENT-ON* */
+
+#define MIN_TCP_SESSION_ID          ( 1U )
+#define MAX_TCP_SESSION_ID          ( 6U )
+#define TCP_SESSION_TABLE_LEGNTH    ( MAX_TCP_SESSION_ID + 1 )
+
+#define INVALID_SOCKET_INDEX        ( UINT32_MAX )
+#define INVALID_SESSION_ID          ( UINT32_MAX )
+
+/* Delay after AT+CFUN=1,1 commands. */
+#ifndef CELLULAR_HL7802_RESET_DELAY_MS
+    #define CELLULAR_HL7802_RESET_DELAY_MS    ( 3000U )
+#endif
+
+/* AT command recommended timeout value for HL7802. Reference HL7802 AT Commands
+ * Interface Guide to setup the timeout value for each AT commands. */
+#define CELLULAR_HL7802_AT_TIMEOUT_2_SECONDS_MS      ( 2000U )
+#define CELLULAR_HL7802_AT_TIMEOUT_5_SECONDS_MS      ( 5000U )
+#define CELLULAR_HL7802_AT_TIMEOUT_30_SECONDS_MS     ( 30000U )
+#define CELLULAR_HL7802_AT_TIMEOUT_60_SECONDS_MS     ( 60000U )
+#define CELLULAR_HL7802_AT_TIMEOUT_120_SECONDS_MS    ( 120000U )
+
+/* Define the following timeout value since they are content dependent or no recommended value. */
+#ifndef CELLULAR_HL7802_AT_KSELACQ_TIMEOUT_MS
+    #define CELLULAR_HL7802_AT_KSELACQ_TIMEOUT_MS    CELLULAR_HL7802_AT_TIMEOUT_5_SECONDS_MS
+#endif
+
+#ifndef CELLULAR_HL7802_AT_KEDRXCFG_TIMEOUT_MS
+    #define CELLULAR_HL7802_AT_KEDRXCFG_TIMEOUT_MS    CELLULAR_HL7802_AT_TIMEOUT_5_SECONDS_MS
+#endif
+
+#ifndef CELLULAR_HL7802_AT_KCNXUP_TIMEOUT_MS
+    #define CELLULAR_HL7802_AT_KCNXUP_TIMEOUT_MS    CELLULAR_HL7802_AT_TIMEOUT_30_SECONDS_MS
+#endif
+
+#ifndef CELLULAR_HL7802_AT_KCNXDOWN_TIMEOUT_MS
+    #define CELLULAR_HL7802_AT_KCNXDOWN_TIMEOUT_MS    CELLULAR_HL7802_AT_TIMEOUT_30_SECONDS_MS
+#endif
+
+/* Band configuration for HL7802. */
+#ifndef CELLULAR_CONFIG_HL7802_CATM1_BAND
+    /* Default enable all bands. */
+    #define CELLULAR_CONFIG_HL7802_CATM1_BAND    "0002000000000F0F1B9F"
+#endif
+
+#ifndef CELLULAR_CONFIG_HL7802_NBIOT_BAND
+    /* Default enable all bands. */
+    #define CELLULAR_CONFIG_HL7802_NBIOT_BAND    "0002000000000B0F189F"
+#endif
+
+/*-----------------------------------------------------------*/
+
+typedef struct cellularModuleContext
+{
+    uint32_t pSessionMap[ TCP_SESSION_TABLE_LEGNTH ];
+} cellularModuleContext_t;
+
+typedef enum tcpSocketState
+{
+    TCP_SOCKET_STATE_NOT_DEFINED = 0,
+    TCP_SOCKET_STATE_DEFINED_BUT_NOT_USED = 1,
+    TCP_SOCKET_STATE_OPENING_AND_CONNECTING = 2,
+    TCP_SOCKET_STATE_CONNECTION_UP = 3,
+    TCP_SOCKET_STATE_CONNECTION_CLOSING = 4,
+    TCP_SOCKET_STATE_CLOSED = 5,
+    TCP_SOCKET_STATE_MAX
+} tcpSocketState_t;
+
+typedef enum tcpConnectionFailure
+{
+    TCP_NOTIF_OK = -1,
+    TCP_NOTIF_NETWORK_ERROR = 0,
+    TCP_NOTIF_NO_MORE_SOCKETS_AVAILABLE = 1,
+    TCP_NOTIF_MEMORY_PROBLEM = 2,
+    TCP_NOTIF_DNS_ERROR = 3,
+    TCP_NOTIF_TCP_DISCONNECTION = 4,
+    TCP_NOTIF_TCP_CONNECTION_ERROR = 5,
+    TCP_NOTIF_GENERIC_ERROR = 6,
+    TCP_NOTIF_FAIL_TO_ACCEPT_CLIENT_REQUEST = 7,
+    TCP_NOTIF_KTCPSND_WAITING_FOR_MORE_OR_LESS_CHARACTERS = 8,
+    TCP_NOTIF_BAD_SESSION_ID = 9,
+    TCP_NOTIF_SESSION_IS_ALREADY_RUNNING = 10,
+    TCP_NOTIF_ALL_SESSIONS_ARE_USED = 11,
+    TCP_NOTIF_SOCKET_CONNECTION_TIMEOUT_ERROR = 12,
+    TCP_NOTIF_SSL_CONNECTION_ERROR = 13,
+    TCP_NOTIF_SSL_INITIALIZATION_ERROR = 14,
+    TCP_NOTIF_MAX,
+} tcpConnectionFailure_t;
+
+/*-----------------------------------------------------------*/
+
+uint32_t _Cellular_GetSocketId( CellularContext_t * pContext,
+                                uint8_t sessionId );
+
+uint32_t _Cellular_GetSessionId( CellularContext_t * pContext,
+                                 uint32_t socketIndex );
+
+/*-----------------------------------------------------------*/
+
+extern CellularAtParseTokenMap_t CellularUrcHandlerTable[];
+extern uint32_t CellularUrcHandlerTableSize;
+
+extern const char * CellularSrcTokenErrorTable[];
+extern uint32_t CellularSrcTokenErrorTableSize;
+
+extern const char * CellularSrcTokenSuccessTable[];
+extern uint32_t CellularSrcTokenSuccessTableSize;
+
+extern const char * CellularUrcTokenWoPrefixTable[];
+extern uint32_t CellularUrcTokenWoPrefixTableSize;
+
+/* *INDENT-OFF* */
+#ifdef __cplusplus
+    }
+#endif
+/* *INDENT-ON* */
+
+#endif /* ifndef __CELLULAR_HL7802_H__ */

kernel/FreeRTOS-Plus/Source/FreeRTOS-Cellular-Modules/hl7802/source/cellular_hl7802_urc_handler.c

@@ -0,0 +1,349 @@
+/*
+ * FreeRTOS-Cellular-Interface v1.3.0
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * 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.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ */
+
+#include "cellular_config.h"
+#include "cellular_config_defaults.h"
+
+/* Standard includes. */
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "cellular_types.h"
+#include "cellular_common.h"
+#include "cellular_common_api.h"
+#include "cellular_common_portable.h"
+
+/* Cellular module includes. */
+#include "cellular_hl7802.h"
+
+/*-----------------------------------------------------------*/
+
+static void _cellular_UrcProcessKtcpInd( CellularContext_t * pContext,
+                                         char * pInputLine );
+static void handleTcpNotif( CellularSocketContext_t * pSocketData,
+                            uint8_t tcpNotif,
+                            uint32_t sessionId );
+static void _cellular_UrcProcessKtcpNotif( CellularContext_t * pContext,
+                                           char * pInputLine );
+static void _cellular_UrcProcessKtcpData( CellularContext_t * pContext,
+                                          char * pInputLine );
+
+/*-----------------------------------------------------------*/
+
+/* Try to Keep this map in Alphabetical order. */
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularAtParseTokenMap_t CellularUrcHandlerTable[] =
+{
+    { "CEREG",      Cellular_CommonUrcProcessCereg },
+    { "CREG",       Cellular_CommonUrcProcessCreg  },
+    { "KTCP_DATA",  _cellular_UrcProcessKtcpData   },         /* TCP data URC. */
+    { "KTCP_IND",   _cellular_UrcProcessKtcpInd    },         /* TCP status URC. */
+    { "KTCP_NOTIF", _cellular_UrcProcessKtcpNotif  }          /* TCP connection failure. */
+};
+
+/* FreeRTOS Cellular Common Library porting interface. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+uint32_t CellularUrcHandlerTableSize = sizeof( CellularUrcHandlerTable ) / sizeof( CellularAtParseTokenMap_t );
+
+/*-----------------------------------------------------------*/
+
+static void _cellular_UrcProcessKtcpInd( CellularContext_t * pContext,
+                                         char * pInputLine )
+{
+    CellularATError_t atCoreStatus = CELLULAR_AT_SUCCESS;
+    char * pLocalInputLine = pInputLine;
+    char * pToken = NULL;
+    CellularSocketContext_t * pSocketData = NULL;
+    uint8_t sessionId = 0;
+    uint32_t socketIndex = 0;
+    int32_t tempValue = 0;
+
+    if( ( pContext != NULL ) && ( pInputLine != NULL ) )
+    {
+        /* The inputline is in this format +KTCP_IND: <session_id>, 1
+         * This URC indicate connection success. */
+        atCoreStatus = Cellular_ATGetNextTok( &pLocalInputLine, &pToken );
+
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            atCoreStatus = Cellular_ATStrtoi( pToken, 10, &tempValue );
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                if( ( tempValue >= MIN_TCP_SESSION_ID ) && ( tempValue <= MAX_TCP_SESSION_ID ) )
+                {
+                    sessionId = ( uint8_t ) tempValue;
+                    socketIndex = _Cellular_GetSocketId( pContext, sessionId );
+                }
+                else
+                {
+                    LogError( ( "error parsing _cellular_UrcProcessKtcpInd session ID" ) );
+                    atCoreStatus = CELLULAR_AT_ERROR;
+                }
+            }
+        }
+
+        /* Call the callback function of this session. */
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            if( socketIndex == INVALID_SOCKET_INDEX )
+            {
+                LogWarn( ( "_cellular_UrcProcessKtcpInd : unknown session data received. "
+                           "The session %u may not be closed properly in previous execution.", sessionId ) );
+            }
+            else
+            {
+                pSocketData = _Cellular_GetSocketData( pContext, socketIndex );
+
+                if( pSocketData == NULL )
+                {
+                    LogError( ( "_cellular_UrcProcessKtcpInd : invalid socket index %u", socketIndex ) );
+                }
+                else if( pSocketData->openCallback == NULL )
+                {
+                    LogDebug( ( "_cellular_UrcProcessKtcpInd : Open callback not set!!" ) );
+                }
+                else
+                {
+                    LogDebug( ( "Notify session %d with socket opened\r\n", sessionId ) );
+                    pSocketData->socketState = SOCKETSTATE_CONNECTED;
+                    pSocketData->openCallback( CELLULAR_URC_SOCKET_OPENED,
+                                               pSocketData, pSocketData->pOpenCallbackContext );
+                }
+            }
+        }
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+static void handleTcpNotif( CellularSocketContext_t * pSocketData,
+                            uint8_t tcpNotif,
+                            uint32_t sessionId )
+{
+    /* Suppress warning message if log level is not debug. */
+    ( void ) sessionId;
+
+    switch( tcpNotif )
+    {
+        case TCP_NOTIF_TCP_DISCONNECTION: /* TCP disconnection by the server or remote client. */
+
+            pSocketData->socketState = SOCKETSTATE_DISCONNECTED;
+
+            if( pSocketData->closedCallback != NULL )
+            {
+                LogDebug( ( "Notify session %d with socket disconnected\r\n", sessionId ) );
+                pSocketData->closedCallback( pSocketData, pSocketData->pClosedCallbackContext );
+            }
+
+            break;
+
+        case TCP_NOTIF_TCP_CONNECTION_ERROR: /* TCP connection error. */
+
+            pSocketData->socketState = SOCKETSTATE_DISCONNECTED;
+
+            if( pSocketData->openCallback != NULL )
+            {
+                LogDebug( ( "Notify session %d with socket open failed\r\n", sessionId ) );
+                pSocketData->openCallback( CELLULAR_URC_SOCKET_OPEN_FAILED,
+                                           pSocketData, pSocketData->pOpenCallbackContext );
+            }
+
+            break;
+
+        default:
+            break;
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+static void _cellular_UrcProcessKtcpNotif( CellularContext_t * pContext,
+                                           char * pInputLine )
+{
+    CellularATError_t atCoreStatus = CELLULAR_AT_SUCCESS;
+    char * pLocalInputLine = pInputLine;
+    char * pToken = NULL;
+    CellularSocketContext_t * pSocketData = NULL;
+    uint8_t sessionId = 0;
+    tcpConnectionFailure_t tcpNotif = TCP_NOTIF_OK;
+    uint32_t socketIndex = 0;
+    int32_t tempValue = 0;
+
+    if( ( pContext != NULL ) && ( pInputLine != NULL ) )
+    {
+        /* The inputline is in this format +KTCP_NOTIF: <session_id>, <tcp_notif>
+         * This URC indicate connection problem. */
+
+        /* Remove leading space. */
+        atCoreStatus = Cellular_ATRemoveLeadingWhiteSpaces( &pLocalInputLine );
+
+        /* Parse the session ID. */
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            atCoreStatus = Cellular_ATGetNextTok( &pLocalInputLine, &pToken );
+        }
+
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            atCoreStatus = Cellular_ATStrtoi( pToken, 10, &tempValue );
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                if( ( tempValue >= MIN_TCP_SESSION_ID ) && ( tempValue <= MAX_TCP_SESSION_ID ) )
+                {
+                    sessionId = ( uint8_t ) tempValue;
+                    socketIndex = _Cellular_GetSocketId( pContext, sessionId );
+                }
+                else
+                {
+                    LogError( ( "error parsing _cellular_UrcProcessKtcpInd session ID" ) );
+                    atCoreStatus = CELLULAR_AT_ERROR;
+                }
+            }
+        }
+
+        /* Parse the tcp notif. */
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            atCoreStatus = Cellular_ATGetNextTok( &pLocalInputLine, &pToken );
+        }
+
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            atCoreStatus = Cellular_ATStrtoi( pToken, 10, &tempValue );
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                if( ( tempValue >= TCP_NOTIF_OK ) && ( tempValue <= TCP_NOTIF_MAX ) )
+                {
+                    tcpNotif = ( tcpConnectionFailure_t ) tempValue;
+                }
+                else
+                {
+                    LogError( ( "error parsing _cellular_UrcProcessKtcpInd session ID" ) );
+                    atCoreStatus = CELLULAR_AT_ERROR;
+                }
+            }
+        }
+
+        /* Call the callback function of this session. */
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            if( socketIndex == INVALID_SOCKET_INDEX )
+            {
+                LogWarn( ( "_cellular_UrcProcessKtcpNotif : unknown session data received. "
+                           "The session %u may not be closed properly in previous execution.", sessionId ) );
+            }
+            else
+            {
+                pSocketData = _Cellular_GetSocketData( pContext, socketIndex );
+
+                if( pSocketData == NULL )
+                {
+                    LogError( ( "_cellular_UrcProcessKtcpNotif : invalid socket index %u", socketIndex ) );
+                }
+                else
+                {
+                    handleTcpNotif( pSocketData, tcpNotif, sessionId );
+                }
+            }
+        }
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+static void _cellular_UrcProcessKtcpData( CellularContext_t * pContext,
+                                          char * pInputLine )
+{
+    CellularATError_t atCoreStatus = CELLULAR_AT_SUCCESS;
+    char * pLocalInputLine = pInputLine;
+    char * pToken = NULL;
+    CellularSocketContext_t * pSocketData = NULL;
+    uint8_t sessionId = 0;
+    uint32_t socketIndex = 0;
+    int32_t tempValue = 0;
+
+    if( ( pContext != NULL ) && ( pInputLine != NULL ) )
+    {
+        /* The inputline is in this format +KTCP_DATA: <session_id>, <bytes_received>
+         * This URC indicate connection problem. */
+
+        /* parse the session ID. */
+        atCoreStatus = Cellular_ATGetNextTok( &pLocalInputLine, &pToken );
+
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            atCoreStatus = Cellular_ATStrtoi( pToken, 10, &tempValue );
+
+            if( atCoreStatus == CELLULAR_AT_SUCCESS )
+            {
+                if( ( tempValue >= MIN_TCP_SESSION_ID ) && ( tempValue <= MAX_TCP_SESSION_ID ) )
+                {
+                    sessionId = ( uint8_t ) tempValue;
+                    socketIndex = _Cellular_GetSocketId( pContext, sessionId );
+                }
+                else
+                {
+                    LogError( ( "error parsing _cellular_UrcProcessKtcpData session ID" ) );
+                    atCoreStatus = CELLULAR_AT_ERROR;
+                }
+            }
+        }
+
+        /* Indicate the upper layer about the data reception. */
+        /* Call the callback function of this session. */
+        if( atCoreStatus == CELLULAR_AT_SUCCESS )
+        {
+            if( socketIndex == INVALID_SOCKET_INDEX )
+            {
+                LogWarn( ( "_cellular_UrcProcessKtcpData : unknown session data received. "
+                           "The session %u may not be closed properly in previous execution.", sessionId ) );
+            }
+            else
+            {
+                pSocketData = _Cellular_GetSocketData( pContext, socketIndex );
+
+                if( pSocketData == NULL )
+                {
+                    LogError( ( "_cellular_UrcProcessKtcpData : invalid socket index %u", socketIndex ) );
+                }
+                else if( pSocketData->dataReadyCallback == NULL )
+                {
+                    LogDebug( ( "_cellular_UrcProcessKtcpData : Data ready callback not set!!" ) );
+                }
+                else
+                {
+                    pSocketData->dataReadyCallback( pSocketData, pSocketData->pDataReadyCallbackContext );
+                }
+            }
+        }
+    }
+}
+
+/*-----------------------------------------------------------*/

kernel/FreeRTOS-Plus/Source/FreeRTOS-Cellular-Modules/hl7802/source/cellular_hl7802_wrapper.c

@@ -0,0 +1,269 @@
+/*
+ * FreeRTOS-Cellular-Interface v1.3.0
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * 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.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ */
+
+/* The config header is always included first. */
+#include "cellular_config.h"
+#include "cellular_config_defaults.h"
+
+/* Standard includes. */
+#include <stdio.h>
+#include <string.h>
+
+#include "cellular_platform.h"
+#include "cellular_types.h"
+#include "cellular_api.h"
+#include "cellular_common.h"
+#include "cellular_common_api.h"
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_Cleanup( CellularHandle_t cellularHandle )
+{
+    return Cellular_CommonCleanup( cellularHandle );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_RegisterUrcNetworkRegistrationEventCallback( CellularHandle_t cellularHandle,
+                                                                      CellularUrcNetworkRegistrationCallback_t networkRegistrationCallback,
+                                                                      void * pCallbackContext )
+{
+    return Cellular_CommonRegisterUrcNetworkRegistrationEventCallback( cellularHandle, networkRegistrationCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_RegisterUrcPdnEventCallback( CellularHandle_t cellularHandle,
+                                                      CellularUrcPdnEventCallback_t pdnEventCallback,
+                                                      void * pCallbackContext )
+{
+    return Cellular_CommonRegisterUrcPdnEventCallback( cellularHandle, pdnEventCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_RegisterUrcGenericCallback( CellularHandle_t cellularHandle,
+                                                     CellularUrcGenericCallback_t genericCallback,
+                                                     void * pCallbackContext )
+{
+    return Cellular_CommonRegisterUrcGenericCallback( cellularHandle, genericCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_RegisterModemEventCallback( CellularHandle_t cellularHandle,
+                                                     CellularModemEventCallback_t modemEventCallback,
+                                                     void * pCallbackContext )
+{
+    return Cellular_CommonRegisterModemEventCallback( cellularHandle, modemEventCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_ATCommandRaw( CellularHandle_t cellularHandle,
+                                       const char * pATCommandPrefix,
+                                       const char * pATCommandPayload,
+                                       CellularATCommandType_t atCommandType,
+                                       CellularATCommandResponseReceivedCallback_t responseReceivedCallback,
+                                       void * pData,
+                                       uint16_t dataLen )
+{
+    return Cellular_CommonATCommandRaw( cellularHandle, pATCommandPrefix, pATCommandPayload, atCommandType,
+                                        responseReceivedCallback, pData, dataLen );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_CreateSocket( CellularHandle_t cellularHandle,
+                                       uint8_t pdnContextId,
+                                       CellularSocketDomain_t socketDomain,
+                                       CellularSocketType_t socketType,
+                                       CellularSocketProtocol_t socketProtocol,
+                                       CellularSocketHandle_t * pSocketHandle )
+{
+    return Cellular_CommonCreateSocket( cellularHandle, pdnContextId, socketDomain, socketType,
+                                        socketProtocol, pSocketHandle );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_SocketSetSockOpt( CellularHandle_t cellularHandle,
+                                           CellularSocketHandle_t socketHandle,
+                                           CellularSocketOptionLevel_t optionLevel,
+                                           CellularSocketOption_t option,
+                                           const uint8_t * pOptionValue,
+                                           uint32_t optionValueLength )
+{
+    return Cellular_CommonSocketSetSockOpt( cellularHandle, socketHandle, optionLevel, option,
+                                            pOptionValue, optionValueLength );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_SocketRegisterDataReadyCallback( CellularHandle_t cellularHandle,
+                                                          CellularSocketHandle_t socketHandle,
+                                                          CellularSocketDataReadyCallback_t dataReadyCallback,
+                                                          void * pCallbackContext )
+{
+    return Cellular_CommonSocketRegisterDataReadyCallback( cellularHandle, socketHandle,
+                                                           dataReadyCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_SocketRegisterSocketOpenCallback( CellularHandle_t cellularHandle,
+                                                           CellularSocketHandle_t socketHandle,
+                                                           CellularSocketOpenCallback_t socketOpenCallback,
+                                                           void * pCallbackContext )
+{
+    return Cellular_CommonSocketRegisterSocketOpenCallback( cellularHandle, socketHandle,
+                                                            socketOpenCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_SocketRegisterClosedCallback( CellularHandle_t cellularHandle,
+                                                       CellularSocketHandle_t socketHandle,
+                                                       CellularSocketClosedCallback_t closedCallback,
+                                                       void * pCallbackContext )
+{
+    return Cellular_CommonSocketRegisterClosedCallback( cellularHandle, socketHandle,
+                                                        closedCallback, pCallbackContext );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_RfOn( CellularHandle_t cellularHandle )
+{
+    return Cellular_CommonRfOn( cellularHandle );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_RfOff( CellularHandle_t cellularHandle )
+{
+    return Cellular_CommonRfOff( cellularHandle );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetIPAddress( CellularHandle_t cellularHandle,
+                                       uint8_t contextId,
+                                       char * pBuffer,
+                                       uint32_t bufferLength )
+{
+    return Cellular_CommonGetIPAddress( cellularHandle, contextId, pBuffer, bufferLength );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetModemInfo( CellularHandle_t cellularHandle,
+                                       CellularModemInfo_t * pModemInfo )
+{
+    return Cellular_CommonGetModemInfo( cellularHandle, pModemInfo );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetRegisteredNetwork( CellularHandle_t cellularHandle,
+                                               CellularPlmnInfo_t * pNetworkInfo )
+{
+    return Cellular_CommonGetRegisteredNetwork( cellularHandle, pNetworkInfo );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetNetworkTime( CellularHandle_t cellularHandle,
+                                         CellularTime_t * pNetworkTime )
+{
+    return Cellular_CommonGetNetworkTime( cellularHandle, pNetworkTime );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetServiceStatus( CellularHandle_t cellularHandle,
+                                           CellularServiceStatus_t * pServiceStatus )
+{
+    return Cellular_CommonGetServiceStatus( cellularHandle, pServiceStatus );
+}
+
+/*-----------------------------------------------------------*/
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetSimCardInfo( CellularHandle_t cellularHandle,
+                                         CellularSimCardInfo_t * pSimCardInfo )
+{
+    return Cellular_CommonGetSimCardInfo( cellularHandle, pSimCardInfo );
+}
+
+/*-----------------------------------------------------------*/
+
+
+/* FreeRTOS Cellular Library API. */
+/* coverity[misra_c_2012_rule_8_7_violation] */
+CellularError_t Cellular_GetPsmSettings( CellularHandle_t cellularHandle,
+                                         CellularPsmSettings_t * pPsmSettings )
+{
+    return Cellular_CommonGetPsmSettings( cellularHandle, pPsmSettings );
+}
+
+/*-----------------------------------------------------------*/