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, 311 insertions, 0 deletions

diff --git a/mnsl/mns_pmchannel.c b/mnsl/mns_pmchannel.c
new file mode 100644
index 0000000..e98a2b2
--- /dev/null
+++ b/mnsl/mns_pmchannel.c
@@ -0,0 +1,311 @@
+/*
+ * 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.
+ *
+ */
+
+/*!
+ * \file
+ * \brief Implementation of Port Message Channel
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PMC
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pmchannel.h"
+#include "mns_pmp.h"
+#include "mns_pmcmd.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal Constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal typedefs                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+/* LLD related interface functions */
+static Mns_Lld_RxMsg_t* Pmch_RxAllocate(void *self, uint16_t buffer_size);
+static void Pmch_RxUnused(void *self, Mns_Lld_RxMsg_t *msg_ptr);
+static void Pmch_RxReceive(void *self, Mns_Lld_RxMsg_t *msg_ptr);
+static void Pmch_TxRelease(void *self, Mns_Lld_TxMsg_t *msg_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief  Constructor of class CPmChannel
+ *  \param  self        The instance
+ *  \param  init_ptr    Reference to initialization data structure
+ *  \param  inst_ptr    TKU: MultiInstance param
+ */
+void Pmch_Ctor(CPmChannel *self, const Pmch_InitData_t *init_ptr, void *inst_ptr)
+{
+    uint16_t cnt;
+    MISC_MEM_SET(self, 0, sizeof(*self));
+
+    self->init_data    = *init_ptr;
+    self->inst_ptr     = inst_ptr;
+    self->lld_active   = false;
+ 
+    self->mns_iface.rx_allocate_fptr       = &Pmch_RxAllocate;
+    self->mns_iface.rx_receive_fptr        = &Pmch_RxReceive;
+    self->mns_iface.rx_free_unused_fptr    = &Pmch_RxUnused;
+    self->mns_iface.tx_release_fptr        = &Pmch_TxRelease;
+
+    Pool_Ctor(&self->rx_msgs_pool, self->rx_msgs,                   /* initialize Rx message pool */
+              PMCH_POOL_SIZE_RX, self->init_data.mns_inst_id);
+    for (cnt = 0U; cnt < PMCH_POOL_SIZE_RX; cnt++)                  /* and assign LLD Rx handles  */
+    {
+        Msg_SetLldHandle(&self->rx_msgs[cnt], &self->lld_rx_msgs[cnt]);
+        self->lld_rx_msgs[cnt].msg_ptr = &self->rx_msgs[cnt];
+    }
+}
+
+/*! \brief      Registers an Rx callback function dedicated to one FIFO
+ *  \param      self      The instance
+ *  \param      fifo_id   The FIFO identifier
+ *  \param      rx_fptr   The Rx callback function
+ *  \param      inst_ptr  Reference to the instance required to invoke the callback
+ */
+void Pmch_RegisterReceiver(CPmChannel *self, Pmp_FifoId_t fifo_id, Pmch_OnRxMsg_t rx_fptr, void *inst_ptr)
+{
+    TR_ASSERT(self->init_data.mns_inst_id, "[PMCH]", (((uint8_t)fifo_id == (uint8_t)PMP_FIFO_ID_ICM)||((uint8_t)fifo_id == (uint8_t)PMP_FIFO_ID_MCM)||((uint8_t)fifo_id == (uint8_t)PMP_FIFO_ID_RCM)));
+
+    self->receivers[fifo_id].rx_fptr = rx_fptr;
+    self->receivers[fifo_id].inst_ptr = inst_ptr;
+}
+
+/*! \brief      Un-initializes the LLD interface of the channel
+ *  \param      self    The instance
+ */
+void Pmch_Initialize(CPmChannel *self)
+{
+    if (self->lld_active == false)
+    {
+        self->lld_active   = true;
+        TR_INFO((self->init_data.mns_inst_id, "[PMCH]", "Pmch_Initialize(): LLD_START()", 0U));
+        self->init_data.lld_iface.start_fptr(&self->mns_iface, self, self->inst_ptr);
+    }
+}
+
+/*! \brief      Un-initializes the LLD interface of the channel
+ *  \param      self    The instance
+ */
+extern void Pmch_Uninitialize(CPmChannel *self)
+{
+    TR_INFO((self->init_data.mns_inst_id, "[PMCH]", "Pmch_Uninitialize(): Channel un-synchronization started", 0U));
+
+    if (self->lld_active != false)
+    {
+        self->lld_active = false;
+        TR_INFO((self->init_data.mns_inst_id, "[PMCH]", "Pmch_Uninitialize(): LLD_STOP()", 0U));
+        self->init_data.lld_iface.stop_fptr(self->inst_ptr);
+    }
+}
+
+/*! \brief      Wrapper for LLD transmit
+ *  \details    This function which shall be used by all internal classes. No class shall
+ *              invoke the LLD transmit function directly. Thus, it might be possible 
+ *              in future to handle transmission failures and retries.
+ *  \param      self    The instance
+ *  \param      msg_ptr Reference to the public LLD message structure
+ */
+void Pmch_Transmit(CPmChannel *self, Mns_Lld_TxMsg_t *msg_ptr)
+{
+    if (self->lld_active != false)
+    {
+        self->init_data.lld_iface.tx_transmit_fptr(msg_ptr, self->inst_ptr);
+    }
+    else
+    {
+        Pmch_TxRelease(self, msg_ptr);
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* The exposed low-level driver interface                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Allocates an Rx message object 
+ *  \param  self        The instance
+ *  \param  buffer_size Size of the memory chunk in bytes which is needed to
+ *                      copy the Rx message.
+ *  \return Reference to an allocated Rx message object or \c NULL if no message object is available.
+ */
+static Mns_Lld_RxMsg_t* Pmch_RxAllocate(void *self, uint16_t buffer_size)
+{
+    CMessage *msg_ptr = NULL;
+    Mns_Lld_RxMsg_t *handle = NULL;
+    CPmChannel *self_ = (CPmChannel*)self;
+
+    if (buffer_size <= MSG_SIZE_RSVD_BUFFER)
+    {
+        msg_ptr = Pool_GetMsg(&self_->rx_msgs_pool);
+
+        if (msg_ptr != NULL)
+        {
+            Msg_Cleanup(msg_ptr);
+            handle = &((Lld_IntRxMsg_t*)Msg_GetLldHandle(msg_ptr))->lld_msg;
+
+            TR_ASSERT(self_->init_data.mns_inst_id, "[PMCH]", (handle != NULL));
+ 
+            handle->data_size       = buffer_size;
+            handle->data_ptr        = Msg_GetHeader(msg_ptr);
+        }
+        else
+        {
+            self_->rx_trigger_available = true;
+            TR_INFO((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxAllocate(): Allocation failed, size=%u", 1U, buffer_size));
+        }
+    }
+    else
+    {
+        self_->rx_trigger_available = true;         
+        TR_FAILED_ASSERT(self_->init_data.mns_inst_id, "[PMCH]");
+    }
+
+    return handle;
+}
+
+/*! \brief  Frees an unused Rx message object
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the unused Rx message object
+ */
+static void Pmch_RxUnused(void *self, Mns_Lld_RxMsg_t *msg_ptr)
+{
+    CPmChannel *self_ = (CPmChannel*)self;
+    CMessage *pb_handle = ((Lld_IntRxMsg_t*)(void*)msg_ptr)->msg_ptr;
+
+    TR_ASSERT(self_->init_data.mns_inst_id, "[PMCH]", (pb_handle != NULL));
+    Pmch_ReturnRxToPool(self_, pb_handle);
+}
+
+/*! \brief  Pass an Rx message to MOST NetServices 
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the Rx message object containing the received
+ *                      message.
+ */
+static void Pmch_RxReceive(void *self, Mns_Lld_RxMsg_t *msg_ptr)
+{
+    bool found = false;
+    CPmChannel *self_ = (CPmChannel*)self;
+
+    if (msg_ptr->data_ptr != NULL)
+    {
+        if (msg_ptr->data_size >= PMP_PM_MIN_SIZE_HEADER)                     /* ignore incomplete messages */
+        {
+            uint8_t fifo_no = (uint8_t)Pmp_GetFifoId(msg_ptr->data_ptr);    /* get channel id (FIFO number) */
+
+            if ((fifo_no < PMP_MAX_NUM_FIFOS) && (self_->receivers[fifo_no].inst_ptr != NULL))
+            {
+                CMessage *handle = ((Lld_IntRxMsg_t*)(void*)msg_ptr)->msg_ptr;
+                                                                            /* forward message to the respective FIFO/channel */
+                self_->receivers[fifo_no].rx_fptr(self_->receivers[fifo_no].inst_ptr, handle); 
+                found = true;
+            }
+            else
+            {
+                TR_ERROR((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxReceive(): received message for unregistered FIFO no=%u", 1U, fifo_no));
+            }
+        }
+        else
+        {
+            TR_ERROR((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxReceive(): received incomplete message of size=%u", 1U, msg_ptr->data_size));
+        }
+    }
+    else
+    {
+        TR_ERROR((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxReceive(): message data is not valid", 0U));
+    }
+
+    if (false == found)
+    {
+        Pmch_RxUnused(self_, msg_ptr);                                      /* Just return message to pool until PMC is implemented */
+    }
+}
+
+/*! \brief  Notifies that the LLD no longer needs to access the Tx message object
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the Tx message object which is no longer accessed
+ *                      by the low-level driver
+ */
+static void Pmch_TxRelease(void *self, Mns_Lld_TxMsg_t *msg_ptr)
+{
+    CPmChannel *self_ = (CPmChannel*)self;
+    Lld_IntTxMsg_t *tx_ptr = (Lld_IntTxMsg_t*)(void*)msg_ptr;
+
+    if ((tx_ptr->owner_ptr == NULL) && (tx_ptr->msg_ptr == NULL))           /* tx_ptr is command */
+    {
+        Pmcmd_Release((CPmCommand*)(void*)tx_ptr);
+    }
+    else if (tx_ptr->owner_ptr != NULL)                                     /* release message to FIFO */
+    {
+        self_->init_data.tx_release_fptr(tx_ptr->owner_ptr, msg_ptr);
+    }
+    else
+    {
+        TR_FAILED_ASSERT(self_->init_data.mns_inst_id, "[PMCH]"); /* unknown FIFO - invalid message object */
+    }
+
+    TR_ASSERT(self_->init_data.mns_inst_id, "[PMCH]", (NULL == msg_ptr->custom_next_msg_ptr));  /* concatenation destroyed by the LLD */
+ 
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* FIFO Related Callback Functions                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Returns an unused Rx message object back to the pool
+ *  \param  self    The instance
+ *  \param  msg_ptr The unused Rx message object 
+ */
+void Pmch_ReturnRxToPool(void *self, CMessage *msg_ptr)
+{
+    CPmChannel *self_ = (CPmChannel*)self;
+
+    Pool_ReturnMsg(msg_ptr);
+
+    if (self_->rx_trigger_available == true)
+    {
+        self_->rx_trigger_available = false;
+
+        if (self_->init_data.lld_iface.rx_available_fptr != NULL)
+        {
+            self_->init_data.lld_iface.rx_available_fptr(self_->inst_ptr);
+        }
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+