pka.c

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

/***************************************************************************** 
*            TEXAS INSTRUMENTS INCORPORATED PROPRIETARY INFORMATION          
*                          
*   Property of Texas Instruments                  
*   For  Unrestricted  Internal  Use  Only               
*   Unauthorized reproduction and/or distribution is strictly prohibited.      
*   This product is protected under copyright law and trade secret law         
*   as an unpublished work.                    
*   Created 2004, (C) Copyright 2004 Texas Instruments.  All rights reserved.
*                    
*   Filename:            pka.c
*                      
*   Description:         PKA lib
*                      
*   Author :         Adrian Dumitrascu [e-mail]
*                       
*	Project : 			Neptune
*                   
*****************************************************************************/  


/*****************************************************************************
* INCLUDE FILES
******************************************************************************
*/

#include "pka.h"
#include "global_types.h"
#include "mapping.h"
#include "testaccess.h"
#include "result.h"
/*****************************************************************************
* GLOBAL VARIABLES DECLARATIONS
******************************************************************************
*/

/*****************************************************************************
* LOCAL TYPES AND DEFINITIONS
******************************************************************************
*/

void PKA_SetMaskItEn(void) {
    PKA_MASK_REG |= (UWORD32)(1 << PKA_MASK_REG_ITEN_POS);
}

void PKA_ClearMaskItEn(void) {
    PKA_MASK_REG &= (UWORD32)(!(PKA_MASK_ITEN_MASK));
}

BOOL PKA_IsRunning(void) {
	BOOL temp = (BOOL) (PKA_FUNCTION_REG & PKA_FUNCTION_RUN_MASK);
	return temp;
}

void PKA_SetFunctionLShift() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_LSHIFT_POS);
}

void PKA_SetFunctionRShift() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_RSHIFT_POS);
}

void PKA_SetFunctionCopy() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_COPY_POS);
}

void PKA_SetFunctionCompare() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_COMP_POS);
}

void PKA_SetFunctionAdd() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_ADD_POS);
}

void PKA_SetFunctionSub() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_SUB_POS);
}

void PKA_SetFunctionMultiply() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_MULT_POS);
}

void PKA_SetFunctionDivide() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_DIVIDE_POS);
}

void PKA_SetFunctionExp4() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_EXP4_POS);
}

void PKA_SetFunctionExp2() {
	PKA_FUNCTION_REG = (UWORD32)(1 << PKA_FUNCTION_REG_EXP2_POS);
}

void PKA_SetFunctionRun() {
	PKA_FUNCTION_REG |= (UWORD32)(1 << PKA_FUNCTION_REG_RUN_POS);
}

void PKA_SetAPtr(UWORD32 addr) {
    PKA_APTR_REG = addr & PKA_APTR_APTR_MASK;
}

void PKA_SetBPtr(UWORD32 addr) {
    PKA_BPTR_REG = addr & PKA_BPTR_BPTR_MASK;
}

void PKA_SetCPtr(UWORD32 addr) {
    PKA_CPTR_REG = addr & PKA_CPTR_CPTR_MASK;
}

void PKA_SetDPtr(UWORD32 addr) {
    PKA_DPTR_REG = addr & PKA_DPTR_DPTR_MASK;
}

void PKA_SetALength(UWORD32 len) {
    PKA_ALENGTH_REG = len & PKA_ALENGTH_ALENGTH_MASK   ; 
}

void PKA_SetBLength(UWORD32 len) {
    PKA_BLENGTH_REG = len & PKA_BLENGTH_BLENGTH_MASK   ; 
}

void PKA_SetShift(UWORD32 b) {
    PKA_SHIFT_REG = b & PKA_SHIFT_SHIFT_MASK   ; 
}

void PKA_RShift(UWORD32 b) {
    PKA_SetShift(b);
	PKA_SetFunctionRShift();
	PKA_SetFunctionRun();
}

void PKA_LShift(UWORD32 b) {
    PKA_SetShift(b);
	PKA_SetFunctionLShift();
	PKA_SetFunctionRun();
}

void PKA_Copy(void) {
	PKA_SetFunctionCopy();
	PKA_SetFunctionRun();
}

void PKA_Compare(void) {
	PKA_SetFunctionCompare();
	PKA_SetFunctionRun();
}

void PKA_Exp2(void) {
	PKA_SetFunctionExp2();
	PKA_SetFunctionRun();
}

void PKA_Exp4(void) {
	PKA_SetFunctionExp4();
	PKA_SetFunctionRun();
}

void PKA_Add(void) {
	PKA_SetFunctionAdd();
	PKA_SetFunctionRun();
}

void PKA_Sub(void) {
	PKA_SetFunctionSub();
	PKA_SetFunctionRun();
}

void PKA_Multiply(void) {
	PKA_SetFunctionMultiply();
	PKA_SetFunctionRun();
}

void PKA_Divide(void) {
	PKA_SetFunctionDivide();
	PKA_SetFunctionRun();
}

cmpres CompareResult(void) {
	UWORD32 temp;
	temp = PKA_COMPARE_REG & PKA_COMPARE_MASK;
	switch ((int)(temp)) {
		case 1 : 
			return EQUAL;
		case 2 : 
			return INF  ;
		case 4 : 
			return SUP  ;
		default : 
			RES_Set(0xDEAD);
			return BADVALUE;
			break;
	};
}

void PKA_TestRAMAccess(void) {
	UWORD16 i;
	UWORD16 addr;
	UWORD32 temp;
    UWORD32 debug;

	srand(1234);  /*initialize random number generator*/ 
	for (i=0;i<11;i++) {
		addr = (1<<i)-1;
		temp = (UWORD32)(debug=rand());
		PKA_RAM(addr) = temp;
		if ((debug = PKA_RAM(addr)) != temp) RES_Set(0xA000+addr); //indicate in spy results what address is wrong (AXXX where xxx is the address)
	};

}

void PKA_TestRegistersResetValues(void) {
	BEGIN_RESET_MODULE();

    BEGIN_RESET_TEST(PKA_APTR_REG   ,32);TEST_FIELD_RESET(PKA_APTR_REG   ,APTR   ,32); END_RESET_TEST();
    BEGIN_RESET_TEST(PKA_BPTR_REG   ,32);TEST_FIELD_RESET(PKA_BPTR_REG   ,BPTR   ,32); END_RESET_TEST();
    BEGIN_RESET_TEST(PKA_CPTR_REG   ,32);TEST_FIELD_RESET(PKA_CPTR_REG   ,CPTR   ,32); END_RESET_TEST();
    BEGIN_RESET_TEST(PKA_DPTR_REG   ,32);TEST_FIELD_RESET(PKA_DPTR_REG   ,DPTR   ,32); END_RESET_TEST();
    BEGIN_RESET_TEST(PKA_ALENGTH_REG,32);TEST_FIELD_RESET(PKA_ALENGTH_REG,ALENGTH,32); END_RESET_TEST();
    BEGIN_RESET_TEST(PKA_BLENGTH_REG,32);TEST_FIELD_RESET(PKA_BLENGTH_REG,BLENGTH,32); END_RESET_TEST();
    BEGIN_RESET_TEST(PKA_SHIFT_REG  ,32);TEST_FIELD_RESET(PKA_SHIFT_REG  ,SHIFT  ,32); END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_FUNCTION_REG   ,32);
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,MULT     ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,ADD      ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,SUB      ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,RSHIFT   ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,LSHIFT   ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,DIVIDE   ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,COMP     ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,COPY     ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,EXP4     ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,EXP2     ,32); 
    TEST_FIELD_RESET(PKA_FUNCTION_REG   ,RUN      ,32); 
    END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_COMPARE_REG   ,32);
    TEST_FIELD_RESET(PKA_COMPARE_REG   ,AEQB      ,32); 
    TEST_FIELD_RESET(PKA_COMPARE_REG   ,AINFB     ,32); 
    TEST_FIELD_RESET(PKA_COMPARE_REG   ,ASUPB     ,32); 
    END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_MSW_REG   ,32);
    TEST_FIELD_RESET(PKA_MSW_REG   ,ADDR     ,32); 
    TEST_FIELD_RESET(PKA_MSW_REG   ,RESZ     ,32); 
    END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_DIVMSW_REG   ,32);
    TEST_FIELD_RESET(PKA_DIVMSW_REG   ,ADDR     ,32); 
    TEST_FIELD_RESET(PKA_DIVMSW_REG   ,RESZ     ,32); 
    END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_REV_REG   ,32);
    TEST_FIELD_RESET(PKA_REV_REG   ,REV     ,32); 
    END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_MASK_REG   ,32);
    TEST_FIELD_RESET(PKA_MASK_REG   ,ITEN        ,32); 
    TEST_FIELD_RESET(PKA_MASK_REG   ,SWRST       ,32); 
    TEST_FIELD_RESET(PKA_MASK_REG   ,AUTOIDLE    ,32); 
    END_RESET_TEST();

    BEGIN_RESET_TEST(PKA_SYSSTATUS_REG   ,32);
    TEST_FIELD_RESET(PKA_SYSSTATUS_REG   ,RSTDONE     ,32); 
    END_RESET_TEST();

	END_RESET_MODULE();
}

void PKA_TestRegistersAccess(void) {
	BEGIN_ACCESS_MODULE();

    BEGIN_RW_TEST(PKA_FUNCTION_REG  ,32);
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,MULT     ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,ADD      ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,SUB      ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,RSHIFT   ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,LSHIFT   ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,DIVIDE   ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,COMP     ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,COPY     ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,EXP4     ,32); 
    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,EXP2     ,32); 
//    RW_PREPARE_WRITE(PKA_FUNCTION_REG   ,RUN      ,32); 
    RW_WRITE(PKA_FUNCTION_REG  );
    RW_TEST_READ(PKA_FUNCTION_REG   ,MULT     ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,ADD      ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,SUB      ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,RSHIFT   ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,LSHIFT   ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,DIVIDE   ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,COMP     ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,COPY     ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,EXP4     ,32); 
    RW_TEST_READ(PKA_FUNCTION_REG   ,EXP2     ,32); 
//    RW_TEST_READ(PKA_FUNCTION_REG   ,RUN      ,32); 
    RW_WRITE_PREVIOUS_VALUE(PKA_FUNCTION_REG  );
    END_RW_TEST();

    BEGIN_RW_TEST(PKA_MASK_REG   ,32);
    RW_PREPARE_WRITE(PKA_MASK_REG   ,ITEN        ,32); 
//    RW_PREPARE_WRITE(PKA_MASK_REG   ,SWRST       ,32); 
    RW_PREPARE_WRITE(PKA_MASK_REG   ,AUTOIDLE    ,32); 
    RW_WRITE(PKA_MASK_REG  );
    RW_TEST_READ(PKA_MASK_REG   ,ITEN        ,32); 
//    RW_TEST_READ(PKA_MASK_REG   ,SWRST       ,32); 
    RW_TEST_READ(PKA_MASK_REG   ,AUTOIDLE    ,32); 
    RW_WRITE_PREVIOUS_VALUE(PKA_MASK_REG  );
    END_RW_TEST();

	END_ACCESS_MODULE();
}