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 ); } }