void InitContinuations( struct netif *pNetIf )
{
InterruptTaskContinuation.InitializeCallback( (HAL_CALLBACK_FPN)STM32F4_ETH_LWIP_recv, (void*)pNetIf );
LwipUpTimeCompletion.InitializeForUserMode( (HAL_CALLBACK_FPN)lwip_network_uptime_completion, (void*)pNetIf );
LwipUpTimeCompletion.EnqueueDelta64( 2000000 );
}
void HAL_COMPLETION::EnqueueTicks( UINT64 EventTimeTicks )
{
NATIVE_PROFILE_PAL_ASYNC_PROC_CALL();
ASSERT(EventTimeTicks != 0);
GLOBAL_LOCK(irq);
this->EventTimeTicks = EventTimeTicks;
#if defined(_DEBUG)
this->Start_RTC_Ticks = HAL_Time_CurrentTicks();
#endif
HAL_COMPLETION* ptr = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();
HAL_COMPLETION* ptrNext;
for(;(ptrNext = (HAL_COMPLETION*)ptr->Next()); ptr = ptrNext)
{
if(EventTimeTicks < ptr->EventTimeTicks) break;
}
g_HAL_Completion_List.InsertBeforeNode( ptr, this );
if(this == g_HAL_Completion_List.FirstNode())
{
HAL_Time_SetCompare( EventTimeTicks );
}
}
void InitContinuations( struct netif *pNetIf )
{
InterruptTaskContinuation.InitializeCallback( (HAL_CALLBACK_FPN)LPC24XX_EMAC_lwip_recv, pNetIf );
LwipUpTimeCompletion.InitializeForUserMode( (HAL_CALLBACK_FPN)lwip_network_uptime_completion, pNetIf );
LwipUpTimeCompletion.EnqueueDelta64( 2000000 );
}
void InitContinuations( struct netif* pNetIf )
{
InterruptTaskContinuation.InitializeCallback( (HAL_CALLBACK_FPN)enc28j60_lwip_interrupt, &g_ENC28J60_NetIF );
LwipUpTimeCompletion.InitializeForUserMode( (HAL_CALLBACK_FPN)lwip_network_uptime_completion, pNetIf );
LwipUpTimeCompletion.EnqueueDelta64( 500000 );
}
/*----------------------------------------------------------------------*
rtp_thread_spawn
*----------------------------------------------------------------------*/
int rtp_thread_spawn (RTP_HANDLE * newThread,
RTP_ENTRY_POINT_FN entryPoint,
const char * name,
int stackSizeIndex,
int priorityIndex,
void * userData)
{
PIFACE pi;
int * index = (int *) userData;
if ((rtp_strcmp(name, "ip interpret") == 0) && !IPTaskInitialized[*index])
{
IPTaskInitialized[*index] = 1;
IPTaskContinuation[*index].InitializeCallback((HAL_CALLBACK_FPN) entryPoint, userData);
}
else if ((rtp_strcmp(name, "timer comp") == 0) && !TimerTaskCompInitialized)
{
TimerTaskCompInitialized = 1;
TimerTaskCompletion.InitializeForUserMode((HAL_CALLBACK_FPN) entryPoint, userData);
TimerTaskCompletion.EnqueueDelta(cfg_protocol_data.timer_freq * 1000);
}
else if ((rtp_strcmp(name, "timer cont") == 0) && !TimerTaskContInitialized)
{
TimerTaskContInitialized = 1;
TimerTaskContinuation.InitializeCallback((HAL_CALLBACK_FPN) entryPoint,userData);
}
else if ((rtp_strcmp(name, "interrupt task") == 0) && !InterruptTaskContInitialized[*index])
{
pi = (PIFACE) &ifaces[*index];
if (!pi)
{
return -1;
}
InterruptTaskContInitialized[*index] = 1;
InterruptTaskContinuation[*index].InitializeCallback((HAL_CALLBACK_FPN) entryPoint,pi);
}
else if ((rtp_strcmp(name, "dhcp") == 0) && !DHCPTaskInitialized)
{
DHCPTaskInitialized = 1;
DHCPTaskContinuation.InitializeCallback((HAL_CALLBACK_FPN) entryPoint,userData);
}
return (0);
}
void Events_SetBoolTimer( BOOL* TimerCompleteFlag, UINT32 MillisecondsFromNow )
{
NATIVE_PROFILE_PAL_EVENTS();
// we assume only 1 can be active, abort previous just in case
g_Events_BoolTimerCompletion.Abort();
if(TimerCompleteFlag)
{
g_Events_BoolTimerCompletion.InitializeForISR( local_Events_SetBoolTimer_Callback, TimerCompleteFlag );
g_Events_BoolTimerCompletion.EnqueueDelta( MillisecondsFromNow * 1000 );
}
}
BOOL ENC28J60_LWIP_Driver::Close( ENC28J60_LWIP_DRIVER_CONFIG* config, int index )
{
NATIVE_PROFILE_HAL_DRIVERS_ETHERNET();
if(config == NULL) return FALSE;
LwipUpTimeCompletion.Abort();
netif_set_link_down( &g_ENC28J60_NetIF );
netif_set_down( &g_ENC28J60_NetIF );
netif_remove( &g_ENC28J60_NetIF );
/* Disable the INTERRUPT pin */
CPU_GPIO_EnableInputPin2(config->INT_Pin,
FALSE, /* Glitch filter enable */
NULL, /* ISR */
0, /* minor number */
GPIO_INT_NONE, /* Interrupt edge */
RESISTOR_PULLUP); /* Resistor State */
InterruptTaskContinuation.Abort();
LwipNetworkStatus = FALSE;
enc28j60_lwip_close( &g_ENC28J60_NetIF );
memset(&g_ENC28J60_NetIF, 0, sizeof(g_ENC28J60_NetIF));
return TRUE;
}
void lwip_network_uptime_completion(void *arg)
{
NATIVE_PROFILE_PAL_NETWORK();
BOOL status = ENET_PHY_lwip_get_link_status( );
if(status != LwipNetworkStatus)
{
struct netif* pNetIf = (struct netif*)arg;
if(status)
{
SOCK_NetworkConfiguration *pNetCfg = &g_NetworkConfig.NetworkInterfaces[0];
ENET_PHY_lwip_set_link_speed( );
netif_set_up( pNetIf );
if(pNetCfg->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DHCP)
{
dhcp_start( pNetIf );
}
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, NETWORK_EVENT_FLAGS_IS_AVAILABLE );
}
else
{
netif_set_down( (struct netif*)arg );
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, 0);
}
LwipNetworkStatus = status;
}
LwipUpTimeCompletion.EnqueueDelta64( 2000000 );
}
void lwip_network_uptime_completion(void *arg)
{
NATIVE_PROFILE_PAL_NETWORK();
struct netif* pNetIf = (struct netif*)arg;
BOOL status = enc28j60_get_link_status(&g_ENC28J60_LWIP_Config.DeviceConfigs[0].SPI_Config);
if(status != LwipNetworkStatus)
{
if(status)
{
tcpip_callback((sys_timeout_handler)netif_set_link_up, (void*)pNetIf);
tcpip_callback((sys_timeout_handler)netif_set_up, (void*)pNetIf);
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, NETWORK_EVENT_FLAGS_IS_AVAILABLE );
}
else
{
tcpip_callback((sys_timeout_handler)netif_set_link_down, (void*)pNetIf);
tcpip_callback((sys_timeout_handler)netif_set_down, (void*)pNetIf);
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, 0);
}
Events_Set(SYSTEM_EVENT_FLAG_SOCKET);
Events_Set(SYSTEM_EVENT_FLAG_NETWORK);
LwipNetworkStatus = status;
}
LwipUpTimeCompletion.EnqueueDelta64( 2000000 );
}
BOOL Events_Initialize()
{
NATIVE_PROFILE_PAL_EVENTS();
g_Events_BoolTimerCompletion.Initialize();
SystemEvents = 0;
return TRUE;
}
void HAL_COMPLETION::DequeueAndExec()
{
NATIVE_PROFILE_PAL_ASYNC_PROC_CALL();
GLOBAL_LOCK(irq);
HAL_COMPLETION* ptr = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();
HAL_COMPLETION* ptrNext = (HAL_COMPLETION*)ptr->Next();
// waitforevents does not have an associated completion, therefore we need to verify
// than their is a next completion and that the current one has expired.
if(ptrNext)
{
ASSERT(ptr->EventTimeTicks <= HAL_Time_CurrentTicks());
Events_Set(SYSTEM_EVENT_FLAG_SYSTEM_TIMER);
ptr->Unlink();
//
// In case there's no other request to serve, set the next interrupt to be 356 years since last powerup (@25kHz).
//
HAL_Time_SetCompare( ptrNext->Next() ? ptrNext->EventTimeTicks : HAL_Completion_IdleValue );
#if defined(_DEBUG)
ptr->EventTimeTicks = 0;
#endif // defined(_DEBUG)
// let the ISR turn on interrupts, if it needs to
ptr->Execute();
}
}
void LargeBuffer_ManagedToNative( UINT16 marshalId, const BYTE* pData, size_t size )
{
if(!g_LargeBufferCompletionInit)
{
g_LargeBufferTestCompletion.InitializeForUserMode(LargeBufferTest_Completion, (void*)marshalId);
g_LargeBufferCompletionInit = TRUE;
}
if(!g_LargeBufferTestCompletion.IsLinked())
{
g_LargeBufferTestCompletion.EnqueueDelta(1000);
}
int len = (size > ARRAYSIZE(s_Data)) ? ARRAYSIZE(s_Data) : size;
for(int i=0; i<len; i++)
{
s_Data[i] = pData[size - 1 - i];
}
s_LastSize = len;
}
BOOL TEvents::TEvents_1()
{
UINT32 count = 100;
UINT32 signaled;
HAL_COMPLETION compObj;
compObj.InitializeForISR(CompletionCallback, NULL);
while (count--)
{
compObj.EnqueueDelta(1000*2);
signaled = Events_WaitForEvents(s_event,50);
if (signaled != s_event)
{
return false;
}
}
return true;
}
void HAL_COMPLETION::WaitForInterrupts( UINT64 Expire, UINT32 sleepLevel, UINT64 wakeEvents )
{
NATIVE_PROFILE_PAL_ASYNC_PROC_CALL();
const int c_SetCompare = 1;
const int c_ResetCompare = 2;
const int c_NilCompare = 4;
ASSERT_IRQ_MUST_BE_OFF();
HAL_COMPLETION* ptr = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();
int state;
if(ptr->Next() == NULL)
{
state = c_SetCompare | c_NilCompare;
}
else if(ptr->EventTimeTicks > Expire)
{
state = c_SetCompare | c_ResetCompare;
}
else
{
state = 0;
}
if(state & c_SetCompare) HAL_Time_SetCompare( Expire );
CPU_Sleep( (SLEEP_LEVEL)sleepLevel, wakeEvents );
if(state & (c_ResetCompare | c_NilCompare))
{
// let's get the first node again
// it could have changed since CPU_Sleep re-enabled interrupts
ptr = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();
HAL_Time_SetCompare( (state & c_ResetCompare) ? ptr->EventTimeTicks : HAL_Completion_IdleValue );
}
}
/*----------------------------------------------------------------------*
rtp_thrd_timer_completion
*----------------------------------------------------------------------*/
void rtp_thrd_timer_completion(void* arg)
{
NATIVE_PROFILE_PAL_NETWORK();
/* Schedule the timer task to run as a continuation */
if(!TimerTaskContinuation.IsLinked())
{
TimerTaskContinuation.Enqueue();
}
/////////////////////////////////////////////////////////////////
// DO NT CHANGE!
// KEEP the timeout IN SYNC with _CFG_TIMER_FREQ
TimerTaskCompletion.EnqueueDelta(cfg_protocol_data.timer_freq * 1000);
// DO NT CHANGE!
/////////////////////////////////////////////////////////////////
}
/*----------------------------------------------------------------------*
rtp_thread_kill
*----------------------------------------------------------------------*/
int rtp_thread_kill (RTP_HANDLE * newThread,
RTP_ENTRY_POINT_FN entryPoint,
const char * name,
int stackSizeIndex,
int priorityIndex,
void * userData)
{
int * index = (int *) userData;
if ((rtp_strcmp(name, "ip interpret") == 0) && IPTaskInitialized[*index])
{
IPTaskInitialized[*index] = 0;
IPTaskContinuation[*index].Abort();
}
else if ((rtp_strcmp(name, "timer comp") == 0) && TimerTaskCompInitialized)
{
TimerTaskCompInitialized = 0;
TimerTaskCompletion.Abort();
}
else if ((rtp_strcmp(name, "timer cont") == 0) && TimerTaskContInitialized)
{
TimerTaskContInitialized = 0;
TimerTaskContinuation.Abort();
}
else if ((rtp_strcmp(name, "interrupt task") == 0) && InterruptTaskContInitialized[*index])
{
InterruptTaskContInitialized[*index] = 0;
InterruptTaskContinuation[*index].Abort();
}
else if ((rtp_strcmp(name, "dhcp") == 0) && DHCPTaskInitialized)
{
DHCPTaskInitialized = 0;
DHCPTaskContinuation.Abort();
}
return (0);
}
/* ********************************************************************
open the loop back driver interface.
This routine opens a loop back device driver
The address of this function must be placed into the "devices" table in
iface.c either at compile time or before a device open is called.
******************************************************************** */
bool loop_lwip_open( struct netif *pNetIF )
{
NATIVE_PROFILE_HAL_DRIVERS_ETHERNET();
/* Now put in a dummy ethernet address get the ethernet address */
memcpy( pNetIF->hwaddr, phony_addr, ETHARP_HWADDR_LEN );
#if defined(FAKE_ASYNC_LOOPBACK_PROCESSING)
memset(&g_dummy_pbuf_chain,0,PBUF_CHAIN_DEPTH*sizeof(pbuf*));
g_fake_loopback_ISR.InitializeForISR( loop_lwip_send_packet, pNetIF );
#endif
/* JJM Possibly initialize Continuation here. loop_lwip_interrupt_continuation */
return( TRUE );
}
BOOL AT91_EMAC_LWIP_Driver::Close(void)
{
LwipUpTimeCompletion.Abort();
CPU_INTC_DeactivateInterrupt(AT91C_ID_EMAC);
InterruptTaskContinuation.Abort();
LwipNetworkStatus = 0;
netif_set_down( &g_AT91_EMAC_NetIF );
netif_remove( &g_AT91_EMAC_NetIF );
AT91_EMAC_LWIP_close( &g_AT91_EMAC_NetIF );
memset( &g_AT91_EMAC_NetIF, 0, sizeof g_AT91_EMAC_NetIF );
return TRUE;
}
BOOL LPC24XX_EMAC_LWIP_Driver::Close( )
{
LwipUpTimeCompletion.Abort();
/* Disable the interrupt */
CPU_INTC_DeactivateInterrupt(LPC24XX_VIC::c_IRQ_INDEX_EMAC);
InterruptTaskContinuation.Abort();
LwipNetworkStatus = 0;
netif_set_down( &g_LPC24XX_EMAC_NetIF );
netif_remove( &g_LPC24XX_EMAC_NetIF );
LPC24XX_EMAC_lwip_close( &g_LPC24XX_EMAC_NetIF );
memset( &g_LPC24XX_EMAC_NetIF, 0, sizeof g_LPC24XX_EMAC_NetIF);
return TRUE;
}
BOOL SH7264_SMSC_LWIP_Driver::Close(void)
{
LwipUpTimeCompletion.Abort();
//CPU_INTC_DeactivateInterrupt(SH7264C_ID_EDMAC);
CPU_INTC_DeactivateInterrupt(81);
InterruptTaskContinuation.Abort();
LwipNetworkStatus = 0;
netif_set_down( &g_SH7264_SMSC_NetIF );
netif_remove( &g_SH7264_SMSC_NetIF );
SH7264_SMSC_lwip_close( &g_SH7264_SMSC_NetIF );
memset( &g_SH7264_SMSC_NetIF, 0, sizeof g_SH7264_SMSC_NetIF);
return TRUE;
}
/* ********************************************************************
Transmit. a packet over the packet driver interface.
This routine is called when a packet needs sending. The packet contains a
full ethernet frame to be transmitted. The length of the packet is
provided.
Returns 0 if successful or errno if unsuccessful
******************************************************************** */
err_t loop_lwip_xmit( struct netif *pNetIF, struct pbuf *pPBuf)
{
NATIVE_PROFILE_HAL_DRIVERS_ETHERNET();
#if defined(FAKE_ASYNC_LOOPBACK_PROCESSING)
// store the packet and process it asynchronously by calling SOCKETS_RestartTcpIpProcessor()
// this would also require fakign an interrupt to 'receive' the packet
g_dummy_pbuf_chain[g_dummy_pbuf_current] = pPBuf;
if(++g_dummy_pbuf_current == PBUF_CHAIN_DEPTH) g_dummy_pbuf_current = 0;
g_fake_loopback_ISR.EnqueueDelta(10 * 1000);
SOCKETS_RestartTcpIpProcessor(10 * 1000);
#else
pNetIF->input( pPBuf, pNetIF );
#endif
return( ERR_OK );
}
void lwip_network_uptime_completion(void *arg)
{
NATIVE_PROFILE_PAL_NETWORK();
BOOL status = dm9161_lwip_GetLinkStatus( ) != 0;
if(!status)
{
status = dm9161_lwip_GetLinkStatus( ) != 0;
}
if(status != LWIP_STATUS_isset(LWIP_STATUS_LinkUp) )
{
struct netif* pNetIf = (struct netif*)arg;
if(status)
{
tcpip_timeout(1000, (sys_timeout_handler)netif_set_link_up, (void*)pNetIf);
tcpip_timeout(1000, (sys_timeout_handler)netif_set_up, (void*)pNetIf);
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, NETWORK_EVENT_FLAGS_IS_AVAILABLE );
}
else
{
tcpip_callback((sys_timeout_handler)netif_set_link_down, (void*)pNetIf);
tcpip_callback((sys_timeout_handler)netif_set_down, (void*)pNetIf);
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, 0);
}
Events_Set(SYSTEM_EVENT_FLAG_SOCKET);
Events_Set(SYSTEM_EVENT_FLAG_NETWORK);
LWIP_STATUS_setorclear( LWIP_STATUS_LinkUp, status );
}
LwipUpTimeCompletion.EnqueueDelta64( 2000000 );
}
BOOL Events_Uninitialize()
{
NATIVE_PROFILE_PAL_EVENTS();
g_Events_BoolTimerCompletion.Abort();
return TRUE;
}
void lwip_network_uptime_completion(void *arg)
{
NATIVE_PROFILE_PAL_NETWORK();
static BOOL isPhyPoweringUp = FALSE;
static int nAttempts = 0;
BOOL status;
/* Power up PHY and wait while it starts */
if (!LwipNetworkStatus && !isPhyPoweringUp)
{
eth_powerUpPhy(TRUE);
isPhyPoweringUp = TRUE;
LwipUpTimeCompletion.EnqueueDelta64( 2500000 );
nAttempts++;
return;
}
/* PHY should now have started, get the network status */
isPhyPoweringUp = FALSE;
status = eth_isPhyLinkValid(FALSE);
/* Check whether network status has changed */
if (status != LwipNetworkStatus)
{
struct netif* pNetIf = (struct netif*)arg;
/* Check status */
if (status)
{
/* Network is up, open ethernet driver */
SOCK_NetworkConfiguration *pNetCfg = &g_NetworkConfig.NetworkInterfaces[0];
STM32F4_ETH_LWIP_open(pNetIf);
netif_set_up( pNetIf );
if(pNetCfg->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DHCP)
{
dhcp_start( pNetIf );
}
nAttempts = 0;
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, NETWORK_EVENT_FLAGS_IS_AVAILABLE );
}
else
{
/* Network is down, close ethernet driver */
STM32F4_ETH_LWIP_close(FALSE);
netif_set_down( (struct netif*)arg );
Network_PostEvent( NETWORK_EVENT_TYPE__AVAILABILITY_CHANGED, 0);
}
/* Save new network status */
LwipNetworkStatus = status;
}
/* Power down PHY if network is down */
if (!LwipNetworkStatus)
{
eth_powerUpPhy(FALSE);
}
/* Schedule the next network status check */
if (LwipNetworkStatus || (nAttempts < 12) )
{
/* When network is up or has been up, check every 5 seconds */
LwipUpTimeCompletion.EnqueueDelta64( 2500000 );
}
else
{
/* When network is down, check only once every minute */
LwipUpTimeCompletion.EnqueueDelta64( 57500000 );
}
}
void DeInitContinuations()
{
LwipUpTimeCompletion.Abort();
InterruptTaskContinuation.Abort();
}
