static eOresult_t s_eo_nvset_DeinitEPs(EOnvSet* p)
{
eOnvset_brd_t* theBoard = &p->theboard;
uint16_t i = 0;
uint16_t endpointsnum = 0;
if(NULL == theBoard->theendpoints)
{ // already deinitted
return(eores_OK);
}
endpointsnum = eo_vector_Size(theBoard->theendpoints);
for(i=0; i<endpointsnum; i++)
{
eOnvset_ep_t **ppep = (eOnvset_ep_t **)eo_vector_At(theBoard->theendpoints, i);
eOnvset_ep_t *theEndpoint = *ppep;
// now i erase memory associated with this endpoint
eo_mempool_Delete(eo_mempool_GetHandle(), theEndpoint->epram);
// and i dissociates that from from the internals of the eoprot library
eoprot_config_endpoint_ram(theBoard->boardnum, theEndpoint->epcfg.endpoint, NULL, 0);
// i also de-init the number of entities for that endpoint
eoprot_config_endpoint_entities(theBoard->boardnum, theEndpoint->epcfg.endpoint, NULL);
// now i delete all data associated to the mutex protection
if(NULL != theEndpoint->mtx_endpoint)
{
eov_mutex_Delete(theEndpoint->mtx_endpoint);
}
if(NULL != theEndpoint->themtxofthenvs)
{
uint16_t size = eo_vector_Size(theEndpoint->themtxofthenvs);
int j = 0;
for(j=0; j<size; j++)
{
EOVmutexDerived** pmtx = (EOVmutexDerived**)eo_vector_At(theEndpoint->themtxofthenvs, j);
eov_mutex_Delete(*pmtx);
}
eo_vector_Delete(theEndpoint->themtxofthenvs);
}
// now i erase the memory of the entire eOnvset_ep_t entry
eo_mempool_Delete(eo_mempool_GetHandle(), theEndpoint);
}
// so that we dont get in here inside again
theBoard->theendpoints = NULL;
return(eores_OK);
}
extern eOresult_t eo_confman_ConfirmationRequests_Process(EOconfirmationManager *p, eOipv4addr_t toipaddr)
{
if(NULL == p)
{
return(eores_NOK_generic);
}
eov_mutex_Take(p->mtx, eok_reltimeINFINITE);
if(0 != eo_vector_Size(p->confrequests))
{
uint16_t size = eo_vector_Size(p->confrequests);
uint16_t i=0;
for(i=0; i<size; i++)
{
eOropdescriptor_t *ropdes = (eOropdescriptor_t*) eo_vector_At(p->confrequests, i);
eo_confman_Confirmation_Requested(p, toipaddr, ropdes);
}
eo_vector_Clear(p->confrequests); // remove the conf requests
}
eov_mutex_Release(p->mtx);
return(eores_OK);
}
static EOVmutexDerived* s_eo_nvset_get_nvmutex(EOnvSet* p, eOnvID32_t id32)
{
EOVmutexDerived* mtx2use = NULL;
if(eo_nvset_protection_none == p->protection)
{ // the most common situation is no protection, thus ...
mtx2use = NULL;
}
else
{
switch(p->protection)
{
case eo_nvset_protection_one_per_board:
{
mtx2use = p->theboard.mtx_board;
} break;
case eo_nvset_protection_one_per_endpoint:
{
// compute the endpoint and ....
eOnvset_ep_t* theEndpoint = s_eo_nvset_get_endpoint(p, eoprot_ID2endpoint(id32));
if(NULL != theEndpoint)
{
mtx2use = theEndpoint->mtx_endpoint;
}
} break;
case eo_nvset_protection_one_per_netvar:
{
eOnvset_ep_t* theEndpoint = s_eo_nvset_get_endpoint(p, eoprot_ID2endpoint(id32));
if(NULL != theEndpoint)
{
//#warning .... i think of void* as a uint32_t* ///////////// think of it
uint32_t nvprognumber = eoprot_endpoint_id2prognum(p->theboard.boardnum, id32);
uint32_t** addr = eo_vector_At(theEndpoint->themtxofthenvs, nvprognumber);
mtx2use = (EOVmutexDerived*) (*addr);
}
} break;
default:
{
mtx2use = NULL;
} break;
}
}
return(mtx2use);
}
static eOnvset_ep_t* s_eo_nvset_get_endpoint(EOnvSet* p, eOnvEP8_t ep8)
{
eOnvset_brd_t* theBoard = &p->theboard;
eOnvset_ep_t** ptheEndpoint = NULL;
uint16_t onendpointindex = s_eonvset_EP2INDEX(p, ep8);
if(EOK_uint16dummy == onendpointindex)
{
return(NULL);
}
ptheEndpoint = (eOnvset_ep_t**) eo_vector_At(theBoard->theendpoints, onendpointindex);
if(NULL == ptheEndpoint)
{
return(NULL);
}
return(*ptheEndpoint);
}
extern eOresult_t eo_nvset_NVSinitialise(EOnvSet* p)
{
eOnvset_brd_t* theBoard = NULL;
uint16_t j;
uint16_t nendpoints;
if(NULL == p)
{
return(eores_NOK_nullpointer);
}
theBoard = &p->theboard;
nendpoints = eo_vector_Size(theBoard->theendpoints);
for(j=0; j<nendpoints; j++)
{
eOnvset_ep_t** theEndpoint = (eOnvset_ep_t**) eo_vector_At(theBoard->theendpoints, j);
s_eo_nvset_NVsOfEP_Initialise(p, (*theEndpoint), (*theEndpoint)->epcfg.endpoint);
}
return(eores_OK);
}
static eOresult_t s_eo_nvset_NVsOfEP_Initialise(EOnvSet* p, eOnvset_ep_t* endpoint, eOnvEP8_t ep08)
{
eOnvset_brd_t* theBoard = NULL;
eOnvset_ep_t* theEndpoint = endpoint;
eOvoid_fp_uint32_voidp_t initialise = NULL;
if(NULL == p)
{
return(eores_NOK_nullpointer);
}
theBoard = &p->theboard;
if(NULL == theEndpoint)
{
theEndpoint = s_eo_nvset_get_endpoint(p, ep08);
if(NULL == theEndpoint)
{
return(eores_NOK_generic);
}
// if(ep08 != theEndpoint->epcfg.endpoint)
// {
// return(eores_NOK_generic);
// }
}
if(eobool_true == (theEndpoint->initted))
{ // already initted
return(eores_OK);
}
initialise = eoprot_endpoint_get_initialiser(ep08);
if(NULL != initialise)
{
initialise(theBoard->ipaddress, theEndpoint->epram);
}
theEndpoint->initted = eobool_true;
#define EO_NVSET_INIT_EVERY_NV
#if defined(EO_NVSET_INIT_EVERY_NV)
{ // put parenthesis to create a new scope and avoid errors in non c99 environments as windows
EOnv thenv = {0};
uint16_t k = 0;
EOnv_rom_t* rom = NULL;
uint8_t* ram = NULL;
uint16_t nvars = theEndpoint->epnvsnumberof;
eOipv4addr_t ip = theBoard->ipaddress;
uint8_t brd = theBoard->boardnum; // local or 0, 1, 2, 3
eOnvID32_t id32 = EOK_uint32dummy;
uint32_t prog = 0;
eObool_t proxied = eobool_false;
eOvoid_fp_cnvp_cropdesp_t onsay = NULL;
EOVmutexDerived* mtx2use = NULL;
if(eo_nvset_protection_one_per_board == p->protection)
{
mtx2use = theBoard->mtx_board;
}
else if(eo_nvset_protection_one_per_endpoint == p->protection)
{
mtx2use = theEndpoint->mtx_endpoint;
}
// else if eo_nvset_protection_one_per_netvar ... eval foreach k
for(k=0; k<nvars; k++)
{
if(eo_nvset_protection_one_per_netvar == p->protection)
{
//#warning -> think of uint32 and void* maybe use uint64
uint32_t** addr = eo_vector_At(theEndpoint->themtxofthenvs, k);
mtx2use = (EOVmutexDerived*) (*addr);
}
prog = k;
// - 0. the id32
id32 = eoprot_endpoint_prognum2id(brd, ep08, prog);
if(EOK_uint32dummy == id32)
{
continue;
}
// - 0+. proxied?
proxied = eoprot_variable_is_proxied(brd, id32);
// - 0++ onsay
onsay = eoprot_onsay_endpoint_get(ep08);
// - 1. the rom
rom = (EOnv_rom_t*) eoprot_variable_romof_get(brd, id32);
// - 2. the ram
ram = (uint8_t*) eoprot_variable_ramof_get(brd, id32);
// - 3. the mtx
mtx2use = mtx2use;
// - load everything into the nv
eo_nv_hid_Load( &thenv,
ip,
brd,
proxied,
id32,
onsay,
rom,
ram,
mtx2use
);
eo_nv_Init(&thenv);
}
} // put parenthesis to create a new scope and avoid errors in non c99 environments as windows
#endif //EO_NVSET_INIT_EVERY_NV
return(eores_OK);
}
