📄 sblock_test.c

📁 s3c6400 ADS下官方测试程序
💻 C
📖 第 1 页 / 共 5 页
字号:
	while(!SBLK_IsFifoTransDone());

	SBLK_GetDataFromTxFifo(OUTPUT_BUF, 5);
	if (eHashOperMode == HMAC)
		Copy((u32)uHmacCiperText47, GOLDEN_BUF, 5);
	else if (eHashOperMode == SHA1)
		Copy((u32)uSha1CipherText47, GOLDEN_BUF, 5);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5);

	if(eTest == eTest_Manual)
	{
		if (uRet)
		{
		Disp("HASH_");
		DispOperMode(eHashOperMode);
		Disp("_FIFO 47 Success..\n");
		}
		else
		{
		Disp("HASH_");
		DispOperMode(eHashOperMode);
		Disp("_FIFO 47 Failed..\n");
		}
	}
	else
	{
		if(uRet == false)
			{
			Disp("HASH_");
			DispOperMode(eHashOperMode);
			Disp("_FIFO 47 Failed..\n");
			g_sblock_err =1;
			UART_Getc();
			}
	}
 }

//////////
// Function Name : Test_HASH_DMA
// Function Description : HASH DMA mode Test
// Input : 	None
// Output :	None 
// Version : v0.1
void Test_HASH_DMA(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 uRet, usel;
	
	//g_sblock_err=0;
	
	if(eTest == eTest_Manual)
	{
		printf("[SBLOCK - HASH DMA Mode Test]\n");

		printf("Select HASH Operating Mode  : 1)HMAC  2)SHA1  3)PRNG \n");
		usel=GetIntNum();
		if (usel == 1) eHashOperMode = HMAC;
		else if (usel == 2) eHashOperMode = SHA1;
		else if (usel == 3) eHashOperMode = PRNG;

		printf("Your selection is ");
		DispOperMode(eHashOperMode);
		printf("\n");
	}
	else
	{
		eHashOperMode = (OPER_MODE)oAutoVar.Test_Parameter[0];
	}	


	INTC_SetVectAddr(NUM_SDMA1, Isr_SDMA1); //Rx Operation 
	INTC_Enable(NUM_SDMA1);

	
	if (eHashOperMode == PRNG)
	{
		if(eTest == eTest_Manual)
			Disp("This mode isn't supported..\n");
		return;
	}

	SBLK_Init(HASH, eHashOperMode, ENC);
	if (eHashOperMode == HMAC)
	{
		SBLK_SetFifo(19, 16, 5, 16, LASTBYTE_1ST);
		SBLK_SetSDMA(INPUT_BUF, 19, OUTPUT_BUF, 5);
		Copy((u32)uHmacPlainText19, INPUT_BUF, 19);
	}
	else
	{
		SBLK_SetFifo(16, 16, 5, 16, LASTBYTE_4TH);
		SBLK_SetSDMA(INPUT_BUF, 16, OUTPUT_BUF, 5);
		Copy((u32)uSha1PlainText16, INPUT_BUF, 16);
	}

	g_SDma1Done= 0;

	SBLK_StartFifo();
	SBLK_StartSDMA();

	while(!g_SDma1Done);

	if (eHashOperMode == HMAC)
		Copy((u32)uHmacCiperText19, GOLDEN_BUF, 5);
	else if (eHashOperMode == SHA1)
		Copy((u32)uSha1CipherText16, GOLDEN_BUF, 5);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5);

	if(eTest == eTest_Manual)
	{
		if (uRet)
		{
			Disp("HASH_");
			DispOperMode(eHashOperMode);
			if (eHashOperMode == HMAC)
				Disp("_DMA 19 Success..\n");
			else if (eHashOperMode == SHA1)
				Disp("_DMA 16 Success..\n");
		}
		else
		{
			Disp("HASH_");
			DispOperMode(eHashOperMode);
			if (eHashOperMode == HMAC)
				Disp("_DMA 19 Failed..\n");
			else if (eHashOperMode == SHA1)
				Disp("_DMA 16 Failed..\n");
		}
	}
	else
	{
		if(uRet == false)
			{
			Disp("HASH_");
			DispOperMode(eHashOperMode);
			if (eHashOperMode == HMAC)
				Disp("_DMA 19 Failed..\n");
			else if (eHashOperMode == SHA1)
				Disp("_DMA 16 Failed..\n");

			g_sblock_err =1;
			UART_Getc();
			}
	}

	SBLK_Init(HASH, eHashOperMode, ENC);
	if (eHashOperMode == HMAC)
	{
		SBLK_SetFifo(47, 16, 5, 16, LASTBYTE_4TH);
		SBLK_SetSDMA(INPUT_BUF, 47, OUTPUT_BUF, 5);
		Copy((u32)uHmacPlainText47, INPUT_BUF, 47);
	}
	else
	{
		SBLK_SetFifo(47, 16, 5, 16, LASTBYTE_4TH);
		SBLK_SetSDMA(INPUT_BUF, 47, OUTPUT_BUF, 5);
		Copy((u32)uSha1PlainText47, INPUT_BUF, 47);
	}

	g_SDma1Done = 0;

	SBLK_StartFifo();
	SBLK_StartSDMA();

	while(!g_SDma1Done);

	if (eHashOperMode == HMAC)
		Copy((u32)uHmacCiperText47, GOLDEN_BUF, 5);
	else if (eHashOperMode == SHA1)
		Copy((u32)uSha1CipherText47, GOLDEN_BUF, 5);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5);
	if(eTest == eTest_Manual)
	{
		if (uRet)
		{
		Disp("HASH_");
		DispOperMode(eHashOperMode);
		Disp("_DMA 47 Success..\n");
		}
		else
		{
		Disp("HASH_");
		DispOperMode(eHashOperMode);
		Disp("_DMA 47 Failed..\n");
		}
	}
	else
	{
		if(uRet == false)
			{
			Disp("HASH_");
			DispOperMode(eHashOperMode);
			Disp("_DMA 47 Failed..\n");
			g_sblock_err =1;
			UART_Getc();
			}
	}


}



void Sblock_ClockChange(void)
{
	u32 uRatio, uRegValue, uMode;
	
	printf("Select Secure Ratio:  1, or 3\n");
	uRatio = GetIntNum();

	uRegValue= Inp32SYSC(0x20);
	uRegValue = uRegValue&~(3<<18)|(uRatio<<18);
	Outp32SYSC(0x20, uRegValue);

	printf("rCLK_DIV0: 0x%x\n", Inp32SYSC(0x20));


	printf("Select Operating Mode: 0: Sync,   1: Async \n");
	uMode = GetIntNum();

	switch(uMode)
		{
			case 0:		// Sync Mode
			SYSC_ChangeMode(eSYNC_MODE);
			SYSC_ChangeSYSCLK_1(eAPLL532M, eAPLL266M, 0, 1, 3);
			break;

			case 1:		//ASync Mode
			SYSC_ChangeMode(eASYNC_MODE);
			SYSC_ChangeSYSCLK_1(eAPLL532M, eAPLL266M, 0, 0, 3);
			break;
		}
	

	
}


//////////
// Function Name : Test_HASH_CPU
// Function Description : HASH CPU mode Test
// Input : 	None
// Output :	None 
// Version : v0.1
/*
void Test_HASH_CPU_Added(void)
{
	u32 uRet;

	SBLK_Init(HASH, SHA1, ENC);

	//SHA1 - #0
	SBLK_PutDataToInReg((u32)uSha1PlainText1, 1, LASTBYTE_1ST);

	while(!SBLK_IsOutputReady());

	SBLK_GetDataFromOutReg(OUTPUT_BUF, 5);

	Copy((u32)uSha1CipherText1, GOLDEN_BUF, 5);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5);
	if (uRet)
	{
		Disp("HASH_SHA1_CPU 1, LAST_1ST Success \n");
		
	}
	else
	{
		Disp("HASH_SHA1_CPU 1, LAST_1ST Failed \n");
	}


	Disp(" \n");
	
}
*/
/*
void Test_HASH_CPU_Added(void)
{
	u32 uRet;

	//SHA1 - #0
	SBLK_Init(HASH, SHA1, ENC);
	
	SBLK_PutDataToInReg((u32)uSha1PlainText1, 1, LASTBYTE_1ST);

	while(!SBLK_IsOutputReady());

	SBLK_GetDataFromOutReg(OUTPUT_BUF, 5);

	//SHA1- #1

	SBLK_Init(HASH, SHA1, ENC);

	SBLK_PutDataToInReg((u32)uSha1PlainText1, 1, LASTBYTE_2ND);

	while(!SBLK_IsOutputReady());

	SBLK_GetDataFromOutReg(OUTPUT_BUF+5*4, 5);

	//SHA1- #3

	SBLK_Init(HASH, SHA1, ENC);

	SBLK_PutDataToInReg((u32)uSha1PlainText1, 1, LASTBYTE_3RD);

	while(!SBLK_IsOutputReady());

	SBLK_GetDataFromOutReg(OUTPUT_BUF+10*4, 5);


	//SHA1- #4

	SBLK_Init(HASH, SHA1, ENC);

	SBLK_PutDataToInReg((u32)uSha1PlainText1, 1, LASTBYTE_4TH);

	while(!SBLK_IsOutputReady());

	SBLK_GetDataFromOutReg(OUTPUT_BUF+15*4, 5);
	

	Copy((u32)uSha1CipherText1, GOLDEN_BUF, 5*4);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5*4);
	if (uRet)
	{
		Disp("HASH_SHA1_CPU 1,  Success \n");
		
	}
	else
	{
		Disp("HASH_SHA1_CPU 1,  Failed \n");
	}


	Disp(" \n");
	
}
*/
/*
void Test_HASH_CPU_Added(void)
{
	u32 uRet, uLASTBYTE,uRep;


	for(uRep=0;uRep<4;uRep++)
	{
		SBLK_Init(HASH, SHA1, ENC);
		switch(uRep)
		{
			case 0: 
				uLASTBYTE= LASTBYTE_1ST;
			     	break;           
			case 1: 
				uLASTBYTE= LASTBYTE_2ND;
			     	break;     
			case 2: 
				uLASTBYTE= LASTBYTE_3RD;
			     	break;        
			case 3: 
				uLASTBYTE= LASTBYTE_4TH;
			     	break;   	     	
		}
	
		SBLK_PutDataToInReg((u32)uSha1PlainText16, 1, (LVALID_BYTE)uLASTBYTE);
		while(!SBLK_IsOutputReady());
		SBLK_GetDataFromOutReg(OUTPUT_BUF + (uRep*5)*4, 5);
		}


	Copy((u32)uSha1CipherText1, GOLDEN_BUF, 5*4);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5*4);
	if (uRet)
	{
		Disp("HASH_SHA1_CPU 1,  Success \n");
		
	}
	else
	{
		Disp("HASH_SHA1_CPU 1,  Failed \n");
	}


	Disp(" \n");
	
}
*/

void Test_HASH_CPU_Added(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 uRet, uLASTBYTE,uRep, i;

   for(i=1;i<16;i++)
   {
	for(uRep=0;uRep<4;uRep++)
	{
		SBLK_Init(HASH, SHA1, ENC);
		switch(uRep)
		{
			case 0: 
				uLASTBYTE= LASTBYTE_1ST;
			     	break;           
			case 1: 
				uLASTBYTE= LASTBYTE_2ND;
			     	break;     
			case 2: 
				uLASTBYTE= LASTBYTE_3RD;
			     	break;        
			case 3: 
				uLASTBYTE= LASTBYTE_4TH;
			     	break;   	     	
		}
	
		SBLK_PutDataToInReg((u32)uSha1PlainText16, i, (LVALID_BYTE)uLASTBYTE);
		while(!SBLK_IsOutputReady());
		SBLK_GetDataFromOutReg(OUTPUT_BUF + (uRep*5)*4, 5);
		}

				
		switch(i)
		{
			case 1: 
				Copy((u32)uSha1CipherText1, GOLDEN_BUF, 5*4);
			     	break;           
			case 2: 
				Copy((u32)uSha1CipherText2, GOLDEN_BUF, 5*4);
			     	break;     
			case 3: 
				Copy((u32)uSha1CipherText3, GOLDEN_BUF, 5*4);
			     	break;        
			case 4: 
				Copy((u32)uSha1CipherText4, GOLDEN_BUF, 5*4);
			     	break;   	     	
			case 5: 
				Copy((u32)uSha1CipherText5, GOLDEN_BUF, 5*4);
			     	break;   	     	
			case 6: 
				Copy((u32)uSha1CipherText6, GOLDEN_BUF, 5*4);
			     	break;   	      	
			case 7: 
				Copy((u32)uSha1CipherText7, GOLDEN_BUF, 5*4);
			     	break;   	       	
			case 8: 
				Copy((u32)uSha1CipherText8, GOLDEN_BUF, 5*4);
			     	break;   	   
			case 9: 
				Copy((u32)uSha1CipherText9, GOLDEN_BUF, 5*4);
			     	break;   	   	     	
			case 10: 
				Copy((u32)uSha1CipherText10, GOLDEN_BUF, 5*4);
			     	break;
			case 11: 
				Copy((u32)uSha1CipherText11, GOLDEN_BUF, 5*4);
			     	break;
 			case 12: 
				Copy((u32)uSha1CipherText12, GOLDEN_BUF, 5*4);
			     	break;    	
			case 13: 
				Copy((u32)uSha1CipherText13, GOLDEN_BUF, 5*4);
			     	break;     	
			case 14: 
				Copy((u32)uSha1CipherText14, GOLDEN_BUF, 5*4);
			     	break;
			case 15: 
				Copy((u32)uSha1CipherText15, GOLDEN_BUF, 5*4);
				break;
			     	
			     	
		}



	
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5*4);

	if(eTest == eTest_Manual)
	{
		if (uRet)
		{
		Disp("HASH_SHA1_CPU %d,  Success \n", i);
		}
		else
		{
		Disp("HASH_SHA1_CPU %d,  Failed \n", i );
		}
	}
	else
	{
		if(uRet == false)
			{
				Disp("HASH_SHA1_CPU %d,  Failed \n", i );
				g_sblock_err =1;
				UART_Getc();
			}
	}

  }

}


void Test_SHA1_INTERMEDIATE(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 uRet, i;

	SBLK_Init(HASH, SHA1, ENC);
	//Outp32(0x7D300000, 0x9);

/*
	// Intermediate FIFO Setting
	Outp32(0x7D400000, 0x04);		// Rx Fifo Host Write Enable/Start
	Outp32(0x7D800000, 0x04);		// Tx Fifo Host Write Enable/Start

	Outp32(0x7D400004, 0x79);		// Rx Fifo Message Length
	Outp32(0x7D400008, 0x30010);	// Full 32bit, block Size 0x10
	Outp32(0x7D40000C, 0x7D300004);	// Rx FIFO Destination Address, HASH Rx DATA

	Outp32(0x7D800004, 0x5);		// Tx FIFO Message Length
	Outp32(0x7D800008, 0x10);
	//Outp32(0x7D80000C, 0x7D300034);	// Tx FIFO Source Address => Rx HASHOUT ??
	Outp32(0x7D80000C, 0x7D700034);	// Tx FIFO Source Address => Rx HASHOUT ??
	
	Outp32(0x7D400000, 0xB3);		// Rx FIFO Start 
	Outp32(0x7D800000, 0xB3);		// Tx FIFO Start	
*/

	SBLK_SetFifo(0x79, 0x30010, 5, 0x10, LASTBYTE_4TH);
	SBLK_StartFifo();

	//for(i=0;i<7;i++){
	for(i=0;i<6;i++){
	//Wait Write Enable...		
	SBLK_PutDataToRxFifo((u32)uSha1PlainText16, 16);
	}
	

	while(((Inp32(0x7D400000)>>8)&0xFF)>1);	// RX_FIFO Empty Polling
	while(((Inp32(0x7D300030)>>3)&0x3)==3);	// Ready to receivce

	//Delay(10);
	//SBLK_GetDataFromTxFifo(OUTPUT_BUF, 5);
	
	Copy(0x7D30005c, MID_BUF, 5);


	// HMAC Operating.
	SBLK_Init(HASH, HMAC, ENC);
	SBLK_SetFifo(47, 16, 5, 16, LASTBYTE_4TH);
	SBLK_StartFifo();
	SBLK_PutDataToRxFifo((u32)uHmacPlainText47, 47);
	while(!SBLK_IsFifoTransDone());
	SBLK_GetDataFromTxFifo(OUTPUT_BUF, 5);
	Copy((u32)uHmacCiperText47, GOLDEN_BUF, 5);
	uRet = Compare(OUTPUT_BUF, GOLDEN_BUF, 5);

	if(eTest == eTest_Manual)
	{
		if (uRet)
		{
		Disp("HASH_HMAC ,  Success \n");
		
		}
		else
		{
		Disp("HASH_HMAC ,  Failed \n" );
		}
	}
	// Start 2nd SHA1 Operation
	Outp32(0x7D300000, 0x0);
	Outp32(0x7D400000, 0x4);
	Outp32(0x7D800000, 0x4);

		
	//Copy(MID_BUF, 0x7D300070, 5);		//Load Back-up Intermediate Value
	//Copy(MID_BUF, 0x7D700070, 5);

/*
	Copy(MID_BUF+0x10, 0x7D300070,1);
	Copy(MID_BUF+0xc, 0x7D300074,1);
	Copy(MID_BUF+8, 0x7D300078,1);
	Copy(MID_BUF+4, 0x7D30007c,1);
	Copy(MID_BUF, 0x7D300080,1);
*/
	

	Outp32(0x7D300070, 0xcd381861);		// Golden Data => MID Value
	Outp32(0x7D300074, 0x1a921f94);
	Outp32(0x7D300078, 0x6e76da53);
	Outp32(0x7D30007c, 0x5c52c230);
	Outp32(0x7D300080, 0x64e696cd);

/*
	Outp32(0x7D300070, 0x64e696cd);
	Outp32(0x7D300074, 0x5c52c230);
	Outp32(0x7D300078, 0x6e76da53);
	Outp32(0x7D30007c,0x1a921f94);
	Outp32(0x7D300080, 0xcd381861);
*/


/*
	Outp32(0x7D300070, 0x611838cd);
	Outp32(0x7D300074, 0x941f921a);
	Outp32(0x7D300078, 0x53da766e);
	Outp32(0x7D30007c, 0x30c2525c);
	Outp32(0x7D300080, 0xcd96e664);
*/

/*
	Outp32(0x7D300080, 0x611838cd);
	Outp32(0x7D30007c, 0x941f921a);
	Outp32(0x7D300078, 0x53da766e);
	Outp32(0x7D300074, 0x30c2525c);
	Outp32(0x7D300070, 0xcd96e664);
*/

	
	//printf("HASH_CTRL Reg: 0x%x\n", Inp32(0x7D300000));
	  // FIFO Reset
	//Outp32(0x7D300000, 0x109);		// Usign Back-up IV, not SHA1 Constants	
	//Copy(MID_BUF, 0x7D700070, 5);		//Load Back-up Intermediate Value
	Outp32(0x7D300084, 0x0);
	Outp32(0x7D300088,0xC0000);

	// SHA1 Pre Length Load,  96Word => C00

	Outp32(0x7D300000, 0x109);		// Usign Back-up IV, not SHA1 Constants
	//Outp32(0x7D300000, 0x1c9);		// Usign Back-up IV, not SHA1 Constants
	//Outp32(0x7D300000, 0x109);		// Usign Back-up IV, not SHA1 Constants
	//SBLK_Init_T(HASH, SHA1, ENC);
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -