wcdma_sc.c

OMAP1030 处理器的ARM 侧硬件测试代码 OMAP1030 是TI的双核处理器

RES_Set((~SC_DSP_INT_MASK1_RES_VAL & SC_DSP_INT_MASK1_WR_MASK) >> 16);
RES_Set((~SC_DSP_INT_MASK1_RES_VAL & SC_DSP_INT_MASK1_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_DSP_INT_MASK2 =(~SC_DSP_INT_MASK2_RES_VAL & SC_DSP_INT_MASK2_WR_MASK);
if ( !((SC_DSP_INT_MASK2 & SC_DSP_INT_MASK2_WR_MASK) == (~SC_DSP_INT_MASK2_RES_VAL & SC_DSP_INT_MASK2_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_DSP_INT_MASK2_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_DSP_INT_MASK2_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_DSP_INT_MASK2_OFFSET) & 0xFFFF);
RES_Set((SC_DSP_INT_MASK2 & SC_DSP_INT_MASK2_WR_MASK) >> 16);
RES_Set((SC_DSP_INT_MASK2 & SC_DSP_INT_MASK2_WR_MASK) & 0xFFFF);
RES_Set((~SC_DSP_INT_MASK2_RES_VAL & SC_DSP_INT_MASK2_WR_MASK) >> 16);
RES_Set((~SC_DSP_INT_MASK2_RES_VAL & SC_DSP_INT_MASK2_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_DSP_INT_MASK3 =(~SC_DSP_INT_MASK3_RES_VAL & SC_DSP_INT_MASK3_WR_MASK);
if ( !((SC_DSP_INT_MASK3 & SC_DSP_INT_MASK3_WR_MASK) == (~SC_DSP_INT_MASK3_RES_VAL & SC_DSP_INT_MASK3_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_DSP_INT_MASK3_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_DSP_INT_MASK3_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_DSP_INT_MASK3_OFFSET) & 0xFFFF);
RES_Set((SC_DSP_INT_MASK3 & SC_DSP_INT_MASK3_WR_MASK) >> 16);
RES_Set((SC_DSP_INT_MASK3 & SC_DSP_INT_MASK3_WR_MASK) & 0xFFFF);
RES_Set((~SC_DSP_INT_MASK3_RES_VAL & SC_DSP_INT_MASK3_WR_MASK) >> 16);
RES_Set((~SC_DSP_INT_MASK3_RES_VAL & SC_DSP_INT_MASK3_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_ARM_INT_MASK0 =(~SC_ARM_INT_MASK0_RES_VAL & SC_ARM_INT_MASK0_WR_MASK);
if ( !((SC_ARM_INT_MASK0 & SC_ARM_INT_MASK0_WR_MASK) == (~SC_ARM_INT_MASK0_RES_VAL & SC_ARM_INT_MASK0_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_ARM_INT_MASK0_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK0_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK0_OFFSET) & 0xFFFF);
RES_Set((SC_ARM_INT_MASK0 & SC_ARM_INT_MASK0_WR_MASK) >> 16);
RES_Set((SC_ARM_INT_MASK0 & SC_ARM_INT_MASK0_WR_MASK) & 0xFFFF);
RES_Set((~SC_ARM_INT_MASK0_RES_VAL & SC_ARM_INT_MASK0_WR_MASK) >> 16);
RES_Set((~SC_ARM_INT_MASK0_RES_VAL & SC_ARM_INT_MASK0_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_ARM_INT_MASK1 =(~SC_ARM_INT_MASK1_RES_VAL & SC_ARM_INT_MASK1_WR_MASK);
if ( !((SC_ARM_INT_MASK1 & SC_ARM_INT_MASK1_WR_MASK) == (~SC_ARM_INT_MASK1_RES_VAL & SC_ARM_INT_MASK1_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_ARM_INT_MASK1_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK1_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK1_OFFSET) & 0xFFFF);
RES_Set((SC_ARM_INT_MASK1 & SC_ARM_INT_MASK1_WR_MASK) >> 16);
RES_Set((SC_ARM_INT_MASK1 & SC_ARM_INT_MASK1_WR_MASK) & 0xFFFF);
RES_Set((~SC_ARM_INT_MASK1_RES_VAL & SC_ARM_INT_MASK1_WR_MASK) >> 16);
RES_Set((~SC_ARM_INT_MASK1_RES_VAL & SC_ARM_INT_MASK1_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_ARM_INT_MASK2 =(~SC_ARM_INT_MASK2_RES_VAL & SC_ARM_INT_MASK2_WR_MASK);
if ( !((SC_ARM_INT_MASK2 & SC_ARM_INT_MASK2_WR_MASK) == (~SC_ARM_INT_MASK2_RES_VAL & SC_ARM_INT_MASK2_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_ARM_INT_MASK2_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK2_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK2_OFFSET) & 0xFFFF);
RES_Set((SC_ARM_INT_MASK2 & SC_ARM_INT_MASK2_WR_MASK) >> 16);
RES_Set((SC_ARM_INT_MASK2 & SC_ARM_INT_MASK2_WR_MASK) & 0xFFFF);
RES_Set((~SC_ARM_INT_MASK2_RES_VAL & SC_ARM_INT_MASK2_WR_MASK) >> 16);
RES_Set((~SC_ARM_INT_MASK2_RES_VAL & SC_ARM_INT_MASK2_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_ARM_INT_MASK3 =(~SC_ARM_INT_MASK3_RES_VAL & SC_ARM_INT_MASK3_WR_MASK);
if ( !((SC_ARM_INT_MASK3 & SC_ARM_INT_MASK3_WR_MASK) == (~SC_ARM_INT_MASK3_RES_VAL & SC_ARM_INT_MASK3_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_ARM_INT_MASK3_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK3_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_ARM_INT_MASK3_OFFSET) & 0xFFFF);
RES_Set((SC_ARM_INT_MASK3 & SC_ARM_INT_MASK3_WR_MASK) >> 16);
RES_Set((SC_ARM_INT_MASK3 & SC_ARM_INT_MASK3_WR_MASK) & 0xFFFF);
RES_Set((~SC_ARM_INT_MASK3_RES_VAL & SC_ARM_INT_MASK3_WR_MASK) >> 16);
RES_Set((~SC_ARM_INT_MASK3_RES_VAL & SC_ARM_INT_MASK3_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_SYS_DMA_MASK0 =(~SC_SYS_DMA_MASK0_RES_VAL & SC_SYS_DMA_MASK0_WR_MASK);
if ( !((SC_SYS_DMA_MASK0 & SC_SYS_DMA_MASK0_WR_MASK) == (~SC_SYS_DMA_MASK0_RES_VAL & SC_SYS_DMA_MASK0_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_SYS_DMA_MASK0_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_SYS_DMA_MASK0_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_SYS_DMA_MASK0_OFFSET) & 0xFFFF);
RES_Set((SC_SYS_DMA_MASK0 & SC_SYS_DMA_MASK0_WR_MASK) >> 16);
RES_Set((SC_SYS_DMA_MASK0 & SC_SYS_DMA_MASK0_WR_MASK) & 0xFFFF);
RES_Set((~SC_SYS_DMA_MASK0_RES_VAL & SC_SYS_DMA_MASK0_WR_MASK) >> 16);
RES_Set((~SC_SYS_DMA_MASK0_RES_VAL & SC_SYS_DMA_MASK0_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_SYS_DMA_MASK1 =(~SC_SYS_DMA_MASK1_RES_VAL & SC_SYS_DMA_MASK1_WR_MASK);
if ( !((SC_SYS_DMA_MASK1 & SC_SYS_DMA_MASK1_WR_MASK) == (~SC_SYS_DMA_MASK1_RES_VAL & SC_SYS_DMA_MASK1_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_SYS_DMA_MASK1_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_SYS_DMA_MASK1_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_SYS_DMA_MASK1_OFFSET) & 0xFFFF);
RES_Set((SC_SYS_DMA_MASK1 & SC_SYS_DMA_MASK1_WR_MASK) >> 16);
RES_Set((SC_SYS_DMA_MASK1 & SC_SYS_DMA_MASK1_WR_MASK) & 0xFFFF);
RES_Set((~SC_SYS_DMA_MASK1_RES_VAL & SC_SYS_DMA_MASK1_WR_MASK) >> 16);
RES_Set((~SC_SYS_DMA_MASK1_RES_VAL & SC_SYS_DMA_MASK1_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_MGS_DMA_MASK0 =(~SC_MGS_DMA_MASK0_RES_VAL & SC_MGS_DMA_MASK0_WR_MASK);
if ( !((SC_MGS_DMA_MASK0 & SC_MGS_DMA_MASK0_WR_MASK) == (~SC_MGS_DMA_MASK0_RES_VAL & SC_MGS_DMA_MASK0_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_MGS_DMA_MASK0_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_MGS_DMA_MASK0_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_MGS_DMA_MASK0_OFFSET) & 0xFFFF);
RES_Set((SC_MGS_DMA_MASK0 & SC_MGS_DMA_MASK0_WR_MASK) >> 16);
RES_Set((SC_MGS_DMA_MASK0 & SC_MGS_DMA_MASK0_WR_MASK) & 0xFFFF);
RES_Set((~SC_MGS_DMA_MASK0_RES_VAL & SC_MGS_DMA_MASK0_WR_MASK) >> 16);
RES_Set((~SC_MGS_DMA_MASK0_RES_VAL & SC_MGS_DMA_MASK0_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_MGS_DMA_MASK1 =(~SC_MGS_DMA_MASK1_RES_VAL & SC_MGS_DMA_MASK1_WR_MASK);
if ( !((SC_MGS_DMA_MASK1 & SC_MGS_DMA_MASK1_WR_MASK) == (~SC_MGS_DMA_MASK1_RES_VAL & SC_MGS_DMA_MASK1_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_MGS_DMA_MASK1_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_MGS_DMA_MASK1_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_MGS_DMA_MASK1_OFFSET) & 0xFFFF);
RES_Set((SC_MGS_DMA_MASK1 & SC_MGS_DMA_MASK1_WR_MASK) >> 16);
RES_Set((SC_MGS_DMA_MASK1 & SC_MGS_DMA_MASK1_WR_MASK) & 0xFFFF);
RES_Set((~SC_MGS_DMA_MASK1_RES_VAL & SC_MGS_DMA_MASK1_WR_MASK) >> 16);
RES_Set((~SC_MGS_DMA_MASK1_RES_VAL & SC_MGS_DMA_MASK1_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_GCC_LOAD_VAL =(~SC_GCC_LOAD_VAL_RES_VAL & SC_GCC_LOAD_VAL_WR_MASK);
if ( !((SC_GCC_LOAD_VAL & SC_GCC_LOAD_VAL_WR_MASK) == (~SC_GCC_LOAD_VAL_RES_VAL & SC_GCC_LOAD_VAL_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_GCC_LOAD_VAL_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_GCC_LOAD_VAL_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_GCC_LOAD_VAL_OFFSET) & 0xFFFF);
RES_Set((SC_GCC_LOAD_VAL & SC_GCC_LOAD_VAL_WR_MASK) >> 16);
RES_Set((SC_GCC_LOAD_VAL & SC_GCC_LOAD_VAL_WR_MASK) & 0xFFFF);
RES_Set((~SC_GCC_LOAD_VAL_RES_VAL & SC_GCC_LOAD_VAL_WR_MASK) >> 16);
RES_Set((~SC_GCC_LOAD_VAL_RES_VAL & SC_GCC_LOAD_VAL_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}
SC_PMT_SELECT =(~SC_PMT_SELECT_RES_VAL & SC_PMT_SELECT_WR_MASK);
if ( !((SC_PMT_SELECT & SC_PMT_SELECT_WR_MASK) == (~SC_PMT_SELECT_RES_VAL & SC_PMT_SELECT_WR_MASK)) ) {
global_test = 0;
//RES_Set(SC_PMT_SELECT_BAD_RESET_VALUE);
RES_Set(START_ARRAY_DATA);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_PMT_SELECT_OFFSET) >> 16);
RES_Set((WCDMA_CS_LB + WCDMA_SC_BASE_ADDR + SC_PMT_SELECT_OFFSET) & 0xFFFF);
RES_Set((SC_PMT_SELECT & SC_PMT_SELECT_WR_MASK) >> 16);
RES_Set((SC_PMT_SELECT & SC_PMT_SELECT_WR_MASK) & 0xFFFF);
RES_Set((~SC_PMT_SELECT_RES_VAL & SC_PMT_SELECT_WR_MASK) >> 16);
RES_Set((~SC_PMT_SELECT_RES_VAL & SC_PMT_SELECT_WR_MASK) & 0xFFFF);
RES_Set(END_ARRAY_DATA);
}

if (global_test == 1) {
RES_Set(TEST_OK);
 }
 }



/* This enables the RCI interrupt on the System Controller.  It enables
 * RCI intr 0 on the ARM interrupt 0 line.
 */
UWORD32 WCDMA_ScEnableRciInterrupt0(void)
{
   UWORD32 intMask;

   intMask = SC_ARM_INT_MASK0;                    /* read old mask */
   SC_ARM_INT_MASK0 = intMask | (0x1 << 17);      /* add RCI intr0 to old mask */

   return intMask;      /* return old mask in case user wants to restore it later */
}


/* Get the ARM Interrupt 0 status register's contents */
UWORD32 WCDMA_ScGetIntr0Status(void)
{
   return(SC_ARM_INT_STAT0);
}


//------------------------------------------------------------
// Enable (start) GCC counter
//------------------------------------------------------------
void WCDMA_ScEnableGcc(void)
{
  SC_GCC_CTL = 0x00000001;
}

//------------------------------------------------------------
// Arm GCC reset line
//------------------------------------------------------------
void WCDMA_ScArmGccReset(void)
{
  SC_GCC_RESET_ARM = 0x00000001;
}

//------------------------------------------------------------
// Wait for GCC reset to occur
//------------------------------------------------------------
void WCDMA_ScWaitGccReset(void)
{
  while (SC_GCC_RESET_ARM == 0x1); 
}

//------------------------------------------------------------
// Create interrupts from SC (Using Interrupt Generator 1)
//------------------------------------------------------------
void WCDMA_ScCreateInts(void)
{
  SC_ARM_INT_MASK0 = 0x02000000; // Map INTGEN1 int to ARM int line 0
  SC_INTGEN1_VAL   = 0x00000000;
  SC_INTGEN1_MASK  = 0xFFFFFE00; // Int's should occur at GCC = 0x0, 0x200, 0x400, ...
  SC_INTGEN_CTL    = 0x00000001;
}

//------------------------------------------------------------
// Stops interrupts from SC (Using Interrupt Generator 1)
//------------------------------------------------------------
void WCDMA_ScStopInts(void)
{
  SC_INTGEN_CTL    = 0x00000000;
}