BOOL SSL_ParseCertificate( const char* certificate, size_t certLength, const char* szPwd, X509CertData* certData )
{
if (!s_init_done) s_init_done=ssl_initialize_internal();
NATIVE_PROFILE_PAL_COM();
return ssl_parse_certificate_internal((void *)certificate,
TINYCLR_SSL_STRLEN(certificate),
NULL, (void*)certData);
}
BOOL SSL_Initialize()
{
NATIVE_PROFILE_PAL_COM();
memset(&g_SSL_Driver, 0, sizeof(g_SSL_Driver));
return TRUE;
}
void Sockets_NetduinoIP_Driver::ApplyConfigExtended()
{
NATIVE_PROFILE_PAL_COM();
if(!HAL_CONFIG_BLOCK::ApplyConfig( g_NetworkConfigExtended.GetDriverName(), &g_NetworkConfigExtended, sizeof(g_NetworkConfigExtended) ))
{
// save to the dynamic config section so that MFDeploy will be able to get the configuration.
SaveConfigExtended(0, NULL);
}
}
BOOL USART_Driver::Initialize( int ComPortNum, int BaudRate, int Parity, int DataBits, int StopBits, int FlowValue )
{
NATIVE_PROFILE_PAL_COM();
if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT))
{
//DEBUG_TRACE1(TRACE_ALWAYS, "ERROR: VTE_USART_Initialize: invalid ComPortNum %u\r\n", ComPortNum);
return FALSE;
}
{
GLOBAL_LOCK(irq);
HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];
if(!IS_USART_INITIALIZED(State))
{
State.fDataEventSet = FALSE;
State.PortIndex = ComPortNum;
// DO NOT INITIALIZE EVENT CALLBACKS HERE BECAUSE THEY CAN BE SET PRIOR TO INITIALIZE
State.Flag = 0; //clear all the flag bits
SET_USART_FLAG(State, HAL_USART_STATE::c_INITIALIZED | HAL_USART_STATE::c_TX_XON_STATE);
// If SW flow control on input is enabled
if (FlowValue & USART_FLOW_SW_IN_EN)
{
SET_USART_FLAG(State, HAL_USART_STATE::c_RX_SWFLOW_CTRL);
}
// If SW flow control on output is enabled
if (FlowValue & USART_FLOW_SW_OUT_EN)
{
SET_USART_FLAG(State, HAL_USART_STATE::c_TX_SWFLOW_CTRL);
}
// If HW flow control on input is enabled (HW output control is either totally in hardware or in HAL only)
if (FlowValue & USART_FLOW_HW_IN_EN)
{
SET_USART_FLAG(State, HAL_USART_STATE::c_RX_HWFLOW_CTRL);
}
State.RxBufferHighWaterMark = USART_BUFFER_HIGH_WATER_MARK( RX_USART_BUFFER_SIZE );
State.RxBufferLowWaterMark = USART_BUFFER_LOW_WATER_MARK ( RX_USART_BUFFER_SIZE );
State.TicksStartTxXOFF = 0;
State.TxQueue.Initialize( &TxBuffer_Com[ComPortNum * TX_USART_BUFFER_SIZE], TX_USART_BUFFER_SIZE);
State.RxQueue.Initialize( &RxBuffer_Com[ComPortNum * RX_USART_BUFFER_SIZE], RX_USART_BUFFER_SIZE );
return CPU_USART_Initialize( ComPortNum, BaudRate, Parity, DataBits, StopBits, FlowValue );
}
return TRUE;
}
}
void I2C_HAL_XACTION::Initialize( I2C_USER_CONFIGURATION& config, I2C_HAL_XACTION_UNIT** xActionUnits, size_t numXActionUnits )
{
NATIVE_PROFILE_PAL_COM();
m_xActionUnits = xActionUnits;
m_numXActionUnits = numXActionUnits;
m_current = 0;
m_clockRate = I2C_Internal_GetClockRate( config.ClockRate );
m_address = config.Address;
m_status = c_Status_Idle;
}
int USART_Driver::Read( int ComPortNum, char* Data, size_t size )
{
NATIVE_PROFILE_PAL_COM();
if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) {ASSERT(FALSE); return -1;}
if(Data == NULL ) return -1;
HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];
if ( IS_POWERSAVE_ENABLED(State) || (!IS_USART_INITIALIZED(State))) return -1;
int CharsRead = 0;
while(CharsRead < size)
{
// keep interrupts off only during pointer movement so we are atomic
GLOBAL_LOCK(irq);
size_t toRead;
UINT8 *Src;
toRead = size - CharsRead;
Src = State.RxQueue.Pop( toRead );
if( NULL == Src )
break;
// Check if FIFO level has just passed or gotten down to the low water mark
if(State.RxQueue.NumberOfElements() <= State.RxBufferLowWaterMark && (State.RxQueue.NumberOfElements() + toRead) > State.RxBufferLowWaterMark)
{
if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_SWFLOW_CTRL) )
{
// Clear our XOFF state
SendXON( ComPortNum, XOFF_FLAG_FULL );
}
if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_HWFLOW_CTRL) )
{
CPU_USART_RxBufferFullInterruptEnable(ComPortNum, TRUE);
}
}
memcpy(&Data[CharsRead], Src, toRead); // Copy data from queue to Read buffer
CharsRead += toRead;
}
{
GLOBAL_LOCK(irq);
State.fDataEventSet = FALSE;
if(!State.RxQueue.IsEmpty())
{
SetEvent( ComPortNum, USART_EVENT_DATA_CHARS );
}
}
return CharsRead;
}
BOOL SSL_Uninitialize()
{
NATIVE_PROFILE_PAL_COM();
BOOL retVal;
retVal = ssl_uninitialize_internal();
s_init_done = FALSE;
return retVal;
}
void SSL_ClearCertificateAuthority( int sslContextHandle )
{
NATIVE_PROFILE_PAL_COM();
if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) || (sslContextHandle < 0))
{
return;
}
memset(&g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificates[0], 0, sizeof(g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificates));
g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificateCount = 0;
}
void Sockets_NetduinoIP_Driver::SaveConfigExtended(INT32 index, SOCK_NetworkConfigurationExtended *cfg)
{
NATIVE_PROFILE_PAL_COM();
if(index >= NETWORK_INTERFACE_COUNT) return;
if(cfg)
{
memcpy( &g_NetworkConfigExtended.NetworkInterfaces[index], cfg, sizeof(SOCK_NetworkConfigurationExtended) );
}
HAL_CONFIG_BLOCK::UpdateBlockWithName(g_NetworkConfigExtended.GetDriverName(), &g_NetworkConfigExtended, sizeof(g_NetworkConfigExtended), TRUE);
}
void Sockets_NetduinoIP_Driver::SaveWirelessConfig(INT32 index, SOCK_NetworkConfiguration *cfg)
{
NATIVE_PROFILE_PAL_COM();
if(index >= WIRELESS_INTERFACE_COUNT) return;
if(cfg)
{
memcpy( &g_WirelessConfig.WirelessInterfaces[index], cfg, sizeof(SOCK_WirelessConfiguration) );
}
HAL_CONFIG_BLOCK::UpdateBlockWithName(g_WirelessConfig.GetDriverName(), &g_WirelessConfig, sizeof(g_WirelessConfig), TRUE);
}
void Sockets_NetduinoIP_Driver::ApplyWirelessConfig()
{
NATIVE_PROFILE_PAL_COM();
if(!s_wirelessInitialized)
{
if(!HAL_CONFIG_BLOCK::ApplyConfig( g_WirelessConfig.GetDriverName(), &g_WirelessConfig, sizeof(g_WirelessConfig) ))
{
SaveWirelessConfig(0, NULL);
}
s_wirelessInitialized = TRUE;
}
}
BOOL Sockets_NetduinoIP_Driver::Initialize()
{
NATIVE_PROFILE_PAL_COM();
if(!s_initialized)
{
ApplyConfig();
ApplyConfigExtended();
ApplyWirelessConfig();
s_initialized = TRUE;
}
}
BOOL SSL_ParseCertificate( const char* certificate, size_t certLength, const char* szPwd, X509CertData* certData )
{
NATIVE_PROFILE_PAL_COM();
RTCertificate rt_cert;
int ret;
rt_cert.cert = (X509Certificate)certificate;
rt_cert.size = certLength;
ret = secure_parse_certificate( (const RTCertificate *)&rt_cert, (RTCertData*)certData );
return (-1 != ret);
}
void I2C_Driver::StartNext()
{
NATIVE_PROFILE_PAL_COM();
I2C_HAL_XACTION* xAction = (I2C_HAL_XACTION*)g_I2C_Driver.m_xActions.FirstValidNode();
if(xAction == NULL)
{
return;
}
xAction->SetState( I2C_HAL_XACTION::c_Status_Processing );
I2C_Internal_XActionStart( xAction, false );
}
BOOL DebuggerPort_Flush( COM_HANDLE ComPortNum )
{
NATIVE_PROFILE_PAL_COM();
switch(ExtractTransport(ComPortNum))
{
case USART_TRANSPORT:
return USART_Flush( ConvertCOM_ComPort( ComPortNum ) );
case USB_TRANSPORT:
return USB_Flush( ConvertCOM_UsbStream(ComPortNum) );
case SOCKET_TRANSPORT:
return SOCKETS_Flush( ConvertCOM_SockPort(ComPortNum) );
}
return FALSE;
}
void CPU_ProtectCommunicationGPIOs( BOOL On )
{
NATIVE_PROFILE_PAL_COM();
switch(ExtractTransport(HalSystemConfig.DebugTextPort))
{
case USART_TRANSPORT:
CPU_USART_ProtectPins( ConvertCOM_ComPort(HalSystemConfig.DebugTextPort), On );
return ;
case USB_TRANSPORT:
CPU_USB_ProtectPins ( ConvertCOM_UsbController(HalSystemConfig.DebugTextPort), On );
return;
default:
return;
}
}
BOOL DebuggerPort_Uninitialize( COM_HANDLE ComPortNum )
{
NATIVE_PROFILE_PAL_COM();
switch(ExtractTransport(ComPortNum))
{
case USART_TRANSPORT:
return USART_Uninitialize( ConvertCOM_ComPort(ComPortNum) );
case USB_TRANSPORT:
USB_CloseStream( ConvertCOM_UsbStream(ComPortNum) );
return USB_Uninitialize( ConvertCOM_UsbController(ComPortNum) );
case SOCKET_TRANSPORT:
return SOCKETS_Uninitialize(ConvertCOM_SockPort(ComPortNum));
}
return FALSE;
}
int DebuggerPort_Write( COM_HANDLE ComPortNum, const char* Data, size_t size )
{
NATIVE_PROFILE_PAL_COM();
UINT32 transport = ExtractTransport(ComPortNum);
const char* dataTmp = Data;
INT32 totWrite = 0;
int retries = 100;
while(size > 0 && retries--)
{
int ret = 0;
switch(transport)
{
case USART_TRANSPORT:
ret = USART_Write( ConvertCOM_ComPort( ComPortNum ), dataTmp, size );
break;
case USB_TRANSPORT:
ret = USB_Write( ConvertCOM_UsbStream( ComPortNum ), dataTmp, size );
break;
case SOCKET_TRANSPORT:
ret = SOCKETS_Write( ConvertCOM_SockPort(ComPortNum), dataTmp, size );
break;
}
if(ret < 0)
{
break;
}
else if(ret == 0)
{
// if interrupts are off and our buffer is full then there is nothing we can do
if(!INTERRUPTS_ENABLED_STATE()) break;
Events_WaitForEvents(0, 1);
}
else
{
retries = 50; // reset retries
size -= ret;
dataTmp += ret;
totWrite += ret;
}
}
return totWrite;
}
BOOL DebuggerPort_Initialize( COM_HANDLE ComPortNum )
{
NATIVE_PROFILE_PAL_COM();
switch(ExtractTransport(ComPortNum))
{
case USART_TRANSPORT:
return USART_Initialize( ConvertCOM_ComPort(ComPortNum), HalSystemConfig.USART_DefaultBaudRate, USART_PARITY_NONE, 8, USART_STOP_BITS_ONE, USART_FLOW_NONE );
case USB_TRANSPORT:
if(USB_CONFIG_ERR_OK != USB_Configure( ConvertCOM_UsbController(ComPortNum), NULL )) return FALSE;
if(!USB_Initialize( ConvertCOM_UsbController(ComPortNum) )) return FALSE;
return USB_OpenStream( ConvertCOM_UsbStream(ComPortNum), USB_DEBUG_EP_WRITE, USB_DEBUG_EP_READ );
case SOCKET_TRANSPORT:
return SOCKETS_Initialize(ConvertCOM_SockPort(ComPortNum));
}
return FALSE;
}
void I2C_HAL_XACTION::Signal( UINT8 state, BOOL signal )
{
NATIVE_PROFILE_PAL_COM();
ASSERT_IRQ_MUST_BE_OFF();
m_status = state;
// this will automatically remove this node from the I2C_Driver
// list and place it in the global continuation list
if(signal) Enqueue();
// stop the flow if the transaction was not cancelled
// in whihc case the Stop command would have been issued already
if(!(m_status & c_Status_Cancelled))
{
I2C_Internal_XActionStop();
}
}
BOOL SSL_ExitContext( INT32 sslContextHandle )
{
NATIVE_PROFILE_PAL_COM();
BOOL ret;
if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) || (sslContextHandle < 0) || (g_SSL_Driver.m_sslContextArray[sslContextHandle].SslContext == NULL))
{
return FALSE;
}
ret = (0 == secure_sslexit(g_SSL_Driver.m_sslContextArray[sslContextHandle].SslContext));
memset(&g_SSL_Driver.m_sslContextArray[sslContextHandle], 0, sizeof(g_SSL_Driver.m_sslContextArray[sslContextHandle]));
g_SSL_Driver.m_sslContextCount --;
return ret;
}
void I2C_HAL_XACTION_UNIT::Initialize( I2C_WORD* src, I2C_WORD* dst, size_t size, BOOL fRead )
{
NATIVE_PROFILE_PAL_COM();
m_bytesToTransfer = size;
m_bytesTransferred = 0;
m_fRead = fRead;
m_dataQueue.Initialize( dst, size );
if(!fRead)
{
I2C_WORD* slot;
while((slot = m_dataQueue.Push()) != NULL)
{
*slot = *src++;
}
}
}
BOOL I2C_Driver::Enqueue( I2C_HAL_XACTION* xAction )
{
NATIVE_PROFILE_PAL_COM();
ASSERT(xAction);
if(xAction == NULL) return FALSE;
GLOBAL_LOCK(irq);
xAction->SetCallback( I2C_Driver::CompletedCallback );
xAction->SetState( I2C_HAL_XACTION::c_Status_Scheduled );
g_I2C_Driver.m_xActions.LinkAtBack( xAction );
StartNext();
return TRUE;
}
void I2C_Driver::CompletedCallback( void* arg )
{
NATIVE_PROFILE_PAL_COM();
I2C_HAL_XACTION* xAction = (I2C_HAL_XACTION*)arg;
// is the transaction is the last of a series of related
// transactions then free the bus for whoever comes next
if((
xAction->m_current == (xAction->m_numXActionUnits)) ||
xAction->CheckState( I2C_HAL_XACTION::c_Status_Aborted | I2C_HAL_XACTION::c_Status_Cancelled
))
{
// signal the waiting thread; since continuations are executed one at a time for every round
// of the scheduler there is no need to check for lost events on the waiting thread
Events_Set( SYSTEM_EVENT_I2C_XACTION );
StartNext();
}
}
BOOL SSL_Uninitialize()
{
NATIVE_PROFILE_PAL_COM();
BOOL result = TRUE;
for(int i = 0; i<ARRAYSIZE(g_SSL_Driver.m_sslContextArray); i++)
{
if(g_SSL_Driver.m_sslContextArray[i].SslContext != NULL)
{
SSL_ExitContext( i );
}
}
secure_exit();
g_SSL_Driver.m_sslContextCount = 0;
return result;
}
int DebuggerPort_Read( COM_HANDLE ComPortNum, char* Data, size_t size )
{
NATIVE_PROFILE_PAL_COM();
int ret = 0;
switch(ExtractTransport(ComPortNum))
{
case USART_TRANSPORT:
ret = USART_Read( ConvertCOM_ComPort( ComPortNum ), Data, size );
break;
case USB_TRANSPORT:
ret = USB_Read( ConvertCOM_UsbStream( ComPortNum ), Data, size );
break;
case SOCKET_TRANSPORT:
ret = SOCKETS_Read( ConvertCOM_SockPort(ComPortNum), Data, size );
break;
}
return ret;
}
BOOL I2C_Driver::Uninitialize()
{
NATIVE_PROFILE_PAL_COM();
GLOBAL_LOCK(irq);
if(!g_I2C_Driver.m_initialized)
{
return FALSE;
}
else
{
I2C_Internal_Uninitialize();
g_I2C_Driver.m_initialized = FALSE;
while(g_I2C_Driver.m_xActions.ExtractFirstNode());
return TRUE;
}
}
BOOL I2C_Driver::Initialize()
{
NATIVE_PROFILE_PAL_COM();
GLOBAL_LOCK(irq);
// initialize the PAL driver only once
if(!g_I2C_Driver.m_initialized)
{
g_I2C_Driver.m_xActions.Initialize();
g_I2C_Driver.m_initialized = TRUE;
}
// give always a chance to the HAL driver to initialize
// this will resurrect the GPIO pins in case some other
// entity has been using them
if(!I2C_Internal_Initialize()) return FALSE;
return TRUE;
}
void SSL_GetTime(DATE_TIME_INFO* pdt)
{
NATIVE_PROFILE_PAL_COM();
if(pdt == NULL) return;
if(g_SSL_Driver.m_pfnGetTimeFuncPtr != NULL)
{
g_SSL_Driver.m_pfnGetTimeFuncPtr(pdt);
}
else
{
pdt->year = 2009;
pdt->month = 1;
pdt->day = 1;
pdt->hour = 0;
pdt->minute = 0;
pdt->second = 0;
pdt->msec = 0;
pdt->dlsTime = 0;
pdt->tzOffset = -8 * 60 * 60;
}
}
BOOL SSL_AddCertificateAuthority( int sslContextHandle, const char* certificate, int cert_len, const char* szCertPwd )
{
NATIVE_PROFILE_PAL_COM();
SSL_Driver::SSL_Context *ctx;
RTCertificate *rtCert;
if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) ||
(sslContextHandle < 0) ||
(g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificateCount >= SSL_Driver::c_MaxCertificatesPerContext))
{
return FALSE;
}
ctx = &g_SSL_Driver.m_sslContextArray[sslContextHandle];
rtCert = &ctx->m_certificates[ctx->m_certificateCount];
ctx->m_certificateCount++;
rtCert->cert = (X509Certificate)certificate;
rtCert->size = cert_len;
return TRUE;
}
