path: root/mnsl/mnsl.c

/*
 * 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 2 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                                                                                    */
/*------------------------------------------------------------------------------------------------*/