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

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