sngks32cintrctl.c

Vxworks下BSP源码

/* sngks32cIntrCtl.c - Samsung KS32C interrupt controller driver */

/* Copyright 1984-2001 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01c,02oct01,m_h  race condition
01b,26apr01,m_h  convert tabs to spaces for readability
01a,12apr01,m_h  created from snds100 template.
*/

/*

DESCRIPTION

This module implements interrupt controller driver for Samsung's KS32C50100
microprocessor which is an ARM based processor with several integrated 
peripherals.  It has an interrupt controller, two 32-bit timers, one 
Ethernet controller, two HDLC controllers, one IIC controller, general 
purpose I/O ports, and a 2-channel DMA controller.

The KS32C interrupt controller is a simple, generic interrupt controller
that manages 21 levels of interrupts from various sources internal to the
microprocessor and external to it.  For external interrupts are supported.
The interrupt controller has control and pending status registers, mask
register and supports level-sensitive interrupts.  This library provides
the routines to manage interrupts multiplexed by the KS32C interrupt controller.

The KS32C interrupt controller registers used by this driver are described
below under the symbolic names used herein.

SNGKS32C_INTENB (write): this is the mask register described in the
KS32C50100 Users' Manual.  When this register is written, each data bit 
that is clear (0) causes the corresponding interrupt to be enabled.
Each bit that is set (1) causes the corresponding interrupt to be disabled.

SNGKS32C_INTPEND (read): this is the interrupt pending register.
When this register is read, each data bit that is set (1) indicates that
an interrupt is pending from the corresponding source. Level 20 is the
highest priority and level 0 is the lowest.

SNGKS32C_INTMODE (write): this register is used to configure the interrupts
in FIQ or IRQ mode.  Each bit set in this register configures the corresponding
interrupt as FIQ.  Otherwise the interrupt is treated as IRQ.  VxWorks
does not support the high priority FIQ mode of interrupts.  Hence all the
interrupts have to be configured in IRQ mode.

The interrupt priority registers can be used to change the priorities
of the interrupts from the default settings.  This feature is not
supported in this driver.  All the interrupts are set with the default
priority ordering.

The number of interrupts supported by the device i.e. the number of
valid bits in the SNGKS32C_INTPEND register (21), is specified by
SNGKS32C_INTNUMLEVELS.

sngks32carm7.h has defined the addresses of the controller chips registers:
SNGKS32C_INTENB, SNGKS32C_INTDIS and SNGKS32C_INTPEND and also the 
driver constants SNGKS32C_INTMASK_VAL, SNGKS32C_INTNUMLEVELS.

The chip registers are memory-mapped at specified addresses internal to
the processor.  32-bit accesses can be made to these register locations.
The macros SNGKS32C_INT_REG_READ and SNGKS32C_INT_REG_WRITE are used to
access these registers.

The BSP will initialize this driver in sysHwInit2(), after initializing
the main interrupt library, usually intLibInit().  The initialization
routine, sngks32cIntDevInit() will setup the interrupt controller device,
it will mask off all individual interrupt sources and then set the
interrupt level to enable all interrupts.  See sngks32cIntDevInit for more
information.

All of the functions in this library are global.  This allows them to
be used by the BSP if it is necessary to create wrapper routines or to
incorporate several drivers together as one.

SEE ALSO
<Samsung KS32C50100 User's Manual>

*/

#include "vxWorks.h"
#include "config.h"
#include "intLib.h"

#include "sngks32c.h"


#include "myDef.h"

void myDelay();



#if !defined (AT91C_AIC_IPR) || !defined (AT91C_AIC_IECR) || \
    !defined (AT91C_AIC_IDCR) || !defined (AT91C_AIC_ICCR) || \
    !defined (AT91C_AIC_ISCR) || !defined (AT91C_INTNUMLEVELS)
#   error missing AT91C interrupt definitions
#endif


/* hardware access methods */
#ifndef AT91C_INT_REG_READ
#   define AT91C_INT_REG_READ(x,result) \
        ((result) = *(volatile UINT32 *)(x))
#endif    /*AT91C_INT_REG_READ*/

#ifndef AT91C_INT_REG_WRITE
#   define AT91C_INT_REG_WRITE(x,data) \
        (*((volatile UINT32 *)(x)) = (data))
#endif /*AT91C_INT_REG_WRITE*/



/* Local data */

/*
 * A mask word.  Bits are set in this word when a specific level
 * is enabled. It is used to mask off individual levels that have
 * not been explicitly enabled.
 */

LOCAL UINT32 at91cIntLvlMask;

/* forward declarations */

STATUS    at91cIntLvlVecChk  (int*, int*);
STATUS    at91cIntLvlEnable  (int);
STATUS    at91cIntLvlDisable (int);


STATUS at91cIntAck(int level);


/*******************************************************************************
*
* at91cIntDevInit - initialize the interrupt controller
*
* This routine will initialize the interrupt controller device, disabling all
* interrupt sources.  It will also connect the device driver specific routines
* into the architecture level hooks.  If the BSP needs to create a wrapper
* routine around any of the arhitecture level routines, it should install the
* pointer to the wrapper routine after calling this routine.
*
* RETURNS: N/A
*/

void at91cIntDevInit (void)
    {
    /* install the driver routines in the architecture hooks */

	UCHAR i;

    sysIntLvlVecChkRtn     = at91cIntLvlVecChk;
    sysIntLvlEnableRtn     = at91cIntLvlEnable;
    sysIntLvlDisableRtn    = at91cIntLvlDisable;


/*    sysIntLvlVecAckRtn	=at91cIntAck;	*/
    at91cIntLvlMask  = 0x0;     /* all sources disabled */
    for(i=0;i<32;i++)
	{
		*((volatile UINT32 *)(0xfffff000+i*4))=0x20;  /*所有改为边沿触发*/
		*(volatile UINT32 *)(0xfffff080+i*4)=i;
	}
    *(volatile UINT32 *)0xfffff004=0;
    *(volatile UINT32 *)0xfffff060=0;	


	

    at91cIntLvlMask  = 0x0;     /* all sources disabled */
    AT91C_INT_REG_WRITE (AT91C_AIC_IDCR, ~at91cIntLvlMask);
    AT91C_INT_REG_WRITE (AT91C_AIC_ICCR, ~at91cIntLvlMask);

    }

/*******************************************************************************
*
* at91cIntLvlVecChk - check for and return any pending interrupts
*
* This routine interrogates the hardware to determine the highest priority
* interrupt pending.  It returns the vector associated with that interrupt, and
* also the interrupt priority level prior to the interrupt (not the
* level of the interrupt).  The current interrupt priority level is then
* raised to the level of the current interrupt so that only higher priority
* interrupts will be accepted until this interrupt is finished.
*
* The return value ERROR indicates that no pending interrupt was found and
* that the level and vector values were not returned.
*
* RETURNS: OK or ERROR if no interrupt is pending.
*/

STATUS  at91cIntLvlVecChk
    (
    int* pLevel,  /* ptr to receive old interrupt level */
    int* pVector  /* ptr to receive current interrupt vector */
    )
    {
	UINT32 temp;


/*
*(volatile UINT16 *)0x40000000 = 0;
*(volatile UINT16 *)0x40000040 = 0x0105;
*/
/*LED REG0*/



/*debug*/	myXXX++;
	

	if((*(volatile UINT32*)AT91C_AIC_IPR&*(volatile UINT32*)AT91C_AIC_IMR) ==0) return ERROR;
	*(volatile UINT32*)AT91C_AIC_EOICR=0;						
	temp=*(volatile UINT32*)AT91C_AIC_IVR;
	*pVector=*(volatile UINT32*)AT91C_AIC_ISR;
	*(volatile UINT32*)AT91C_AIC_EOICR=0;						
	*(volatile UINT32*)AT91C_AIC_ICCR=(1<<(*pVector));	
        return OK;

   }

/*******************************************************************************
*
* at91cIntLvlEnable - enable a single interrupt level
*
* Enable a specific interrupt level.  The enabled level will be allowed to
* generate an interrupt, when the overall interrupt level is set below the
* specified level.  Without being enabled, the interrupt is blocked regardless
* of the overall interrupt level setting.
*
* RETURNS: OK or ERROR if the specified level cannot be enabled.
*/

STATUS  at91cIntLvlEnable
    (
    int level  /* level to be enabled */
    )
    {
    int key;

    if (level < 0 ||
        level >= AT91C_INTNUMLEVELS)
        return ERROR;

    /* clear bit in mask register */
    key = intLock ();		
    at91cIntLvlMask |= ((1 << level));
    AT91C_INT_REG_WRITE (AT91C_AIC_IECR, at91cIntLvlMask);
    intUnlock (key);			

    return OK;
    }

/*******************************************************************************
*
* at91cIntLvlDisable - disable a single interrupt level
*
* Disable a specific interrupt level.  The disabled level is prevented
* from generating an interrupt even if the overall interrupt level is set
* below the specified level.
*
* RETURNS: OK or ERROR, if the specified interrupt level cannot be disabled.
*/

STATUS  at91cIntLvlDisable
    (
    int level  /* level to be disabled */
    )
    {
    int key;

    if (level < 0 ||
        level >= AT91C_INTNUMLEVELS)
        return ERROR;

    /* set bit in disable register */
    key = intLock ();
    at91cIntLvlMask &= ~(1 << level);
    AT91C_INT_REG_WRITE (AT91C_AIC_IDCR, 1<<level);
    intUnlock (key);


    return OK;
    }


STATUS at91cIntAck(int level)
{
	return;
}


#if 0
void myDelay()
{
	int i;
	
	*(volatile UINT32 *)0xfffff800 = 0x35;
	*(volatile UINT32 *)0xfffff810 = 0x35;
	
	while(1)
	{
	*(volatile UINT32 *)0xfffff834 = 0x35;/*lit*/
	
	for(i=0;i<1000000;i++);
	
	*(volatile UINT32 *)0xfffff830 = 0x35;
	
	for(i=0;i<1000000;i++);
	
	}
}	
#endif