src: unicens: import sources

This patch adds the source tree of the NetworkManager v3.0.4.
Additionally, it provides the needed configuration scripts.

Change-Id: I23778b51423b51a4f87741957e0fb208bceb79b3
Signed-off-by: Christian Gromm <christian.gromm@microchip.com>

1 files changed, 435 insertions, 0 deletions

diff --git a/mnsl/mnsl.c b/mnsl/mnsl.c
new file mode 100644
index 0000000..2b59746
--- /dev/null
+++ b/mnsl/mnsl.c
@@ -0,0 +1,435 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 Microchip Technology Germany II GmbH & Co. KG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You may also obtain this software under a propriety license from Microchip.
+ * Please contact Microchip for further information.
+ *
+ */
+
+/* parasoft suppress item * reason "not part of MOST NetServices delivery" */
+
+/*!
+ * \file
+ * \brief Implementation of MOST NetServices Light
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+#include "mnsl.h"
+#include "mns_base.h"
+#include "mns_misc.h"
+#include "mns_pmchannel.h"
+#include "mns_ams.h"
+#include "mns_transceiver.h"
+#include "mns_pmfifos.h"
+
+#include <assert.h> //TKU
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Mnsl_OnPmsEvent(void *self, void *event_code);
+static void Mnsl_OnServiceRequest(void *self, void *data_ptr);
+static void Mnsl_OnGetTickCount(void *self, void *tick_count_value_ptr);
+static void Mnsl_OnSetApplicationTimer(void *self, void *new_time_value_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CMnsl                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Assigns default values to a provided MNSL init structure
+ *  \param   init_ptr         Reference to MNSL init structure.
+ *  \param   enable_watchdog  Set to \c true for normal use. Set to \c false to disable the watchdog 
+ *                            supervision for debugging purpose only.
+ */
+extern void Mnsl_SetDefaultConfig(Mnsl_InitData_t *init_ptr, bool enable_watchdog)
+{
+    MISC_MEM_SET(init_ptr, 0, sizeof(Mnsl_InitData_t));
+
+    init_ptr->pms.active_fifos = MNSL_FIFOS_MCM_ICM;
+    init_ptr->pms.compressed = false;
+    
+    init_ptr->pms.icm_config.fifo_id = PMP_FIFO_ID_ICM;
+    init_ptr->pms.icm_config.tx_wd_timeout = 0U;
+    init_ptr->pms.icm_config.tx_wd_timer_value = 0U;
+    init_ptr->pms.icm_config.rx_ack_timeout = 10U;
+    init_ptr->pms.icm_config.rx_busy_allowed = 0xFU;
+    init_ptr->pms.icm_config.rx_credits = PMCH_FIFO_CREDITS;
+    init_ptr->pms.icm_config.rx_threshold = PMCH_FIFO_THRESHOLD;
+
+    init_ptr->pms.rcm_config.fifo_id = PMP_FIFO_ID_RCM;
+    init_ptr->pms.rcm_config.tx_wd_timeout = 10U;       /* watchdog timeout: 1s */
+    init_ptr->pms.rcm_config.tx_wd_timer_value = 600U;  /* watchdog trigger every 600 ms */
+    init_ptr->pms.rcm_config.rx_ack_timeout = 10U;
+    init_ptr->pms.rcm_config.rx_busy_allowed = 0xFU;
+    init_ptr->pms.rcm_config.rx_credits = PMCH_FIFO_CREDITS;
+    init_ptr->pms.rcm_config.rx_threshold = PMCH_FIFO_THRESHOLD;
+
+    init_ptr->pms.mcm_config.fifo_id = PMP_FIFO_ID_MCM;
+    init_ptr->pms.mcm_config.tx_wd_timeout = 10U;       /* watchdog timeout: 1s */
+    init_ptr->pms.mcm_config.tx_wd_timer_value = 600U;  /* watchdog trigger every 600 ms */
+    init_ptr->pms.mcm_config.rx_ack_timeout = 10U;
+    init_ptr->pms.mcm_config.rx_busy_allowed = 0xFU;
+    init_ptr->pms.mcm_config.rx_credits = PMCH_MCM_CREDITS;
+    init_ptr->pms.mcm_config.rx_threshold = PMCH_MCM_THRESHOLD;
+                                                          
+    if (enable_watchdog == false)
+    {
+        init_ptr->pms.icm_config.rx_ack_timeout = 0U;   /* acknowledge timeout: 0 -> infinite */
+        init_ptr->pms.rcm_config.tx_wd_timeout = 0U;    /* watchdog timeout:    0 -> infinite */
+        init_ptr->pms.rcm_config.tx_wd_timer_value = 0U;/* watchdog timer:      0 -> no timer */
+        init_ptr->pms.rcm_config.rx_ack_timeout = 0U;   /* acknowledge timeout: 0 -> infinite */
+        init_ptr->pms.mcm_config.tx_wd_timeout = 0U;    /* watchdog timeout:    0 -> infinite */
+        init_ptr->pms.mcm_config.tx_wd_timer_value = 0U;/* watchdog timer:      0 -> no timer */
+        init_ptr->pms.mcm_config.rx_ack_timeout = 0U;   /* acknowledge timeout: 0 -> infinite */
+    }
+}
+
+/*! \brief  Initialize MNS Light class
+ *  \param  init_ptr    Reference to the MNSL init structure.
+ *                      The memory of the init structure can be freed after the function returns.
+ */
+void Mnsl_Init(CMnsl *mnsl, Mnsl_InitData_t *init_ptr, void *inst_ptr)
+{
+    assert(NULL != mnsl);
+    CSingleObserver *srv_request_obs_ptr = NULL;
+    CSingleObserver *app_timer_obs_ptr = NULL;
+    Base_InitData_t base_init_data;
+    Pmch_InitData_t pmch_init_data;
+    CPmFifo *icm_ptr = NULL;
+    CPmFifo *rcm_ptr = NULL;
+    CPmFifo *mcm_ptr = NULL;
+    CTransceiver *trcv_mcm_ptr = NULL;
+    CTransceiver *trcv_rcm_ptr = NULL;
+
+    MISC_MEM_SET(mnsl, 0, sizeof(mnsl));
+    MISC_MEM_SET(&base_init_data, 0, sizeof(base_init_data));
+
+    mnsl->inst_ptr = inst_ptr; //TKU
+    mnsl->inst_id = 1U;
+    mnsl->get_tick_count_fptr = init_ptr->general.get_tickcount_fptr;
+    mnsl->srv_request_fptr = init_ptr->general.request_service_fptr;
+    mnsl->set_app_timer_fptr = init_ptr->general.set_app_timer_fptr;
+
+    if(mnsl->srv_request_fptr != NULL)
+    {
+        Sobs_Ctor(&mnsl->srv_request_obs, mnsl, &Mnsl_OnServiceRequest);
+        srv_request_obs_ptr = &mnsl->srv_request_obs;
+    }
+    if (mnsl->set_app_timer_fptr != NULL)
+    {
+        Sobs_Ctor(&mnsl->set_app_timer_obs, mnsl, &Mnsl_OnSetApplicationTimer);
+        app_timer_obs_ptr = &mnsl->set_app_timer_obs;
+    }
+
+    base_init_data.mns_inst_id = 1U;
+    base_init_data.tm.mns_inst_id = 1U;
+    base_init_data.scd.mns_inst_id = 1U;
+
+    Sobs_Ctor(&mnsl->get_tick_count_obs, mnsl, &Mnsl_OnGetTickCount);
+    base_init_data.tm.get_tick_count_obs_ptr = &mnsl->get_tick_count_obs;
+    base_init_data.scd.service_request_obs_ptr = srv_request_obs_ptr;
+    base_init_data.tm.set_application_timer_obs_ptr = app_timer_obs_ptr;
+
+    Base_Ctor(&mnsl->base, &base_init_data);
+    
+    /* Initialize port message service */
+    pmch_init_data.mns_inst_id = 1U;
+    pmch_init_data.tx_release_fptr = &Fifo_TxOnRelease;
+    pmch_init_data.lld_iface = init_ptr->lld;
+    Pmch_Ctor(&mnsl->pm_channel, &pmch_init_data, inst_ptr);
+
+    if((init_ptr->pms.active_fifos & MNSL_FIFOS_ICM) == MNSL_FIFOS_ICM)
+    {
+        Fifo_InitData_t icm_init;
+
+        icm_init.base_ptr = &mnsl->base;
+        icm_init.channel_ptr = &mnsl->pm_channel;
+        icm_init.rx_cb_fptr = &Trcv_RxOnMsgComplete;
+        icm_init.rx_cb_inst = &mnsl->icm_transceiver;
+
+        if (init_ptr->pms.compressed)
+        {
+            icm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_80);
+            icm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_80);
+        }
+        else
+        {
+            icm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+            icm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        }
+
+        Fifo_Ctor(&mnsl->icm_fifo, &icm_init, &init_ptr->pms.icm_config);
+        Trcv_Ctor(&mnsl->icm_transceiver, &mnsl->icm_fifo, MSG_ADDR_EHC_CFG, base_init_data.mns_inst_id, PMP_FIFO_ID_ICM);/* initialize ICM transceiver and set link to PMS instance */
+
+        icm_ptr = &mnsl->icm_fifo;
+    }
+
+    if((init_ptr->pms.active_fifos & MNSL_FIFOS_RCM) == MNSL_FIFOS_RCM)
+        {
+        Fifo_InitData_t rcm_init;
+
+        rcm_init.base_ptr = &mnsl->base;
+        rcm_init.channel_ptr = &mnsl->pm_channel;
+        rcm_init.rx_cb_fptr = &Trcv_RxOnMsgComplete;
+        rcm_init.rx_cb_inst = &mnsl->rcm_transceiver;
+        rcm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        rcm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        /* Note: RCM compressed data format is not supported */
+
+        Fifo_Ctor(&mnsl->rcm_fifo, &rcm_init, &init_ptr->pms.rcm_config);
+        Trcv_Ctor(&mnsl->rcm_transceiver, &mnsl->rcm_fifo, MSG_ADDR_EHC_CFG, base_init_data.mns_inst_id, PMP_FIFO_ID_RCM);/* initialize ICM transceiver and set link to PMS instance */
+
+        rcm_ptr = &mnsl->rcm_fifo;
+        trcv_rcm_ptr = &mnsl->rcm_transceiver;
+    }
+
+    if((init_ptr->pms.active_fifos & MNSL_FIFOS_MCM) == MNSL_FIFOS_MCM)
+    {
+        Fifo_InitData_t mcm_init;
+
+        mcm_init.base_ptr = &mnsl->base;
+        mcm_init.channel_ptr = &mnsl->pm_channel;
+        mcm_init.rx_cb_fptr = &Trcv_RxOnMsgComplete;
+        mcm_init.rx_cb_inst = &mnsl->mcm_transceiver;
+
+        if (init_ptr->pms.compressed)
+        {
+            mcm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_81);
+            mcm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_80);
+        }
+        else
+        {
+            mcm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+            mcm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        }
+
+        Fifo_Ctor(&mnsl->mcm_fifo, &mcm_init, &init_ptr->pms.mcm_config);
+        Trcv_Ctor(&mnsl->mcm_transceiver, &mnsl->mcm_fifo, MSG_ADDR_EHC_APP, base_init_data.mns_inst_id, PMP_FIFO_ID_MCM);/* initialize ICM transceiver and set link to PMS instance */
+
+        mcm_ptr = &mnsl->mcm_fifo;
+        trcv_mcm_ptr = &mnsl->mcm_transceiver;
+        }
+
+    if ((trcv_mcm_ptr != NULL) || (trcv_rcm_ptr != NULL))       /* initialize AMS if MCM or RCM is active */
+    {
+        mnsl->ams_allocator.alloc_fptr = init_ptr->ams.rx_alloc_mem_fptr;
+        mnsl->ams_allocator.free_fptr = init_ptr->ams.rx_free_mem_fptr;
+        Amsp_Ctor(&mnsl->ams_pool, &mnsl->ams_allocator, mnsl->base.mns_inst_id);
+        Ams_Ctor(&mnsl->ams, &mnsl->base, trcv_mcm_ptr, trcv_rcm_ptr, &mnsl->ams_pool, AMS_RX_DEF_SIZE_PAYLOAD);
+    }
+
+    /* initialize FIFO handler */
+    Fifos_Ctor(&mnsl->fifos, &mnsl->base, &mnsl->pm_channel, icm_ptr, mcm_ptr, rcm_ptr);
+
+    /* register event callback */
+    mnsl->event_fptr = init_ptr->general.event_fptr;
+    Obs_Ctor(&mnsl->pms_observer, mnsl, &Mnsl_OnPmsEvent);
+    Fifos_AddEventObserver(&mnsl->fifos, &mnsl->pms_observer);
+}
+
+/*! \brief   Synchronizes the PMS
+ *  \details Accordingly MNSL_EVENT_SYNC_COMPLETE or MNSL_EVENT_SYNC_FAILED will be notified.
+ */
+void Mnsl_Synchronize(CMnsl *mnsl)
+{
+    assert(NULL != mnsl);
+    /* initializes the port message service & LLD interface  */
+    Fifos_ConfigureSyncParams(&mnsl->fifos, FIFOS_SYNC_RETRIES, FIFOS_SYNC_TIMEOUT);
+    Fifos_Synchronize(&mnsl->fifos, true, true);
+}
+
+/*! \brief   Un-synchronizes the PMS
+ *  \details Accordingly MNSL_EVENT_UNSYNC_COMPLETE or MNSL_EVENT_UNSYNC_FAILED will be notified.
+ *           Calling this function if MNSL is already un-synced will report MNSL_EVENT_UNSYNC_FAILED,
+ *           since the low-level driver interface is not active.
+ *  \param   initial    MNSL is able to trigger un-synchronization in advance of the initial
+ *                      synchronization. In this case, timeouts and retries behave like a synchronization
+ *                      and on MNSL_EVENT_UNSYNC_COMPLETE the LLD interface will stay running.
+ *                      I.e. if set to \c true the un-synchronization behaves like MNS initial un-synchronization.
+ *                      If set to \c false, the un-synchronization behaves like MNS final un-synchronization.
+ */
+void Mnsl_Unsynchronize(CMnsl *mnsl, bool initial)
+{    
+    assert(NULL != mnsl);
+    if (initial == false)
+    {
+        Fifos_ConfigureSyncParams(&mnsl->fifos, FIFOS_UNSYNC_RETRIES, FIFOS_UNSYNC_TIMEOUT); /* final sync */
+    }
+    else
+    {
+        Fifos_ConfigureSyncParams(&mnsl->fifos, FIFOS_SYNC_RETRIES, FIFOS_SYNC_TIMEOUT); /* initial sync */
+    }
+    
+    Fifos_Unsynchronize(&mnsl->fifos, true, initial);
+}
+
+/*! \brief  Handles PMS event and notifies MNSL registered event callback
+ *  \param  self         Reference to instance
+ *  \param  event_code  Event notified by the PMS
+ */
+static void Mnsl_OnPmsEvent(void *self, void *event_code)
+{
+    assert(NULL != self);
+    Fifos_Event_t *code = (Fifos_Event_t*)event_code;
+    CMnsl *mnsl = (CMnsl *)self;    
+
+    if (mnsl->event_fptr != NULL)
+    {
+        switch (*code)
+        {
+            case FIFOS_EV_SYNC_LOST:
+                Eh_ReportEvent(&mnsl->base.eh, EH_E_SYNC_LOST);        /* event is necessary for AMS cleanup */
+                mnsl->event_fptr(MNSL_EVENT_SYNC_LOST, mnsl->inst_ptr);
+                break;
+            case FIFOS_EV_SYNC_ESTABLISHED:
+                mnsl->event_fptr(MNSL_EVENT_SYNC_COMPLETE, mnsl->inst_ptr);
+                break;
+            case FIFOS_EV_SYNC_FAILED:
+                mnsl->event_fptr(MNSL_EVENT_SYNC_FAILED, mnsl->inst_ptr);
+                break;
+            case FIFOS_EV_UNSYNC_COMPLETE:
+                mnsl->event_fptr(MNSL_EVENT_UNSYNC_COMPLETE, mnsl->inst_ptr);
+                Eh_ReportEvent(&mnsl->base.eh, EH_E_UNSYNC_COMPLETE);   /* event is necessary for AMS cleanup */
+                break;
+            case FIFOS_EV_UNSYNC_FAILED:
+                mnsl->event_fptr(MNSL_EVENT_UNSYNC_FAILED, mnsl->inst_ptr);
+                Eh_ReportEvent(&mnsl->base.eh, EH_E_UNSYNC_FAILED);    /* event is necessary for AMS cleanup */
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+/*! \brief  Service function of MNS Light
+ */
+void Mnsl_Service(CMnsl *mnsl)
+{
+    assert(NULL != mnsl);
+    bool pending_events;
+
+    TR_INFO((mnsl->inst_id, "[API]", "Mnsl_Service()", 0U));
+    Scd_Service(&mnsl->base.scd);                                                        /* Run the scheduler */
+    pending_events = Scd_AreEventsPending(&mnsl->base.scd);                              /* Check if events are still pending? */
+
+    if (pending_events != false)                                                        /* At least one event is pending? */
+    {
+        TR_INFO((mnsl->inst_id, "[API]", "Mnsl_Service(): events still pending", 0U));
+        Mnsl_OnServiceRequest(mnsl, NULL);
+    }
+    else                                                                                /* No event is pending */
+    {
+        TR_INFO((mnsl->inst_id, "[API]", "Mnsl_Service(): calling Tm_CheckForNextService()", 0U));
+        mnsl->base.scd.scd_srv_is_running = true;                                        /* prevent continuous service requests if no app timer is provided */
+        Tm_CheckForNextService(&mnsl->base.tm);                                          /* If MNS timers are running: What is the next time that the timer management must be */
+        mnsl->base.scd.scd_srv_is_running = false;                                       /* serviced again? */
+    }
+}
+
+/*! \brief  Reports that the application provided timer has expired.
+ */
+void Mnsl_ReportTimeout(CMnsl *mnsl)
+{
+    assert(NULL != mnsl);
+    TR_INFO((mnsl->inst_id, "[API]", "Mns_ReportTimeout()", 0U));
+    Tm_TriggerService(&mnsl->base.tm);  /* Trigger TM service call */
+}
+
+/*! \brief  Callback function which is invoked by the scheduler
+ *  \param self                     Parameter not used with single instance API
+ *  \param data_ptr                 Currently unused
+ */
+static void Mnsl_OnServiceRequest(void *self, void *data_ptr)
+{
+    assert(NULL != self);
+    CMnsl *mnsl = (CMnsl *)self;    
+    MISC_UNUSED(data_ptr);
+
+    if (mnsl->srv_request_fptr != NULL)
+    {
+        TR_INFO((mnsl->inst_id, "[API]", "Mnsl_OnServiceRequest(): calling srv_request_fptr()", 0U));
+        mnsl->srv_request_fptr(mnsl->inst_ptr);
+    }
+}
+
+/*! \brief This function is used in combination with the observer \c mns.get_tick_count_obs
+ *         which is used to request the current tick count value form the application.
+ *  \param self                     Parameter not used with single instance API
+ *  \param tick_count_value_ptr     Reference to the requested tick count value. The pointer must 
+ *                                  be casted into data type uint16_t.
+ */
+static void Mnsl_OnGetTickCount(void *self, void *tick_count_value_ptr)
+{
+    assert(NULL != self);
+    CMnsl *mnsl = (CMnsl *)self;    
+    *((uint16_t *)tick_count_value_ptr) = mnsl->get_tick_count_fptr();
+}
+
+/*! \brief  Callback function which is invoked to start the application timer when the MNSL service
+ *          is implemented event driven         
+ *  \param  self                The instance
+ *  \param  new_time_value_ptr  Reference to the new timer value. The pointer must be casted into 
+ *                              data type uint16_t.
+ */
+static void Mnsl_OnSetApplicationTimer(void *self, void *new_time_value_ptr)
+{
+    CMnsl *self_ = (CMnsl*)self;
+    TR_INFO((mnsl->inst_id, "[API]", "Mnsl_OnSetApplicationTimer(): set_app_timer_fptr(%d)", 1U, *((uint16_t *)new_time_value_ptr)));
+    self_->set_app_timer_fptr(*((uint16_t *)new_time_value_ptr), self_->inst_ptr);
+}
+
+/*! \brief  Returns the ICM transceiver object
+ *  \return Reference to the ICM transceiver 
+ */
+CTransceiver * Mnsl_GetIcmTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->icm_transceiver;
+}
+
+/*! \brief  Returns the RCM transceiver object
+ *  \return Reference to the RCM transceiver 
+ */
+CTransceiver * Mnsl_GetRcmTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->rcm_transceiver;
+}
+
+/*! \brief  Returns the MCM transceiver object
+ *  \return Reference to the MCM transceiver 
+ */
+CTransceiver * Mnsl_GetMcmTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->mcm_transceiver;
+}
+
+/*! \brief      Returns the AMS transceiver object
+ *  \details    It is important not make usage of competing transceivers
+ *              AMS, MCM and RCM. Either use AMS exclusively or MCM and RCM.
+ *              Important: Do not use AMS in mode \c MNSL_FIFOS_ICM. 
+ *  \return     Reference to the AMS
+ */
+CAms * Mnsl_GetAmsTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->ams;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/