HRESULT CLR_HW_Hardware::TransferAllInterruptsToApplicationQueue()
{
NATIVE_PROFILE_CLR_HARDWARE();
TINYCLR_HEADER();
while(true)
{
HalInterruptRecord* rec;
{
GLOBAL_LOCK(irq1);
rec = m_interruptData.m_HalQueue.Peek();
}
if(rec == NULL) break;
CLR_RT_ApplicationInterrupt* queueRec = (CLR_RT_ApplicationInterrupt*)CLR_RT_Memory::Allocate_And_Erase( sizeof(CLR_RT_ApplicationInterrupt), CLR_RT_HeapBlock::HB_CompactOnFailure ); CHECK_ALLOCATION(queueRec);
queueRec->m_interruptPortInterrupt.m_data1 = rec->m_data1;
queueRec->m_interruptPortInterrupt.m_data2 = rec->m_data2;
queueRec->m_interruptPortInterrupt.m_data3 = rec->m_data3;
queueRec->m_interruptPortInterrupt.m_time = rec->m_time;
queueRec->m_interruptPortInterrupt.m_context = (CLR_RT_HeapBlock_NativeEventDispatcher*)rec->m_context;
m_interruptData.m_applicationQueue.LinkAtBack( queueRec ); ++m_interruptData.m_queuedInterrupts;
{
GLOBAL_LOCK(irq2);
m_interruptData.m_HalQueue.Pop();
}
}
if(m_interruptData.m_queuedInterrupts == 0)
{
TINYCLR_SET_AND_LEAVE(CLR_E_NO_INTERRUPT);
}
TINYCLR_CLEANUP();
if(CLR_E_OUT_OF_MEMORY == hr)
{
// if there is no memory left discard all interrupts to avoid getting into a death spiral of OOM exceptions
{
GLOBAL_LOCK(irq3);
while(!m_interruptData.m_HalQueue.IsEmpty())
{
m_interruptData.m_HalQueue.Pop();
}
}
}
TINYCLR_CLEANUP_END();
}
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;
}
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 Events_Clear( UINT32 Events )
{
NATIVE_PROFILE_PAL_EVENTS();
GLOBAL_LOCK(irq);
SystemEvents &= ~Events;
}
BOOL USART_Driver::ConnectEventSink( int ComPortNum, int EventType, void* pContext, PFNUsartEvent pfnUsartEvtHandler, void** ppArg )
{
if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) return FALSE;
{
GLOBAL_LOCK(irq);
HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];
State.PortIndex = ComPortNum;
if(ppArg != NULL) *ppArg = (void*)ComPortNum;
if(EventType == USART_EVENT_TYPE_DATA)
{
State.UsartDataEventCallback = pfnUsartEvtHandler;
State.DataContext = pContext;
}
else if(EventType == USART_EVENT_TYPE_ERROR)
{
State.UsartErrorEventCallback = pfnUsartEvtHandler;
State.ErrorContext = pContext;
}
}
return TRUE;
}
BOOL USART_Driver::Uninitialize( int ComPortNum )
{
NATIVE_PROFILE_PAL_COM();
if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT))
{
return FALSE;
}
{
GLOBAL_LOCK(irq);
HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];
if (IS_USART_INITIALIZED(State))
{
State.fDataEventSet = FALSE;
State.PortIndex = ComPortNum;
CLEAR_USART_FLAG(State,HAL_USART_STATE::c_INITIALIZED);
return CPU_USART_Uninitialize( ComPortNum );
}
return TRUE;
}
}
BOOL MC9328MXL_AITC_Driver::ActivateInterrupt( UINT32 Irq_Index, BOOL Fast, HAL_CALLBACK_FPN ISR, void* ISR_Param, UINT8 Priority )
{
// figure out the interrupt
IRQ_VECTORING* IsrVector = IRQToIRQVector( Irq_Index ); if(!IsrVector) return FALSE;
{
GLOBAL_LOCK(irq);
MC9328MXL_AITC& AITC = MC9328MXL::AITC();
// disable this interrupt while we change it
AITC.INTDISNUM = IsrVector->Index;
// set the correct type
AITC.SetType( IsrVector->Index, Fast );
// set the correct priority
AITC.SetPriority( IsrVector->Index, Priority );
// set the vector
IsrVector->Handler.Initialize( ISR, ISR_Param );
// enable the interrupt if we have a vector
AITC.INTENNUM = IsrVector->Index;
}
return TRUE;
}
void LPC22XX_USART_Driver::TxBufferEmptyInterruptEnable( int ComPortNum, BOOL Enable )
{
GLOBAL_LOCK(irq);
LPC22XX_USART& USARTC = LPC22XX::UART(ComPortNum);
ASSERT(LPC22XX_USART_Driver::IsValidPortNum(ComPortNum));
if (Enable)
{
USARTC.SEL2.IER.UART_IER |= (LPC22XX_USART::UART_IER_THREIE);
char c;
for (int i=0; i<2; i++)
{
if (USART_RemoveCharFromTxBuffer( ComPortNum, c ))
{
WriteCharToTxBuffer( ComPortNum, c );
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
else
break;
}
}
else
{
USARTC.SEL2.IER.UART_IER &= ~(LPC22XX_USART::UART_IER_THREIE);
}
}
BOOL LPC22XX_GPIO_Driver::Uninitialize()
{
GLOBAL_LOCK(irq);
// TODO Implementation
return TRUE;
}
void AT91_GPIO_Driver::EnableOutputPin( GPIO_PIN pin, BOOL initialState )
{
UINT32 bitmask = 1 << PinToBit( pin );
UINT32 port = PinToPort( pin );
AT91_PIO &pioX = AT91::PIO (port);
GLOBAL_LOCK(irq);
pioX.PIO_PER = bitmask; // Enable PIO function
if(initialState)
pioX.PIO_SODR = bitmask;
else
pioX.PIO_CODR = bitmask;
pioX.PIO_OER = bitmask; // Enable Output
PIN_ISR_DESCRIPTOR& pinIsr = g_AT91_GPIO_Driver.m_PinIsr[ pin ];
pinIsr.m_intEdge = GPIO_INT_NONE;
pinIsr.m_isr = STUB_GPIOISRVector;
pinIsr.m_param = NULL;
}
BOOL LPC24XX_VIC_Driver::ActivateInterrupt( UINT32 Irq_Index, BOOL Fast, HAL_CALLBACK_FPN ISR, void* ISR_Param )
{
// figure out the interrupt
IRQ_VECTORING* IsrVector = IRQToIRQVector( Irq_Index ); if(!IsrVector) return FALSE;
{
GLOBAL_LOCK(irq);
LPC24XX_VIC& VIC = LPC24XX::VIC();
// disable this interrupt while we change it
VIC.INTENCLR = 1 << IsrVector->Index;
// set the vector
IsrVector->Handler.Initialize( ISR, ISR_Param );
// Use Vector Address register to identify the source of interrupt
VIC.VECTADDR[Irq_Index] = Irq_Index;
// enable the interrupt if we have a vector
VIC.INTENABLE = 1 << IsrVector->Index;
}
return TRUE;
}
void I2C_Driver::Cancel( I2C_HAL_XACTION* xAction, bool signal )
{
NATIVE_PROFILE_PAL_COM();
ASSERT(xAction);
if(xAction == NULL) return;
GLOBAL_LOCK(irq);
switch(xAction->GetState())
{
// only one xAction will efer be in processing for every call to Abort
case I2C_HAL_XACTION::c_Status_Processing:
I2C_Internal_XActionStop();
// fall through...
case I2C_HAL_XACTION::c_Status_Scheduled:
case I2C_HAL_XACTION::c_Status_Completed:
case I2C_HAL_XACTION::c_Status_Aborted:
xAction->Abort();
xAction->SetState(I2C_HAL_XACTION::c_Status_Cancelled);
StartNext();
break;
case I2C_HAL_XACTION::c_Status_Idle: // do nothing since we aren't enqueued yet
break;
}
}
/*---------------------------------------------------------------------------*/
int TTWAIN_SupportsCompressionType(TW_UINT16 comprType)
{
int rc;
TUINT32 size;
int found = FALSE;
TW_ENUMERATION *container = 0;
TW_HANDLE handle = 0;
if (!TTWAIN_IsCapCompressionSupported())
return FALSE;
rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)0, &size);
if (!rc || !size)
return FALSE;
handle = GLOBAL_ALLOC(GMEM_FIXED, size);
if (!handle)
return FALSE;
container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)container, 0);
if (!rc)
goto done;
found = TTWAIN_IsItemInList(container->ItemList, &comprType,
container->NumItems, DCItemSize[container->ItemType]);
found = TRUE;
done:
if (handle) {
GLOBAL_UNLOCK(handle);
GLOBAL_FREE(handle);
}
return found;
}
/*---------------------------------------------------------------------------*/
int TTWAIN_SupportsPixelType(TTWAIN_PIXTYPE pix_type)
{
TW_HANDLE handle;
TW_ENUMERATION *container;
int rc, found = FALSE;
TUINT32 size4data;
TW_UINT16 twPix;
twPix = PixType[pix_type].type;
rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)0, &size4data);
if (!rc)
return FALSE;
if (!size4data)
return FALSE;
handle = GLOBAL_ALLOC(GMEM_FIXED, size4data);
if (!handle)
return FALSE;
container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)container, 0);
if (!rc)
goto done;
found = TTWAIN_IsItemInList(container->ItemList, &twPix,
container->NumItems, DCItemSize[container->ItemType]);
done:
GLOBAL_UNLOCK(handle);
GLOBAL_FREE(handle);
return found;
}
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 );
}
}
BOOL LPC24XX_TIMER_Driver::Initialize( UINT32 Timer, HAL_CALLBACK_FPN ISR, void* ISR_Param )
{
ASSERT(Timer < c_MaxTimers);
GLOBAL_LOCK(irq);
if(g_LPC24XX_TIMER_Driver.m_configured[Timer] == TRUE) return FALSE;
//--//
if(ISR)
{
if(!CPU_INTC_ActivateInterrupt( LPC24XX_TIMER::getIntNo(Timer) , ISR, ISR_Param )) return FALSE;
}
LPC24XX_TIMER& TIMER = LPC24XX::TIMER( Timer );
TIMER.TCR = LPC24XX_TIMER::TCR_TEN;
//--//
g_LPC24XX_TIMER_Driver.m_configured[Timer] = TRUE;
return TRUE;
}
BOOL LPC24XX_TIMER_Driver::Uninitialize( UINT32 Timer )
{
ASSERT(Timer < c_MaxTimers);
GLOBAL_LOCK(irq);
if(g_LPC24XX_TIMER_Driver.m_configured[Timer] == FALSE) return FALSE;
//--//
if(!CPU_INTC_DeactivateInterrupt( LPC24XX_TIMER::getIntNo(Timer) )) return FALSE;
LPC24XX_TIMER& TIMER = LPC24XX::TIMER( Timer );
//Reset timer
TIMER.TCR = 0x2;
// disable Timer
TIMER.TCR = 0;
//--//
g_LPC24XX_TIMER_Driver.m_configured[Timer] = FALSE;
return TRUE;
}
BOOL Watchdog_LastOccurence( INT64& time, INT64& timeout, UINT32& assembly, UINT32& method, BOOL fSet )
{
GLOBAL_LOCK(irq);
Watchdog_Driver::WatchdogEvent last;
if(fSet)
{
last.Time = time;
last.Timeout = timeout;
last.Assembly = assembly;
last.Method = method;
}
BOOL fRes = Watchdog_Driver::LastOccurence( last, fSet );
if(!fSet && fRes)
{
time = last.Time;
timeout = last.Timeout;
assembly = last.Assembly;
method = last.Method;
}
return fRes;
}
void LPC22XX_USART_Driver::UART_IntHandler (void *param)
{
GLOBAL_LOCK(irq);
ASSERT(LPC22XX_USART_Driver::IsValidPortNum((UINT32)param));
char c;
UINT32 ComNum = (UINT32)param;
UINT32 i,rxcnt;
LPC22XX_USART& USARTC = LPC22XX::UART(ComNum);
volatile UINT32 IIR_Value;
volatile UINT32 LSR_Value;
// Read data from Rx FIFO
LSR_Value = USARTC.UART_LSR;
while (LSR_Value & LPC22XX_USART::UART_LSR_RFDR)
{
UINT8 rxdata = (UINT8 )USARTC.SEL1.RBR.UART_RBR;
rxcnt++;
if ( 0 == (LSR_Value &
(
LPC22XX_USART::UART_LSR_PEI |
LPC22XX_USART::UART_LSR_OEI |
LPC22XX_USART::UART_LSR_FEI
)
)
)
{
// No errors in Rx data
USART_AddCharToRxBuffer(ComNum, rxdata);
Events_Set( SYSTEM_EVENT_FLAG_COM_IN );
}
LSR_Value = USARTC.UART_LSR;
}
// Send up to 2 bytes of Tx data
for (i = 0; i <2; i++)
{
if (USART_RemoveCharFromTxBuffer( ComNum, c ))
{
WriteCharToTxBuffer( ComNum, c );
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
else
{
// Disable further TxBufferEmptyInterrupt. It will be
// enabled by the PAL uart driver when a character to the
// TxBuffer is added
TxBufferEmptyInterruptEnable( ComNum, FALSE );
break;
}
}
// Check if IIR read is required to clear the uart Rx interrupt
IIR_Value = USARTC.SEL3.IIR.UART_IIR;
}
void LPC24XX_USART_Driver::ProtectPins ( int ComPortNum, BOOL On )
{
ASSERT(LPC24XX_USART_Driver::IsValidPortNum(ComPortNum));
static BOOL COM1_PinsProtected = TRUE; // start out doing work on first unprotect
static BOOL COM2_PinsProtected = TRUE; // start out doing work on first unprotect
static BOOL COM3_PinsProtected = TRUE; // start out doing work on first unprotect
static BOOL COM4_PinsProtected = TRUE; // start out doing work on first unprotect
GLOBAL_LOCK(irq);
UINT32 SER_TXD;
UINT32 SER_RXD;
BOOL* PinsProtected;
switch(ComPortNum)
{
case c_COM1: SER_TXD = LPC24XX_USART::c_SER1_TXD; SER_RXD = LPC24XX_USART::c_SER1_RXD; PinsProtected = &COM1_PinsProtected; break;
case c_COM2: SER_TXD = LPC24XX_USART::c_SER2_TXD; SER_RXD = LPC24XX_USART::c_SER2_RXD; PinsProtected = &COM2_PinsProtected; break;
case c_COM3: SER_TXD = LPC24XX_USART::c_SER3_TXD; SER_RXD = LPC24XX_USART::c_SER3_RXD; PinsProtected = &COM3_PinsProtected; break;
case c_COM4: SER_TXD = LPC24XX_USART::c_SER4_TXD; SER_RXD = LPC24XX_USART::c_SER4_RXD; PinsProtected = &COM4_PinsProtected; break;
default: return;
}
if (On)
{
if(!*PinsProtected)
{
*PinsProtected = TRUE;
TxBufferEmptyInterruptEnable( ComPortNum, FALSE );
// TODO Add config for uart pin protected state
CPU_GPIO_EnableOutputPin( SER_TXD, RESISTOR_DISABLED );
RxBufferFullInterruptEnable( ComPortNum, FALSE );
// TODO Add config for uart pin protected state
CPU_GPIO_EnableOutputPin( SER_RXD, RESISTOR_DISABLED );
}
}
else
{
if(*PinsProtected)
{
*PinsProtected = FALSE;
// Connect pin to UART
CPU_GPIO_DisablePin( SER_TXD, RESISTOR_DISABLED, GPIO_ATTRIBUTE_NONE, GPIO_ALT_MODE_1 );
// Connect pin to UART
CPU_GPIO_DisablePin( SER_RXD, RESISTOR_DISABLED, GPIO_ATTRIBUTE_NONE, GPIO_ALT_MODE_1 );
TxBufferEmptyInterruptEnable( ComPortNum, TRUE );
RxBufferFullInterruptEnable( ComPortNum, TRUE );
}
}
}
BOOL AT91_AIC_Driver::ActivateInterrupt(UINT32 Irq_Index, BOOL Fast, HAL_CALLBACK_FPN ISR, void* ISR_Param)
{
// figure out the interrupt
IRQ_VECTORING* IsrVector = IRQToIRQVector( Irq_Index );
if(!IsrVector)
return FALSE;
AT91_AIC &aic = AT91::AIC();
GLOBAL_LOCK(irq);
// disable this interrupt while we change it
aic.AIC_IDCR= (0x01 << Irq_Index);
// Clear the interrupt on the interrupt controller
aic.AIC_ICCR = (0x01 << Irq_Index);
// set the vector
IsrVector->Handler.Initialize( ISR, ISR_Param );
// enable the interrupt if we have a vector
aic.AIC_IECR= 0x01<<Irq_Index;
return TRUE;
}
BOOL CPU_USART_Initialize( int ComPortNum, int BaudRate, int Parity, int DataBits, int StopBits, int FlowValue )
{
if (ComPortNum >= TOTAL_USART_PORT)
return FALSE;
if (Parity >= USART_PARITY_MARK)
return FALSE;
GLOBAL_LOCK(irq);
ptr_USART_TypeDef uart = g_STM32F4_Uart_Ports[ComPortNum];
UINT32 clk;
// enable UART clock
if (ComPortNum == 5)
{ // COM6 on APB2
RCC->APB2ENR |= RCC_APB2ENR_USART6EN;
clk = SYSTEM_APB2_CLOCK_HZ;
}
else if (ComPortNum == 0)
{ // COM1 on APB2
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
clk = SYSTEM_APB2_CLOCK_HZ;
}
else if (ComPortNum < 5)
{ // COM2-5 on APB1
RCC->APB1ENR |= RCC_APB1ENR_USART2EN >> 1 << ComPortNum;
clk = SYSTEM_APB1_CLOCK_HZ;
}
// ---------------------------------------------------------------------------
BOOL CPU_USB_ProtectPins(int core, BOOL On)
{
USB_CONTROLLER_STATE *State;
USBD_HANDLE_T hUsb = USB_HANDLE(core);
GLOBAL_LOCK(irq);
if (core >= MAX_USB_CORE) return FALSE;
State = USB_STATE(core);
if (On)
{
// Clear queues
for (int epNum = 1; epNum < State->EndpointCount; epNum++)
{
if (State->Queues[epNum] != NULL && State->IsTxQueue[epNum])
State->Queues[epNum]->Initialize();
}
#if 0 // Don't disconnect on CDC
// Make soft disconnect and set detached state
USBD_Connect(hUsb, 0); // Disconnect
State->DeviceState = USB_DEVICE_STATE_DETACHED;
USB_StateCallback(State);
#endif
} else {
// Make soft connect and set attached state
USBD_Connect(hUsb, 1); // Connect
State->DeviceState = USB_DEVICE_STATE_ATTACHED;
USB_StateCallback(State);
}
return TRUE;
}
BOOL __section(SectionForFlashOperations) SAM7X_BS_Driver::ChipReadOnly(void * context, BOOL On, UINT32 ProtectionKey )
{
// Internal setting for WriteProtection
AT91_BL_EFC &efc0 = AT91_BL_EFC::BL_EFC(0);
AT91_BL_EFC &efc1 = AT91_BL_EFC::BL_EFC(1);;
int i;
unsigned char command;
// Set Lock/Unlock command
command = (On == TRUE) ? AT91_BL_EFC::MC_FCMD_LOCK : AT91_BL_EFC::MC_FCMD_UNLOCK;
// Set EFC Mode Register - number of cycles during 1 microsecond
efc0.EFC_FMR = (efc0.EFC_FMR & ~AT91_BL_EFC::MC_FMCN) | ((SYSTEM_CYCLE_CLOCK_HZ / 1000000) << 16);
efc1.EFC_FMR = (efc1.EFC_FMR & ~AT91_BL_EFC::MC_FMCN) | ((SYSTEM_CYCLE_CLOCK_HZ / 1000000) << 16);
{
GLOBAL_LOCK(irq);
// Lock regions of EFC0 controller (1st FLASH block)
// Lock regions of EFC1 controller (2nd FLASH block)
for(i=0; i<16; i++ )
{
efc0.EFC_FCR = (AT91_BL_EFC::MC_KEY_VALUE | ((i*PAGES_IN_REGION) << 8) | command);
efc1.EFC_FCR = (AT91_BL_EFC::MC_KEY_VALUE | ((i*PAGES_IN_REGION) << 8) | command);
// Wait EFC ready
while( ((efc0.EFC_FSR & AT91_BL_EFC::MC_FRDY) != AT91_BL_EFC::MC_FRDY) &&
((efc1.EFC_FSR & AT91_BL_EFC::MC_FRDY) != AT91_BL_EFC::MC_FRDY) );
}
}
return TRUE;
}
BOOL LPC24XX_GPIO_Driver::Uninitialize()
{
GLOBAL_LOCK(irq);
// uninitialize the interrupt information
{
PIN_ISR_DESCRIPTOR* pinIsr = g_LPC24XX_GPIO_Driver.m_PinIsr;
LPC24XX_GPIOIRQ& GPIOIRQ = LPC24XX::GPIOIRQ();
for(int i = 0; i < c_MaxPins; i++)
{
pinIsr->m_completion.Abort();
pinIsr++;
}
// turn off interrupts
GPIOIRQ.IO0IntEnR = 0x00000000;
GPIOIRQ.IO0IntEnF = 0x00000000;
GPIOIRQ.IO2IntEnR = 0x00000000;
GPIOIRQ.IO2IntEnF = 0x00000000;
// flush pending interrupts
GPIOIRQ.IO0IntClr = 0xFFFFFFFF;
GPIOIRQ.IO2IntClr = 0xFFFFFFFF;
}
if(!CPU_INTC_DeactivateInterrupt( LPC24XX_VIC::c_IRQ_INDEX_EINT3 )) return FALSE;
return TRUE;
}
void LPC24XX_GPIO_Driver::EnableOutputPin( GPIO_PIN pin, BOOL initialState )
{
ASSERT(pin < c_MaxPins);
UINT32 Port, Bit;
LPC24XX_GPIO& GPIO = LPC24XX::GPIO();
GLOBAL_LOCK(irq);
// hal_printf( "EnableOutputPin: %08x\r\n", pin);
Port = PinToPort(pin);
Bit = PinToBit(pin);
// Set initial state before changing direction of the port pin
if(initialState) GPIO.Regs[Port].FIOSET_PX |= (0x1 << Bit);
else GPIO.Regs[Port].FIOCLR_PX |= (0x1 << Bit);
GPIO.Regs[Port].FIODIR_PX |= 0x1 << Bit;
// Disable ISR
PIN_ISR_DESCRIPTOR& PinIsr = g_LPC24XX_GPIO_Driver.m_PinIsr[pin];
PinIsr.m_intEdge = GPIO_INT_NONE;
PinIsr.m_isr = STUB_ISRVector;
PinIsr.m_param = (void*)(size_t)pin;
}
void USART_Driver::SetEvent( int ComPortNum, unsigned int event )
{
if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) return;
{
GLOBAL_LOCK(irq);
HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];
// Inorder to reduce the number of methods, we combine Error events and Data events in native code
// and the event codes go from 0 to 6 (0-4 for error events and 5-6 for data events).
// In managed code the event values come from to separate enums (one for errors and one for data events)
// Therefore the managed values are 0-4 for the error codes and 0-1 for data events. This code transforms
// the monolithic event codes for native code into the two separate sets for managed code
// (USART_EVENT_DATA_CHARS is the first data event code).
if(event < USART_EVENT_DATA_CHARS)
{
if(State.UsartErrorEventCallback != NULL)
{
State.UsartErrorEventCallback( State.ErrorContext, event );
}
}
else
{
if(!State.fDataEventSet && State.UsartDataEventCallback != NULL)
{
State.fDataEventSet = TRUE;
// convert the data event codes to 0-1 (expected by managed code)
State.UsartDataEventCallback( State.DataContext, event - USART_EVENT_DATA_CHARS);
}
}
}
}
void SH7619_EDMAC_interrupt(void *param)
{
long eesr0_val;
GLOBAL_LOCK(encIrq);
Events_Set( SYSTEM_EVENT_FLAG_SOCKET );
eesr0_val = EESR0;
if((eesr0_val & 0x00010000) == 0x00010000)
{
Flush_All(iface);
return;
}
// a Frame is transmitted
if((eesr0_val & 0x00200000) == 0x00200000)
{
//signal IP task that xmit has completed
rtp_net_invoke_output(iface, 1);
}
// Frame(s) received
if((eesr0_val & 0x00040000) == 0x00040000)
{
rtp_thrd_interrupt_continuation(iface->ctrl.index);
}
ECSR0 = 0x00000007;
EESR0 = 0x47FF0F9F;
}
/** Returns the number of nodes in this planning graph, including pnode.
*/
size_t infer_planner_node_num_dependency_nodes(std::shared_ptr<planner_node> pnode) {
std::lock_guard<recursive_mutex> GLOBAL_LOCK(global_query_lock);
std::set<pnode_ptr> seen_node_memo;
_fill_dependency_set(pnode, seen_node_memo);
return seen_node_memo.size();
}
void HAL_COMPLETION::Abort()
{
NATIVE_PROFILE_PAL_ASYNC_PROC_CALL();
GLOBAL_LOCK(irq);
HAL_COMPLETION* firstNode = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();
this->Unlink();
#if defined(_DEBUG)
this->Start_RTC_Ticks = 0;
#endif
if(firstNode == this)
{
UINT64 nextTicks;
if(g_HAL_Completion_List.IsEmpty())
{
//
// In case there's no other request to serve, set the next interrupt to be 356 years since last powerup (@25kHz).
//
nextTicks = HAL_Completion_IdleValue;
}
else
{
firstNode = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();
nextTicks = firstNode->EventTimeTicks;
}
HAL_Time_SetCompare( nextTicks );
}
}
