kbd_if.c

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

void KBD_IF_GetKbrLatch(UWORD8 *const kbr_latch)
{

  UWORD16 memReg = KBD_IF_KBR_LATCH;

  *kbr_latch = memReg & KBD_IF_KBR_LATCH_MASK;

}




////////////////////////////////////////
//                                    //
//      Keyboard column outputs       //
//                                    //
////////////////////////////////////////


//-------------------------------------------------------------------------
//  KBD_IF_SetKbcReg : Set the Keyboard column outputs register
//-------------------------------------------------------------------------

void KBD_IF_SetKbcReg(UWORD8 const kbc_reg)
{

  SetField16(KBD_IF_KBC_REG, KBC_REG, kbc_reg);  

}

//----------------------------------------------------------
//   KBD_IF_WriteKbCol
//  WARNING use in MCSI test with the test bench
//-----------------------------------------------------------
void KBD_IF_WriteKbCol(const WORD8 data)
{  
      KBD_IF_KBC_REG = (UWORD16) data;
}	




//-------------------------------------------------------------------------
//  KBD_IF_GetKbcReg : Read the Keyboard column outputs register
//-------------------------------------------------------------------------

void KBD_IF_GetKbcReg(UWORD8 *const kbc_reg)
{

  UWORD16 memReg = KBD_IF_KBC_REG;

  *kbc_reg = memReg & KBD_IF_KBC_REG_MASK;

}




////////////////////////////////////////
//                                    //
//        Full Code registers         //
//                                    //
////////////////////////////////////////

//-------------------------------------------------------------------------
//  KBD_IF_GetFullCode15_0 : Read the Full code 15 0 register
//-------------------------------------------------------------------------

void KBD_IF_GetFullCode15_0(UWORD16 *const full_code_15_0)
{

  *full_code_15_0 = KBD_IF_FULL_CODE_15_0;

}


//-------------------------------------------------------------------------
//  KBD_IF_GetFullCode31_16 : Read the Full code 31 16 register
//-------------------------------------------------------------------------

void KBD_IF_GetFullCode31_16(UWORD16 *const full_code_31_16)
{

  *full_code_31_16 = KBD_IF_FULL_CODE_31_16;

}


//-------------------------------------------------------------------------
//  KBD_IF_GetFullCode47_32 : Read the Full code 47 32 register
//-------------------------------------------------------------------------

void KBD_IF_GetFullCode47_32(UWORD8 *const full_code_47_32)
{
  
  *full_code_47_32 = KBD_IF_FULL_CODE_47_32;

}

//-------------------------------------------------------------------------
//  KBD_IF_GetFullCode63_48 : Read the Full code 63 48 register
//-------------------------------------------------------------------------

void KBD_IF_GetFullCode63_48(UWORD8 *const full_code_63_48)
{
  
  *full_code_63_48 = KBD_IF_FULL_CODE_63_48;

}





//-------------------------------------------------------------------------
//  KBD_IF_CheckFullCodeRegister : Check the Full code register value (64 bits) 
//                                 according to a keyboard key state input.
//
//  Input                        : the number of key(s) pressed and a KBD_key_t
//                                 array which describes the key(s) pressed
//
//  Output                       : 1 -> Full Code Register value is the one
//                                      expected
//                                 0 -> Full Code Register value is not the
//                                      one expected 
//-------------------------------------------------------------------------

int KBD_IF_CheckFullCodeRegister(UWORD8 nb_key, KBD_key_t keys[])
{
  UWORD16 expected_full_code_15_0 = 0, expected_full_code_31_16 = 0;
  UWORD16 expected_full_code_47_32 = 0, expected_full_code_63_48 = 0; 
  UWORD8 i;

  // full code register evaluation from expected value in function of the keys
  // pressed
  for (i = 0; i <= nb_key-1; i++){

    if (keys[i] < 16)      expected_full_code_15_0  |= 1 <<  keys[i];
    else if (keys[i] < 32) expected_full_code_31_16 |= 1 << (keys[i] - 16);
    else if (keys[i] < 48) expected_full_code_47_32 |= 1 << (keys[i] - 32);
    else                   expected_full_code_63_48 |= 1 << (keys[i] - 48);

  }

  // Comparaison between the expected value and the real one
  if (KBD_IF_FULL_CODE_15_0  != expected_full_code_15_0)  return 0;
  if (KBD_IF_FULL_CODE_31_16 != expected_full_code_31_16) return 0;
  if (KBD_IF_FULL_CODE_47_32 != expected_full_code_47_32) return 0;
  if (KBD_IF_FULL_CODE_63_48 != expected_full_code_63_48) return 0;
 
  return 1;

}







////////////////////////////////////////
//                                    //
//    Keyboard Decoding procedures    //
//                                    //
////////////////////////////////////////



//-------------------------------------------------------------------------
//  KBD_IF_GetKeys  : Get the pressed keys from the Full code register (64 bits). 
//                                 
//  Input           : The reference of the number of key(s) pressed and a KBD_key_t array
//                    reference which describes the key(s) pressed.
//                    The pressed keys are stored in this array with increasing order
//                    i.e. a detected key whose position in full code registers is 
//                    before another one will be store in array before the second key.
//
//-------------------------------------------------------------------------

void KBD_IF_GetKeys(UWORD8 *nb_key, KBD_key_t keys[])
{
  UWORD8 i, indice = 0;
  UWORD16 memReg;
  
  // full code register 15:0 cross to search pressed key(s)
  memReg = KBD_IF_FULL_CODE_15_0;
  for (i = 0; i < 16; i++) 
    if (TestBitIndex(memReg, i)) keys[indice++] = (KBD_key_t)i;
  
  // full code register 31:16 cross to search pressed key(s)
  memReg = KBD_IF_FULL_CODE_31_16;
  for (i = 0; i < 16; i++)  
    if (TestBitIndex(memReg, i)) keys[indice++] = (KBD_key_t)(i+16);
  
  // full code register 47:32 cross to search pressed key(s)
  memReg = KBD_IF_FULL_CODE_47_32;
  for (i = 0; i < 16; i++) 
    if (TestBitIndex(memReg, i)) keys[indice++] = (KBD_key_t)(i+32); 

  // full code register 63:48 cross to search pressed key(s)
  memReg = KBD_IF_FULL_CODE_63_48;
  for (i = 0; i < 16; i++) 
    if (TestBitIndex(memReg, i)) keys[indice++] = (KBD_key_t)(i+48); 

  *nb_key = indice;  
  }



//-------------------------------------------------------------------------
//  KBD_IF_GetInterrupt : Read the type of interrupt that has been generated
//-------------------------------------------------------------------------
void KBD_IF_GetInterrupt(KBD_Interrupt_t * const it)
{  

  *it = (KBD_Interrupt_t)(KBD_IF_INTERRUPT_STATUS_REGISTER & KBD_IF_INTERRUPT_STATUS_REGISTER_MASK);

}



//-------------------------------------------------------------------------
//  KBD_IF_ClearInterruptStatus : Clear the bit(s) of Interrupt Status Register  
//                                that corresponds to the argument
//-------------------------------------------------------------------------
void KBD_IF_ClearInterruptStatus(KBD_Interrupt_t const it)
{  

	UWORD16 tmpReg = KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER;
  
  	tmpReg &= ~KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER_MASK;
  	tmpReg |= (UWORD16)it;
  	
  	KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER = tmpReg;  

}





//////////////////////////////////////////
//                                      //
// Test reset values & access registers //
//                                      //
//////////////////////////////////////////



//---------------------------------------------------------------------
// NAME        : KBD_IF_TestResetValues
//
// DESCRIPTION : Test the reset values of KBD_IF registers
//
// PARAMETERS  : None
//
// RETURN VALUE: None
//
// LIMITATIONS : None
//---------------------------------------------------------------------
void KBD_IF_Test_ResetValues(void)
{
  
  UWORD16 result = TEST_OK;


  // Control register
  if ( (KBD_IF_CNTL_REG & KBD_IF_CNTL_REG_MASK) != KBD_IF_CNTL_REG_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_CNTL_REG_BAD_RESET_VALUE);
  }


  // Debouncing Time 
  if ( (KBD_IF_DEBOUNCING_TIME & KBD_IF_DEBOUNCING_TIME_MASK) !=  KBD_IF_DEBOUNCING_TIME_RESET_VALUE){
    result = TEST_BAD;
    RES_Set(KBD_IF_DEBOUNCING_TIME_BAD_RESET_VALUE);
  }


  // Long Key Time
  if ( (KBD_IF_LONG_KEY & KBD_IF_LONG_KEY_TIME_MASK) != KBD_IF_LONG_KEY_TIME_RESET_VALUE){
    result = TEST_BAD;
    RES_Set(KBD_IF_LONG_KEY_BAD_RESET_VALUE);
  }


  // Time out
  if (KBD_IF_TIME_OUT != KBD_IF_TIME_OUT_RESET_VALUE){
    result = TEST_BAD;
    RES_Set(KBD_IF_TIME_OUT_BAD_RESET_VALUE);
  }



  // Interrupt status register
  if ( (KBD_IF_INTERRUPT_STATUS_REGISTER & KBD_IF_INTERRUPT_STATUS_REGISTER_MASK) != KBD_IF_INTERRUPT_STATUS_REGISTER_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_INTERRUPT_STATUS_BAD_RESET_VALUE);
  }

  // Clear interrupt status register
  if ( (KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER & KBD_IF_INTERRUPT_STATUS_REGISTER_MASK) != KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_CLEAR_INTERRUPT_STATUS_BAD_RESET_VALUE);
  }

  // Interrupt enable
  if ( (KBD_IF_INTERRUPT_ENABLE & KBD_IF_INTERRUPT_ENABLE_MASK) != KBD_IF_INTERRUPT_ENABLE_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_INTERRUPT_ENABLE_BAD_RESET_VALUE);
  }

  // Status state machine
  if ( (KBD_IF_STATUS_STATE_MACHINE & KBD_IF_STATUS_STATE_MACHINE_MASK) != KBD_IF_STATUS_STATE_MACHINE_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_STATUS_STATE_MACHINE_BAD_RESET_VALUE);
  }
  
  // Kbc register
  if ( (KBD_IF_KBC_REG & KBD_IF_KBC_REG_MASK) != KBD_IF_KBC_REG_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_KBC_REG_BAD_RESET_VALUE);
  }
  
  // Full code 15:0 register
  if ( KBD_IF_FULL_CODE_15_0 != KBD_IF_FULL_CODE_15_0_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_FULL_CODE_15_0_BAD_RESET_VALUE);
  }
  
  // Full code 31:16 register
  if ( KBD_IF_FULL_CODE_31_16 != KBD_IF_FULL_CODE_31_16_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_FULL_CODE_31_16_BAD_RESET_VALUE);
  }
  
  // Full code 47:32 register
  if ( KBD_IF_FULL_CODE_47_32 != KBD_IF_FULL_CODE_47_32_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_FULL_CODE_47_32_BAD_RESET_VALUE);
  }
 
  // Full code 63:48 register
  if ( KBD_IF_FULL_CODE_63_48 != KBD_IF_FULL_CODE_63_48_RESET_VALUE ){
    result = TEST_BAD;
    RES_Set(KBD_IF_FULL_CODE_63_48_BAD_RESET_VALUE);
  }
 
  // Store Final result to spy result main area
  RES_Set(result);

}

//---------------------------------------------------------------------
// NAME        : KBD_IF_TestRegistersAccess
//
// DESCRIPTION : Test the access to KBD Interface registers
//
// PARAMETERS  : None
//
// RETURN VALUE: None
//
// LIMITATIONS : None
//---------------------------------------------------------------------
void KBD_IF_TestRegistersAccess(void)
{
    
  UWORD16 tmpReg, result = TEST_OK;

  // For each register :
  // 1) store its complemented reset value
  // 2) read this value & compare it with the previous one
  // 3) update spy result
  // 4) reset it (store its reset value) 


  // Control register
  tmpReg = ~KBD_IF_CNTL_REG & KBD_IF_CNTL_REG_MASK;
  KBD_IF_CNTL_REG = tmpReg;
  if ( (KBD_IF_CNTL_REG & KBD_IF_CNTL_REG_MASK) != tmpReg ) result = TEST_BAD;
  KBD_IF_CNTL_REG = KBD_IF_CNTL_REG_RESET_VALUE;


  
  /* Clear interrupt status register access not tested since the register is an auto-cleared one
  tmpReg = ~KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER & KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER_MASK;
  KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER = tmpReg;
  if ( (KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER & KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER_MASK) != tmpReg) result = TEST_BAD;;
  KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER = KBD_IF_CLEAR_INTERRUPT_STATUS_REGISTER_RESET_VALUE;
  */

  // Interrupt Enable
  tmpReg = ~KBD_IF_INTERRUPT_ENABLE & KBD_IF_INTERRUPT_ENABLE_MASK;
  KBD_IF_INTERRUPT_ENABLE = tmpReg;
  if ( (KBD_IF_INTERRUPT_ENABLE & KBD_IF_INTERRUPT_ENABLE_MASK) != tmpReg) result = TEST_BAD;
  KBD_IF_INTERRUPT_ENABLE = KBD_IF_INTERRUPT_ENABLE_RESET_VALUE;

  // Keyboard column outputs
  tmpReg = ~KBD_IF_KBC_REG & KBD_IF_KBC_REG_MASK;
  KBD_IF_KBC_REG = tmpReg;
  if ( (KBD_IF_KBC_REG & KBD_IF_KBC_REG_MASK) != tmpReg) result = TEST_BAD;
  KBD_IF_KBC_REG = KBD_IF_KBC_REG_RESET_VALUE;

  // Store Final result to spy result main area
  RES_Set(result);

}