path: root/ucs2-lib/src/ucs_prog.c

/*------------------------------------------------------------------------------------------------*/
/* UNICENS V2.1.0-3491                                                                            */
/* Copyright (c) 2017 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.                                              */
/*------------------------------------------------------------------------------------------------*/

/*!
 * \file
 * \brief Implementation of the Programming Service.
 *
 * \cond UCS_INTERNAL_DOC
 * \addtogroup G_PROG_MODE
 * @{

 */

/*------------------------------------------------------------------------------------------------*/
/* Includes                                                                                       */
/*------------------------------------------------------------------------------------------------*/
#include "ucs_inic_pb.h"
#include "ucs_prog.h"
#include "ucs_misc.h"


/*------------------------------------------------------------------------------------------------*/
/* Internal constants                                                                             */
/*------------------------------------------------------------------------------------------------*/
#define PRG_NUM_STATES             6U    /*!< \brief Number of state machine states */
#define PRG_NUM_EVENTS            13U    /*!< \brief Number of state machine events */

#define PRG_TIMEOUT_COMMAND      100U    /*!< \brief supervise EXC commands */

#define PRG_SIGNATURE_VERSION      1U    /*!< \brief signature version used for Node Discovery */

#define PRG_ADMIN_BASE_ADDR   0x0F00U    /*!< \brief bas admin address */


/* Error values */
#define PRG_HW_RESET_REQ        0x200110U   /* HW reset required */
#define PRG_SESSION_ACTIVE      0x200111U   /* Session already active */
#define PRG_CFG_STRING_ERROR    0x200220U   /* A configuration string erase error has occurred. */
#define PRG_MEM_ERASE_ERROR     0x200221U   /* An error memory erase error has occurred.*/
#define PRG_CFG_WRITE_ERROR     0x200225U   /* Configuration memory write error. */
#define PRG_CFG_FULL_ERROR      0x200226U   /* Configuration memory is full. */
#define PRG_HDL_MATCH_ERROR     0x200330U   /* The SessionHandle does not match the current memory session. */
#define PRG_MEMID_ERROR         0x200331U   /* The memory session does not support the requested MemID. */
#define PRG_ADDR_EVEN_ERROR     0x200332U   /* The Address is not even when writing the configuration memory. */
#define PRG_LEN_EVEN_ERROR      0x200333U   /* The UnitLen is not even when writing the configuration memory. */

/*------------------------------------------------------------------------------------------------*/
/* Service parameters                                                                             */
/*------------------------------------------------------------------------------------------------*/
/*! Priority of the Programming service used by scheduler */
static const uint8_t PRG_SRV_PRIO = 248U;   /* parasoft-suppress  MISRA2004-8_7 "Value shall be part of the module, not part of a function." */
/*! Main event for the Programming service */
static const Srv_Event_t PRG_EVENT_SERVICE = 1U;


/*------------------------------------------------------------------------------------------------*/
/* Internal enumerators                                                                           */
/*------------------------------------------------------------------------------------------------*/
/*! \brief Possible events of the system diagnosis state machine */
typedef enum Prg_Events_
{
    PRG_E_NIL                = 0U,      /*!< \brief NIL Event */
    PRG_E_START              = 1U,      /*!< \brief API start command was called. */
    PRG_E_STOP               = 2U,      /*!< \brief Stop request occurred. */
    PRG_E_WELCOME_SUCCESS    = 3U,      /*!< \brief Welcome command was successful. */
    PRG_E_WELCOME_NOSUCCESS  = 4U,      /*!< \brief Welcome command was not successful. */
    PRG_E_MEM_WRITE_CMD      = 5U,      /*!< \brief MemorySessionOpen command was succcessful */
    PRG_E_MEM_WRITE_FINISH   = 6U,      /*!< \brief MemoryWrite command was succcessful */
    PRG_E_MEM_CLOSE_SUCCESS  = 7U,      /*!< \brief MemorySessionClose command was succcessful */
    PRG_E_NET_OFF            = 8U,      /*!< \brief NetOff occurred. */
    PRG_E_TIMEOUT            = 9U,      /*!< \brief Timeout occurred. */
    PRG_E_ERROR             = 10U,      /*!< \brief An error occurred which requires no command to be sent to the INIC. */
    PRG_E_ERROR_INIT        = 11U,      /*!< \brief Error requires Init.Start to be sent. */
    PRG_E_ERROR_CLOSE_INIT  = 12U       /*!< \brief Error requires MemorySessionClose.SR and Init.Start to be sent. */
} Prg_Events_t;


/*! \brief States of the node discovery state machine */
typedef enum Prg_State_
{
    PRG_S_IDLE                =  0U,     /*!< \brief Idle state. */
    PRG_S_WAIT_WELCOME        =  1U,     /*!< \brief Programming started. */
    PRG_S_WAIT_MEM_OPEN       =  2U,     /*!< \brief Wait for MemorySessionOpen result. */
    PRG_S_WAIT_MEM_WRITE      =  3U,     /*!< \brief Wait for MemoryWrite result. */
    PRG_S_WAIT_MEM_CLOSE      =  4U,     /*!< \brief Wait for MemorySessionClose result. */
    PRG_S_WAIT_MEM_ERR_CLOSE  =  5U      /*!< \brief Wait for MemorySessionClose result in error case. */
} Prg_State_t;


/*------------------------------------------------------------------------------------------------*/
/* Internal prototypes                                                                            */
/*------------------------------------------------------------------------------------------------*/
static void Prg_Service(void *self);

static void Prg_WelcomeResultCb(void *self, void *result_ptr);
static void Prg_MemOpenResultCb(void *self, void *result_ptr);
static void Prg_MemWriteResultCb(void *self, void *result_ptr);
static void Prg_MemCloseResultCb(void *self, void *result_ptr);

static void Prg_OnTerminateEventCb(void *self, void *result_ptr);
static void Prg_NetworkStatusCb(void *self, void *result_ptr);

static void Prg_A_Start(void *self);
static void Prg_A_MemOpen(void *self);
static void Prg_A_MemWrite(void *self);
static void Prg_A_MemClose(void *self);
static void Prg_A_InitDevice(void *self);
static void Prg_A_NetOff(void *self);
static void Prg_A_Timeout(void *self);
static void Prg_A_Error(void *self);
static void Prg_A_Error_Init(void *self);
static void Prg_A_Error_Close_Init(void *self);


static void Prg_Check_RetVal(CProgramming *self, Ucs_Return_t  ret_val);
static uint32_t Prg_CalcError(uint8_t val[]);

static void Prg_TimerCb(void *self);

/*------------------------------------------------------------------------------------------------*/
/* State transition table (used by finite state machine)                                          */
/*------------------------------------------------------------------------------------------------*/
/*! \brief State transition table */
static const Fsm_StateElem_t prg_trans_tab[PRG_NUM_STATES][PRG_NUM_EVENTS] =    /* parasoft-suppress  MISRA2004-8_7 "Value shall be part of the module, not part of a function." */
{
    { /* State PRG_S_IDLE */
        /* PRG_E_NIL                */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_START              */ {Prg_A_Start,                PRG_S_WAIT_WELCOME       },
        /* PRG_E_STOP               */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_WELCOME_SUCCESS    */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_WELCOME_NOSUCCESS  */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_MEM_WRITE_CMD      */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_MEM_WRITE_FINISH   */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_MEM_CLOSE_SUCCESS  */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_NET_OFF            */ {Prg_A_NetOff,               PRG_S_IDLE               },
        /* PRG_E_TIMEOUT            */ {Prg_A_Timeout,              PRG_S_IDLE               },
        /* PRG_E_ERROR              */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_ERROR_INIT         */ {NULL,                       PRG_S_IDLE               },
        /* PRG_E_ERROR_CLOSE_INIT   */ {NULL,                       PRG_S_IDLE               },
    },
    { /* State PRG_S_WAIT_WELCOME */
        /* PRG_E_NIL                */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_START              */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_STOP               */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_WELCOME_SUCCESS    */ {Prg_A_MemOpen,              PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_WELCOME_NOSUCCESS  */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_MEM_WRITE_CMD      */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_MEM_WRITE_FINISH   */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_MEM_CLOSE_SUCCESS  */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_NET_OFF            */ {Prg_A_NetOff,               PRG_S_IDLE               },
        /* PRG_E_TIMEOUT            */ {Prg_A_Timeout,              PRG_S_IDLE               },
        /* PRG_E_ERROR              */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_ERROR_INIT         */ {NULL,                       PRG_S_WAIT_WELCOME       },
        /* PRG_E_ERROR_CLOSE_INIT   */ {NULL,                       PRG_S_WAIT_WELCOME       }
    },
    { /* State PRG_S_WAIT_MEM_OPEN */
        /* PRG_E_NIL                */ {NULL,                       PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_START              */ {NULL,                       PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_STOP               */ {NULL,                       PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_WELCOME_SUCCESS    */ {NULL,                       PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_WELCOME_NOSUCCESS  */ {NULL,                       PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_MEM_WRITE_CMD      */ {Prg_A_MemWrite,             PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_MEM_WRITE_FINISH   */ {Prg_A_MemClose,             PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_MEM_CLOSE_SUCCESS  */ {NULL,                       PRG_S_WAIT_MEM_OPEN      },
        /* PRG_E_NET_OFF            */ {Prg_A_NetOff,               PRG_S_IDLE               },
        /* PRG_E_TIMEOUT            */ {Prg_A_Timeout,              PRG_S_IDLE               },
        /* PRG_E_ERROR              */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_ERROR_INIT         */ {Prg_A_Error_Init,           PRG_S_IDLE               },
        /* PRG_E_ERROR_CLOSE_INIT   */ {Prg_A_Error_Close_Init,     PRG_S_WAIT_MEM_ERR_CLOSE }
    },
    { /* State PRG_S_WAIT_MEM_WRITE */
        /* PRG_E_NIL                */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_START              */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_STOP               */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_WELCOME_SUCCESS    */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_WELCOME_NOSUCCESS  */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_MEM_WRITE_CMD      */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_MEM_WRITE_FINISH   */ {Prg_A_MemClose,             PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_MEM_CLOSE_SUCCESS  */ {NULL,                       PRG_S_WAIT_MEM_WRITE     },
        /* PRG_E_NET_OFF            */ {Prg_A_NetOff,               PRG_S_IDLE               },
        /* PRG_E_TIMEOUT            */ {Prg_A_Timeout,              PRG_S_IDLE               },
        /* PRG_E_ERROR              */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_ERROR_INIT         */ {Prg_A_Error_Init,           PRG_S_IDLE               },
        /* PRG_E_ERROR_CLOSE_INIT   */ {Prg_A_Error_Close_Init,     PRG_S_WAIT_MEM_ERR_CLOSE }
    },
    { /* State PRG_S_WAIT_MEM_CLOSE */
        /* PRG_E_NIL                */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_START              */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_STOP               */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_WELCOME_SUCCESS    */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_WELCOME_NOSUCCESS  */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_MEM_WRITE_CMD      */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_MEM_WRITE_FINISH   */ {NULL,                       PRG_S_WAIT_MEM_CLOSE     },
        /* PRG_E_MEM_CLOSE_SUCCESS  */ {Prg_A_InitDevice,           PRG_S_IDLE               },
        /* PRG_E_NET_OFF            */ {Prg_A_NetOff,               PRG_S_IDLE               },
        /* PRG_E_TIMEOUT            */ {Prg_A_Timeout,              PRG_S_IDLE               },
        /* PRG_E_ERROR              */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_ERROR_INIT         */ {Prg_A_Error_Init,           PRG_S_IDLE               },
        /* PRG_E_ERROR_CLOSE_INIT   */ {Prg_A_Error,                PRG_S_IDLE               },
    },
    { /* State PRG_S_WAIT_MEM_ERR_CLOSE */
        /* PRG_E_NIL                */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_START              */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_STOP               */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_WELCOME_SUCCESS    */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_WELCOME_NOSUCCESS  */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_MEM_WRITE_CMD      */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_MEM_WRITE_FINISH   */ {NULL,                       PRG_S_WAIT_MEM_ERR_CLOSE },
        /* PRG_E_MEM_CLOSE_SUCCESS  */ {Prg_A_Error_Init,           PRG_S_IDLE               },
        /* PRG_E_NET_OFF            */ {Prg_A_NetOff,               PRG_S_IDLE               },
        /* PRG_E_TIMEOUT            */ {Prg_A_Timeout,              PRG_S_IDLE               },
        /* PRG_E_ERROR              */ {Prg_A_Error,                PRG_S_IDLE               },
        /* PRG_E_ERROR_INIT         */ {Prg_A_Error_Init,           PRG_S_IDLE               },
        /* PRG_E_ERROR_CLOSE_INIT   */ {Prg_A_Error,                PRG_S_IDLE               },
    }

};


/*! \brief Constructor of class CProgramming.
 *  \param self         Reference to CProgramming instance
 *  \param inic         Reference to CInic instance
 *  \param base         Reference to CBase instance
 *  \param exc          Reference to CExc instance
 */
 /*  \param init_ptr    Report callback function*/
void Prg_Ctor(CProgramming *self, CInic *inic, CBase *base, CExc *exc)
{
    MISC_MEM_SET((void *)self, 0, sizeof(*self));

    self->inic       = inic;
    self->exc        = exc;
    self->base       = base;

    Fsm_Ctor(&self->fsm, self, &(prg_trans_tab[0][0]), PRG_NUM_EVENTS, PRG_E_NIL);

    Sobs_Ctor(&self->prg_welcome,       self, &Prg_WelcomeResultCb);
    Sobs_Ctor(&self->prg_memopen,       self, &Prg_MemOpenResultCb);
    Sobs_Ctor(&self->prg_memwrite,      self, &Prg_MemWriteResultCb);
    Sobs_Ctor(&self->prg_memclose,      self, &Prg_MemCloseResultCb);

    /* register termination events */
    Mobs_Ctor(&self->prg_terminate, self, EH_M_TERMINATION_EVENTS, &Prg_OnTerminateEventCb);
    Eh_AddObsrvInternalEvent(&self->base->eh, &self->prg_terminate);

    /* Register NetOn and MPR events */
    Obs_Ctor(&self->prg_nwstatus, self, &Prg_NetworkStatusCb);
    Inic_AddObsrvNwStatus(self->inic,  &self->prg_nwstatus);
    self->neton = false;

    /* Initialize Programming service */
    Srv_Ctor(&self->service, PRG_SRV_PRIO, self, &Prg_Service);
    /* Add Programming service to scheduler */
    (void)Scd_AddService(&self->base->scd, &self->service);

}


/*! \brief Service function of the Node Discovery service.
 *  \param self    Reference to Programming service object
 */
static void Prg_Service(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    Srv_Event_t event_mask;
    Srv_GetEvent(&self_->service, &event_mask);
    if(PRG_EVENT_SERVICE == (event_mask & PRG_EVENT_SERVICE))   /* Is event pending? */
    {
        Fsm_State_t result;
        Srv_ClearEvent(&self_->service, PRG_EVENT_SERVICE);
        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "FSM __ %d %d", 2U, self_->fsm.current_state, self_->fsm.event_occured));
        result = Fsm_Service(&self_->fsm);
        TR_ASSERT(self_->base->ucs_user_ptr, "[PRG]", (result != FSM_STATE_ERROR));
        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "FSM -> %d", 1U, self_->fsm.current_state));
        MISC_UNUSED(result);
    }
}



/**************************************************************************************************/
/* API functions                                                                                  */
/**************************************************************************************************/
/*!
 *
 * \param *self Reference to Programming service object
 */
/*! \brief Program a node
 *
 * \param *self         Reference to Programming service object
 * \param node_id       Node position address of the node to be programmed
 * \param *signature    Signature of the node to be programmed
 * \param session_type  Defines the memory access type.
 * \param command_list  Refers to array of programming tasks.
 * \param report_fptr   Report callback function
 */
void Prg_Start(CProgramming *self,
               uint16_t node_id,
               Ucs_Signature_t *signature,
               Ucs_Prg_SessionType_t session_type,
               Ucs_Prg_Command_t* command_list,
               Ucs_Prg_ReportCb_t report_fptr)
{


    self->node_id          = node_id;
    self->signature        = *signature;
    self->session_type     = session_type;
    self->command_list     = command_list;
    self->report_fptr      = report_fptr;
    self->current_function = UCS_PRG_FKT_DUMMY;

    if (self->neton == true)
    {
        Fsm_SetEvent(&self->fsm, PRG_E_START);
        Srv_SetEvent(&self->service, PRG_EVENT_SERVICE);

        TR_INFO((self->base->ucs_user_ptr, "[PRG]", "Prg_Start", 0U));
    }
    else
    {
        if (self->report_fptr != NULL)
        {
            self->report_fptr(UCS_PRG_RES_NET_OFF,
                              self->current_function,
                              0U,
                              NULL,
                              self->base->ucs_user_ptr);
        }
        TR_INFO((self->base->ucs_user_ptr, "[PRG]", "Prg_Start failed: NET_OFF", 0U));
    }
}



/**************************************************************************************************/
/*  FSM Actions                                                                                   */
/**************************************************************************************************/
/*!  Action on Start command
 *
 * \param *self Reference to Node Discovery object
 */
static void Prg_A_Start(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    Ucs_Return_t  ret_val;

    if (self_->node_id == 0x0400U)
    {
        self_->target_address = UCS_ADDR_LOCAL_INIC;
    }
    else
    {
        self_->target_address = self_->node_id;
    }

    self_->admin_node_address = PRG_ADMIN_BASE_ADDR + ((self_->node_id) & 0x00FFU);
    self_->current_function = UCS_PRG_FKT_WELCOME;

    ret_val = Exc_Welcome_Sr(self_->exc,
                             self_->target_address,
                             self_->admin_node_address,
                             PRG_SIGNATURE_VERSION,
                             self_->signature,
                             &self_->prg_welcome);
    Prg_Check_RetVal(self_, ret_val);
}

static void Prg_A_MemOpen(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    Ucs_Return_t  ret_val;

    self_->current_function = UCS_PRG_FKT_MEM_OPEN;

    ret_val = Exc_MemSessionOpen_Sr(self_->exc,
                                    self_->admin_node_address,
                                    self_->session_type,
                                    &self_->prg_memopen);
    Prg_Check_RetVal(self_, ret_val);
}

static void Prg_A_MemWrite(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    Ucs_Return_t  ret_val;

    self_->current_function = UCS_PRG_FKT_MEM_WRITE;

    ret_val = Exc_MemoryWrite_Sr(self_->exc,
                                 self_->admin_node_address,
                                 self_->session_handle,
                                 self_->command_list[self_->command_index].mem_id,
                                 self_->command_list[self_->command_index].address,
                                 self_->command_list[self_->command_index].unit_length,
                                 self_->command_list[self_->command_index].data,
                                 &self_->prg_memwrite);
    Prg_Check_RetVal(self_, ret_val);
}

static void Prg_A_MemClose(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    Ucs_Return_t  ret_val;

    self_->current_function = UCS_PRG_FKT_MEM_CLOSE;
    ret_val = Exc_MemSessionClose_Sr(self_->exc,
                                     self_->admin_node_address,
                                     self_->session_handle,
                                     &self_->prg_memclose);
    Prg_Check_RetVal(self_, ret_val);
}

static void Prg_A_InitDevice(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    Ucs_Return_t  ret_val;

    self_->current_function = UCS_PRG_FKT_INIT;
    ret_val = Exc_DeviceInit_Start(self_->exc,
                                   self_->admin_node_address,
                                   NULL);
    Prg_Check_RetVal(self_, ret_val);

    if (ret_val == UCS_RET_SUCCESS)
    {
        if (self_->report_fptr != NULL)
        {
            self_->report_fptr(UCS_PRG_RES_SUCCESS,
                               UCS_PRG_FKT_DUMMY,
                               0U,
                               NULL,
                               self_->base->ucs_user_ptr);
        }
    }
}

static void Prg_A_NetOff(void *self)
{
    CProgramming *self_ = (CProgramming *)self;

    if (self_->report_fptr != NULL)
    {
        self_->report_fptr(UCS_PRG_RES_NET_OFF,
                           self_->current_function,
                           0U,
                           NULL,
                           self_->base->ucs_user_ptr);
    }
}

static void Prg_A_Timeout(void *self)
{
    CProgramming *self_ = (CProgramming *)self;

    if (self_->report_fptr != NULL)
    {
        self_->report_fptr(UCS_PRG_RES_TIMEOUT,
                           self_->current_function,
                           0U,
                           NULL,
                           self_->base->ucs_user_ptr);
    }
}

static void Prg_A_Error(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    uint8_t *data_ptr   = NULL;

    if (   (self_->error.code == UCS_PRG_RES_FKT_ASYNCH)
        && (self_->error.ret_len != 0U))
    {
        data_ptr = &(self_->error.parm[0]);
    }

    if (self_->report_fptr != NULL)
    {
        self_->report_fptr(self_->error.code,
                           self_->error.function,
                           self_->error.ret_len,
                           data_ptr,
                           self_->base->ucs_user_ptr);
    }
}


static void Prg_A_Error_Init(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    uint8_t *data_ptr   = NULL;
    Ucs_Return_t  ret_val;

    ret_val = Exc_DeviceInit_Start(self_->exc,
                                     self_->admin_node_address,
                                     NULL);
    Prg_Check_RetVal(self_, ret_val);

    if (   (self_->error.code == UCS_PRG_RES_FKT_ASYNCH)
        && (self_->error.ret_len != 0U))
    {
        data_ptr = &(self_->error.parm[0]);
    }

    if (self_->report_fptr != NULL)
    {
        self_->report_fptr(self_->error.code,
                           self_->error.function,
                           self_->error.ret_len,
                           data_ptr,
                           self_->base->ucs_user_ptr);
    }
}

static void Prg_A_Error_Close_Init(void *self)
{
    CProgramming *self_ = (CProgramming *)self;
    uint8_t *data_ptr   = NULL;
    Ucs_Return_t  ret_val;

    ret_val = Exc_DeviceInit_Start(self_->exc,
                                     self_->admin_node_address,
                                     NULL);
    Prg_Check_RetVal(self_, ret_val);


    if (   (self_->error.code == UCS_PRG_RES_FKT_ASYNCH)
        && (self_->error.ret_len != 0U))
    {
        data_ptr = &(self_->error.parm[0]);
    }

    if (self_->report_fptr != NULL)
    {
        self_->report_fptr(self_->error.code,
                           self_->error.function,
                           self_->error.ret_len,
                           data_ptr,
                           self_->base->ucs_user_ptr);
    }
}


/**************************************************************************************************/
/*  Callback functions                                                                            */
/**************************************************************************************************/

/*! \brief  Function is called on reception of the Welcome.Result messsage
 *  \param  self        Reference to Programming service object
 *  \param  result_ptr  Pointer to the result of the Welcome message
 */
static void Prg_WelcomeResultCb(void *self, void *result_ptr)
{
    CProgramming *self_          = (CProgramming *)self;
    Exc_StdResult_t *result_ptr_ = (Exc_StdResult_t *)result_ptr;

    Tm_ClearTimer(&self_->base->tm, &self_->timer);

    if (result_ptr_->result.code == UCS_RES_SUCCESS)
    {
        Exc_WelcomeResult_t  welcome_result;
        /* read signature and store it */
        welcome_result = *(Exc_WelcomeResult_t *)(result_ptr_->data_info);
        if (welcome_result.res == EXC_WELCOME_SUCCESS)
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_WELCOME_SUCCESS);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_WelcomeResultCb PRG_E_WELCOME_SUCCESS", 0U));
        }
        else
        {
            /* store error paramters */
            self_->error.code     = UCS_PRG_RES_FKT_ASYNCH;
            self_->error.function = UCS_PRG_FKT_WELCOME_NOSUCCESS;
            self_->error.ret_len  = 0U;

            Fsm_SetEvent(&self_->fsm, PRG_E_WELCOME_NOSUCCESS);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_WelcomeResultCb PRG_E_WELCOME_NOSUCCESS", 0U)); 
        }
    }
    else
    {
        uint8_t i;
        /* store error paramters */
        self_->error.code     = UCS_PRG_RES_FKT_ASYNCH;
        self_->error.function = UCS_PRG_FKT_WELCOME;
        self_->error.ret_len  = result_ptr_->result.info_size;
        for (i=0U; i< result_ptr_->result.info_size; ++i)
        {
            self_->error.parm[i] = result_ptr_->result.info_ptr[i];
        }

        Fsm_SetEvent(&self_->fsm, PRG_E_ERROR);

        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_WelcomeResultCb Error (code) 0x%x", 1U, result_ptr_->result.code));
        for (i=0U; i< result_ptr_->result.info_size; ++i)
        {
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_WelcomeResultCb Error (info) 0x%x", 1U, result_ptr_->result.info_ptr[i]));
        }
    }

    Srv_SetEvent(&self_->service, PRG_EVENT_SERVICE);
}



/*! \brief  Function is called on reception of the MemorySessionOpen.Result messsage
 *  \param  self        Reference to Programming service object
 *  \param  result_ptr  Pointer to the result of the Welcome message
 */
static void Prg_MemOpenResultCb(void *self, void *result_ptr)
{
    CProgramming *self_          = (CProgramming *)self;
    Exc_StdResult_t *result_ptr_ = (Exc_StdResult_t *)result_ptr;

    Tm_ClearTimer(&self_->base->tm, &self_->timer);

    if (result_ptr_->result.code == UCS_RES_SUCCESS)
    {
        self_->session_handle = *(uint16_t *)(result_ptr_->data_info);
        self_->command_index = 0U;

        if (   (self_->command_list[self_->command_index].data_length == 0U)
            || (self_->command_list[self_->command_index].data        == NULL))
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_MEM_WRITE_FINISH);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemOpenResultCb No Tasks", 0U));
        }
        else
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_MEM_WRITE_CMD);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemOpenResultCb successful", 0U));
        }
    }
    else
    {
        uint8_t i;
        uint32_t fs_error;

        /* store error paramters */
        self_->error.code     = UCS_PRG_RES_FKT_ASYNCH;
        self_->error.function = UCS_PRG_FKT_MEM_OPEN;
        self_->error.ret_len  = result_ptr_->result.info_size;
        for (i=0U; i< result_ptr_->result.info_size; ++i)
        {
            self_->error.parm[i] = result_ptr_->result.info_ptr[i];
        }

        fs_error = Prg_CalcError(&(self_->error.parm[0]));

        switch (fs_error)
        {
            case PRG_HW_RESET_REQ:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_INIT);
                break;

            case PRG_SESSION_ACTIVE:
                self_->session_handle = (uint16_t)(((uint16_t)(self_->error.parm[3])) << 8U) + self_->error.parm[4]; /* get correct session handle */
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_CLOSE_INIT);
                break;

            default:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR);
                break;
        }

        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemOpenResultCb Error  0x%x", 1U, result_ptr_->result.code));
    }

    Srv_SetEvent(&self_->service, PRG_EVENT_SERVICE);
}


/*! \brief  Function is called on reception of the MemoryWrite.Result messsage
 *  \param  self        Reference to Programming service object
 *  \param  result_ptr  Pointer to the result of the Welcome message
 */
static void Prg_MemWriteResultCb(void *self, void *result_ptr)
{
    CProgramming *self_        = (CProgramming *)self;
    Exc_StdResult_t *result_ptr_ = (Exc_StdResult_t *)result_ptr;

    Tm_ClearTimer(&self_->base->tm, &self_->timer);

    if (result_ptr_->result.code == UCS_RES_SUCCESS)
    {
        self_->command_index++;
        if (   (self_->command_list[self_->command_index].data_length == 0U)
            || (self_->command_list[self_->command_index].data        == NULL))
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_MEM_WRITE_FINISH);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemWriteResultCb PRG_E_MEM_WRITE_FINISH", 0U));
        }
        else
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_MEM_WRITE_CMD);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemWriteResultCb successful", 0U));
        }
    }
    else
    {
        uint8_t i;
        uint32_t fs_error;

        /* store error paramters */
        self_->error.code     = UCS_PRG_RES_FKT_ASYNCH;
        self_->error.function = UCS_PRG_FKT_MEM_WRITE;
        self_->error.ret_len  = result_ptr_->result.info_size;
        for (i=0U; i< result_ptr_->result.info_size; ++i)
        {
            self_->error.parm[i] = result_ptr_->result.info_ptr[i];
        }

        fs_error = Prg_CalcError(&(self_->error.parm[0]));

        switch (fs_error)
        {
            case PRG_CFG_WRITE_ERROR:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_CLOSE_INIT);
                break;

            case PRG_CFG_FULL_ERROR:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_CLOSE_INIT);
                break;

            case PRG_HDL_MATCH_ERROR:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_INIT);
                break;

            case PRG_MEMID_ERROR:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_CLOSE_INIT);
                break;

            case PRG_ADDR_EVEN_ERROR:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_CLOSE_INIT);
                break;

            case PRG_LEN_EVEN_ERROR:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_CLOSE_INIT);
                break;

            default:
                Fsm_SetEvent(&self_->fsm, PRG_E_ERROR);
                break;
        }
        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemWriteResultCb Error  0x%x", 1U, result_ptr_->result.code));
    }

    Srv_SetEvent(&self_->service, PRG_EVENT_SERVICE);
}


/*! \brief  Function is called on reception of the MemorySessionClose.Result messsage
 *  \param  self        Reference to Programming service object
 *  \param  result_ptr  Pointer to the result of the Welcome message
 */
static void Prg_MemCloseResultCb(void *self, void *result_ptr)
{
    CProgramming *self_          = (CProgramming *)self;
    Exc_StdResult_t *result_ptr_ = (Exc_StdResult_t *)result_ptr;

    Tm_ClearTimer(&self_->base->tm, &self_->timer);

    if (result_ptr_->result.code == UCS_RES_SUCCESS)
    {
        uint8_t session_result = *(uint8_t *)(result_ptr_->data_info);

        if (session_result == 0U)
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_MEM_CLOSE_SUCCESS);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemCloseResultCb PRG_E_MEM_CLOSE_SUCCESS", 0U));
        }
        else
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_INIT);
            TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemCloseResultCb ErrResult PRG_E_ERROR_INIT", 0U));
        }
    }
    else
    {
        uint8_t i;
        uint32_t fs_error;

        /* store error paramters */
        self_->error.code     = UCS_PRG_RES_FKT_ASYNCH;
        self_->error.function = UCS_PRG_FKT_MEM_CLOSE;
        self_->error.ret_len  = result_ptr_->result.info_size;
        for (i=0U; i< result_ptr_->result.info_size; ++i)
        {
            self_->error.parm[i] = result_ptr_->result.info_ptr[i];
        }

        fs_error = Prg_CalcError(&(self_->error.parm[0]));

        if (fs_error == PRG_HDL_MATCH_ERROR)
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_ERROR_INIT);
        }
        else
        {
            Fsm_SetEvent(&self_->fsm, PRG_E_ERROR);
        }

        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_MemCloseResultCb Error  0x%x", 1U, result_ptr_->result.code));
    }

    Srv_SetEvent(&self_->service, PRG_EVENT_SERVICE);
}




/*!  Function is called on severe internal errors
 *
 * \param *self         Reference to Programming object
 * \param *result_ptr   Reference to data
 */
static void Prg_OnTerminateEventCb(void *self, void *result_ptr)
{
    CProgramming *self_ = (CProgramming *)self;

    MISC_UNUSED(result_ptr);

    if (self_->fsm.current_state != PRG_S_IDLE)
    {
        Tm_ClearTimer(&self_->base->tm, &self_->timer);
        if (self_->report_fptr != NULL)
        {
            self_->report_fptr(UCS_PRG_RES_ERROR, 
                               self_->current_function, 
                               0U, 
                               NULL, 
                               self_->base->ucs_user_ptr);
        }

        /* reset FSM */
        self_->fsm.current_state = PRG_S_IDLE;
    }
}


/*! \brief Callback function for the INIC.NetworkStatus status and error messages
 *
 * \param *self         Reference to Node Discovery object
 * \param *result_ptr   Pointer to the result of the INIC.NetworkStatus message
 */
static void Prg_NetworkStatusCb(void *self, void *result_ptr)
{
    CProgramming *self_ = (CProgramming *)self;
    Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;

    if (result_ptr_->result.code == UCS_RES_SUCCESS)
    {
        TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_NetworkStatusCb  0x%x", 1U, result_ptr_->result.code));
        /* check for NetOn/NetOff events */
        if (    (self_->neton == true)
             && ((((Inic_NetworkStatus_t *)(result_ptr_->data_info))->availability) == UCS_NW_NOT_AVAILABLE) )
        {
            self_->neton = false;
            Fsm_SetEvent(&self_->fsm, PRG_E_NET_OFF);
        }
        else if (    (self_->neton == false)
                && ((((Inic_NetworkStatus_t *)(result_ptr_->data_info))->availability) == UCS_NW_AVAILABLE) )
        {
            self_->neton = true;
        }
    }

    Srv_SetEvent(&self_->service, PRG_EVENT_SERVICE);
}



/*! \brief Timer callback used for supervising INIC command timeouts.
 *  \param self    Reference to System Diagnosis object
 */
static void Prg_TimerCb(void *self)
{
    CProgramming *self_ = (CProgramming *)self;

    Fsm_SetEvent(&self_->fsm, PRG_E_TIMEOUT);
    TR_INFO((self_->base->ucs_user_ptr, "[PRG]", "Prg_TimerCb PRG_E_TIMEOUT", 0U));

    Srv_SetEvent(&self_->service, PRG_EVENT_SERVICE);
}



/**************************************************************************************************/
/*  Helper functions                                                                              */
/**************************************************************************************************/

static void Prg_Check_RetVal(CProgramming *self, Ucs_Return_t  ret_val)
{
    if (ret_val == UCS_RET_SUCCESS)
    {
        Tm_SetTimer(&self->base->tm,
                    &self->timer,
                    &Prg_TimerCb,
                    self,
                    PRG_TIMEOUT_COMMAND,
                    0U);
    }
    else
    {
        TR_ASSERT(self->base->ucs_user_ptr, "[PRG]", ret_val == UCS_RET_SUCCESS);

        /* store error paramter */
        self->error.code     = UCS_PRG_RES_FKT_SYNCH;
        self->error.function = self->current_function;
        self->error.ret_len  = (uint8_t)ret_val;

        Fsm_SetEvent(&self->fsm, PRG_E_ERROR);
        Srv_SetEvent(&self->service, PRG_EVENT_SERVICE);
    }
}


static uint32_t Prg_CalcError(uint8_t val[])
{
    uint32_t temp;

    temp = val[0] + (((uint32_t)val[1]) << 8U) + (((uint32_t)val[2]) << 16U);

    return temp;
}





/*!
 * @}
 * \endcond
 */

/*------------------------------------------------------------------------------------------------*/
/* End of file                                                                                    */
/*------------------------------------------------------------------------------------------------*/