functions.c

freescale atk source code

// -------------------------------------------------------------------------------------
//        in: WORD              *exp_val        expected values array
//        in: WORD              *res_val        real results array
//        in: int               num_of_res      number of results (array size)
//    in-out:  
//       out:  
//    return: void              
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 15:41:53 IST
//  Revision:  none
// =====================================================================================
int compare_array(WORD *exp_val, WORD *res_val, int num_of_res) 
{ //{{{2
  int i; 
  int rc=0;
  int err = 0;

  for (i=0 ; i < num_of_res ; i++) 
  {
//     info_checktest_trigger(i,exp_val[i],res_val[i]);		  
//     if (exp_val[i] == res_val[i]) {
//       verilog_trigger(arm_vt_pass); }
//     else {verilog_trigger(arm_vt_fail);}
     if (exp_val[i] != res_val[i]) 
     {
     	rc = 1;
		#ifdef PRINT_ERR
			printf("Error receive : word num = %d sent 0x%lx, received 0x%lx\n", i, exp_val[i], res_val[i]);
		#endif
     	if (err++ >= 5)
     	{
     		printf("Error :err numm > 5\n");
     		break; 
     	}
     }
  }
  return rc;
} //2}}}


// ===  FUNCTION  ======================================================================
// 
//         Name:  compare_results
// 
//  Description:  compare 2 data words (expected value and real result)
//                and trigger pass/fail event.
//                uses info_trigger. returns pass/fail indication
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              reg_addr       data word, used for the info message
//        in: WORD              exp_val        expected value
//        in: WORD              res_val        real result
//    in-out:  
//       out:  
//    return: int               flag            pass(0)/fail(1)
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 15:41:53 IST
//  Revision:  none
// =====================================================================================
int compare_results(WORD reg_addr,WORD exp_val, WORD res_val) 
{ //{{{2
   int flag;
   
//   info_trigger(reg_addr,exp_val,res_val);
   if (exp_val == res_val) {
//      verilog_trigger(arm_vt_pass);
      flag=0;
   } else {
//		 verilog_trigger(arm_vt_fail);
 		 printf ("Error receive data: Sent 0x%08%x Received 0x%08%x\n", exp_val, res_val);
         flag=1;
   }
   return flag;		 
} //2}}}



// ===  FUNCTION  ======================================================================
// 
//         Name:  word_data_compare 
// 
//  Description:  compare 2 data half words, and trigger pass/fail event
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              worda           first word to compare 
//        in: WORD              wordb           second word to compare
//    in-out:  
//       out:  
//    return:  void
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 15:34:44 IST
//  Revision:  none
// =====================================================================================
int word_data_compare (WORD worda , WORD wordb)
{ //{{{2
int rc;

//  info_checktest_trigger(DUMMY_INFO,worda,wordb);		
  if (worda != wordb )    
  	rc = 1;
//  	verilog_trigger(arm_vt_fail);
  else              
	rc = 0;
//       verilog_trigger(arm_vt_pass);
	return rc;
} //2}}}

// ===  FUNCTION  ======================================================================
// 
//         Name:  hw_data_compare
// 
//  Description:  compare 2 data half words, and trigger pass/fail event
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: HALF              hworda          first half word to compare 
//        in: HALF              hwordb          second half word to compare
//    in-out:  
//       out:  
//    return:  void
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 15:34:44 IST
//  Revision:  none
// =====================================================================================
int hw_data_compare (HALF hworda , HALF hwordb)
{ //{{{2
int rc;
 
//  info_checktest_trigger(DUMMY_INFO,hworda,hwordb);		
  if(hworda != hwordb )  
	rc = 1;
//  	verilog_trigger(arm_vt_fail);
  else     
	rc = 0;
//        verilog_trigger(arm_vt_pass);
	return rc;
} //2}}}


// ===  FUNCTION  ======================================================================
// 
//         Name:  byte_data_compare
// 
//  Description:  compare 2 data bytes, and trigger pass/fail event
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: HALF              bytea           first byte to compare 
//        in: HALF              byteb           second byte to compare
//    in-out:  
//       out:  
//    return:  void
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 15:34:44 IST
//  Revision:  none
// =====================================================================================

int byte_data_compare (BYTE bytea , BYTE byteb)
{ //{{{2
int rc;

//  info_checktest_trigger(DUMMY_INFO,bytea,byteb);		
  if (bytea != byteb )    
	rc = 1;
//  verilog_trigger(arm_vt_fail);
  else     
	rc = 0;
//                verilog_trigger(arm_vt_pass);
	return rc;
} //2}}}

//1}}}


//----------------------------------------------------------------------
//  Write With Mask (write only certain bits)
//----------------------------------------------------------------------

//{{{1

// ===  FUNCTION  ======================================================================
// 
//         Name:  regN_write_mask
// 
//  Description:  Write value to a register using bit mask.
//                N=8,16,32
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              addr            address to access
//        in: BYTE/HALF/WORD    wdata           data to write, size depends on N
//        in: BYTE/HALF/WORD    mask            bit mask for writing, size depends on N
//    in-out:  
//       out:  
//    return:  void
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/02/04 14:00:05 IST
//  Revision:  none
// =====================================================================================
void reg8_write_mask(WORD addr , BYTE wdata , BYTE mask)
{//{{{2
   BYTE	masked_wdata,rdata;

   rdata=reg8_read(addr);
   masked_wdata=(((~mask)&rdata)|(mask&wdata));
   reg8_write(addr,masked_wdata);
} //2}}}		


void reg16_write_mask(WORD addr , HALF wdata , HALF mask)
{//{{{2
   HALF	masked_wdata,rdata;

   rdata=reg16_read(addr);
   masked_wdata=(((~mask)&rdata)|(mask&wdata));
   reg16_write(addr,masked_wdata);
}//2}}}

void reg32_write_mask(WORD addr , WORD wdata , WORD mask) 
{ //{{{2
   WORD	masked_wdata,rdata;

   rdata=reg32_read(addr);
   masked_wdata=(((~mask)&rdata)|(mask&wdata));
   reg32_write(addr,masked_wdata);
} //2}}}

//1}}}

//----------------------------------------------------------------------
//  Read/Write Compare Functions
//----------------------------------------------------------------------

//{{{1

// ===  FUNCTION  ======================================================================
// 
//         Name:  regN_rw_test
// 
//  Description:  write value to register, read it back and compare to expected value.
//                and trigger pass/fail event (uses regN_read_tst)
//                size is N=8,16,32
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD             addr             addr to access
//        in: BYTE/HALF/WORD   wdata            data to write, size depends on N
//        in: WORD             exp_rdata        expected value
//    in-out:  
//       out:  
//    return: void 
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 16:41:28 IST
//  Revision:  none
// =====================================================================================
void reg8_rw_test(WORD addr, BYTE wdata, BYTE exp_rdata) 
{ //{{{2
   reg8_write(addr,wdata);
   reg8_read_tst(addr,exp_rdata,0xff);
} //2}}}

void reg16_rw_test(WORD addr, HALF wdata, HALF exp_rdata) 
{ //{{{2
   reg16_write(addr,wdata);
   reg16_read_tst(addr,exp_rdata,0xffff);
} //2}}}

void reg32_rw_test(WORD addr, WORD wdata, WORD exp_rdata) 
{ //{{{2
   reg32_write(addr,wdata);
   reg32_read_tst(addr,exp_rdata,0xffffffff);
} //2}}}

 

//1}}}

// #####    Project Specific API  ############################ 

//----------------------------------------------------------------------
//  Tortola/Argon Specific Function (Not Common API)
//----------------------------------------------------------------------

//{{{1
// ===  FUNCTION  ======================================================================
// 
//         Name: release_spba 
// 
//  Description:  release spba from ARM ownership
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: void 
//    in-out:  
//       out:  
//    return:  void
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  09/06/04 15:22:20 IDT
//  Revision:  none
// =====================================================================================


void release_spba(void){ //{{{2

  reg32_write( SPBA_PRR0 , 0x0);
  reg32_write( SPBA_PRR1 , 0x0);
  reg32_write( SPBA_PRR2 , 0x0);
  reg32_write( SPBA_PRR3 , 0x0);
  reg32_write( SPBA_PRR4 , 0x0);
  reg32_write( SPBA_PRR5 , 0x0);
  reg32_write( SPBA_PRR6 , 0x0);
  reg32_write( SPBA_PRR7 , 0x0);
  reg32_write( SPBA_PRR8 , 0x0);
  reg32_write( SPBA_PRR9 , 0x0);
  reg32_write( SPBA_PRR10 , 0x0);
  reg32_write( SPBA_PRR11 , 0x0);
  reg32_write( SPBA_PRR12 , 0x0);
  reg32_write( SPBA_PRR13 , 0x0);
  reg32_write( SPBA_PRR14 , 0x0);
   
} //2}}}

//1}}}
//