kbd_if.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 2001, (C) Copyright 2002 Texas Instruments.  All rights reserved.
//
//   Filename             : calypso_plus_kbd_if.c
//
//   Date of Generation   : 12/04/01
//
//   Last Modification    : 01/10/02
//
//   Description    	  : See calypso_plus_kbd_if.h
//
//   Author            	  : [e-mail]  Yoan Hebrard.            
//
//===============================================================================

#include "global_types.h"
#include "testaccess.h"

#include "kbd_if.h"
#include "io_configuration.h"

void ConfigKBDPullUps(void) {
    CONFIG_PullEnable(IO_CONFIGURATION_CONF_KBD_R_0);
    CONFIG_SetPullUp(IO_CONFIGURATION_CONF_KBD_R_0);

    CONFIG_PullEnable(IO_CONFIGURATION_CONF_KBD_R_1);
    CONFIG_SetPullUp(IO_CONFIGURATION_CONF_KBD_R_1);

    CONFIG_PullEnable(IO_CONFIGURATION_CONF_KBD_R_2);
    CONFIG_SetPullUp(IO_CONFIGURATION_CONF_KBD_R_2);

    CONFIG_PullEnable(IO_CONFIGURATION_CONF_KBD_R_3);
    CONFIG_SetPullUp(IO_CONFIGURATION_CONF_KBD_R_3);

    CONFIG_PullEnable(IO_CONFIGURATION_CONF_KBD_R_4);
    CONFIG_SetPullUp(IO_CONFIGURATION_CONF_KBD_R_4);

    CONFIG_PullEnable(IO_CONFIGURATION_CONF_KBD_R_5);
    CONFIG_SetPullUp(IO_CONFIGURATION_CONF_KBD_R_5);
}




////////////////////////////////////////
//                                    //
//    Control Register procedures     //
//                                    //
////////////////////////////////////////




//-------------------------------------------------------------------------
//  KBD_IF_InitCtrlReg : Initialize the Control register
//-------------------------------------------------------------------------


void KBD_IF_InitCtrlReg(const UWORD8 software_nreset, 
			const KBD_Nsoftware_mode_t nsoftware_mode, 
			const KBD_PTV_t ptv,
			const KBD_EnableDetection_t long_key_process_en,
			const KBD_EnableDetection_t time_out_empty_en,
			const KBD_EnableDetection_t time_out_long_key_en, 
			const KBD_EnableDetection_t repeat_mode_en)
{
  
  UWORD16 memReg = KBD_IF_STATUS_STATE_MACHINE; 
  KBD_Status_t StatusReg = KBD_IF_STATUS_STATE_MACHINE;
  
  if ( (StatusReg != KBD_IF_TEST_TIMER_DEBOUNCING) && (StatusReg != KBD_IF_TEST_TIMER_LONG_KEY) &&
       (StatusReg != KBD_IF_TEST_TIMER_TIME_OUT)   && (StatusReg != KBD_IF_TEST_TIMER_REPEAT_KEY) ){   
    
    // The PTV can be programmed since the timer is not running
    
    KBD_IF_CNTL_REG = (software_nreset |
			 nsoftware_mode       << KBD_IF_CNTL_REG_NSOFTWARE_MODE_POS |
			 ptv                  << KBD_IF_CNTL_REG_PTV_POS |
			 long_key_process_en  << KBD_IF_CNTL_REG_LONG_KEY_EN_POS  | 
			 time_out_empty_en    << KBD_IF_CNTL_REG_TIME_OUT_EMPTY_EN_POS  | 
			 time_out_long_key_en << KBD_IF_CNTL_REG_TIME_OUT_LONG_KEY_EN_POS | 
			 repeat_mode_en       << KBD_IF_CNTL_REG_REPEAT_MODE_EN_POS);  
  } else {
    
    // The PTV must not be programmed when the timer is running

    SetField16(KBD_IF_CNTL_REG, SOFTWARE_NRESET, software_nreset);
    SetField16(KBD_IF_CNTL_REG, NSOFTWARE_MODE, nsoftware_mode);
    SetField16(KBD_IF_CNTL_REG, LONG_KEY_EN, long_key_process_en);
    SetField16(KBD_IF_CNTL_REG, TIME_OUT_EMPTY_EN, time_out_empty_en);
    SetField16(KBD_IF_CNTL_REG, TIME_OUT_LONG_KEY_EN, time_out_long_key_en);
    SetField16(KBD_IF_CNTL_REG, REPEAT_MODE_EN, repeat_mode_en);

    
  }
  

  
}


//-------------------------------------------------------------------------
//  KBD_IF_GetCtrlReg : Read the Control register
//-------------------------------------------------------------------------

void KBD_IF_GetCtrlReg(UWORD8 * const software_nreset, 
		       KBD_Nsoftware_mode_t * const nsoftware_mode, 
		       KBD_PTV_t * const ptv,
		       KBD_EnableDetection_t * const long_key_process_en,
		       KBD_EnableDetection_t * const time_out_empty_en,
		       KBD_EnableDetection_t * const time_out_long_key_en, 
		       KBD_EnableDetection_t * const repeat_mode_en)
{
  UWORD16 memReg = KBD_IF_CNTL_REG; 
  
  *software_nreset      =  memReg & KBD_IF_SOFT_NRES_MASK;
  *nsoftware_mode       = (memReg & KBD_IF_NSOFT_MODE_MASK)           >> KBD_IF_CNTL_REG_NSOFTWARE_MODE_POS;
  *ptv                  = (memReg & KBD_IF_PTV_MASK)                  >> KBD_IF_CNTL_REG_PTV_POS;
  *long_key_process_en  = (memReg & KBD_IF_LONG_KEY_EN_MASK)          >> KBD_IF_CNTL_REG_LONG_KEY_EN_POS; 
  *time_out_empty_en    = (memReg & KBD_IF_TIME_OUT_EMPTY_EN_MASK)    >> KBD_IF_CNTL_REG_TIME_OUT_EMPTY_EN_POS; 
  *time_out_long_key_en = (memReg & KBD_IF_TIME_OUT_LONG_KEY_EN_MASK) >> KBD_IF_CNTL_REG_TIME_OUT_LONG_KEY_EN_POS; 
  *repeat_mode_en       = (memReg & KBD_IF_REPEAT_MODE_EN_MASK)       >> KBD_IF_CNTL_REG_REPEAT_MODE_EN_POS;  
}


//-------------------------------------------------------------------------
//  KBD_IF_SoftwareReset : reset software  
//-------------------------------------------------------------------------

void KBD_IF_SoftwareReset(void)
{
  UWORD16 memReg;
  
  memReg = KBD_IF_CNTL_REG;
  memReg &=  ~KBD_IF_SOFT_NRES_MASK;
  KBD_IF_CNTL_REG = memReg; 
  
}

//-------------------------------------------------------------------------
//  KBD_IF_NormalOperation : Set the keyboard interface to operate Normally   
//-------------------------------------------------------------------------

void KBD_IF_NormalOperation(void)
{
  UWORD16 memReg;
  
  memReg = KBD_IF_CNTL_REG;
  memReg &=  ~KBD_IF_SOFT_NRES_MASK;
  memReg |= 0x0001;
  KBD_IF_CNTL_REG = memReg; 
  
}





//-------------------------------------------------------------------------
//  KBD_IF_EnableSoftwareMode : enable software mode.
//                              nsoftware_mode == SOFTWARE_MODE_ENABLE --> software decoding
//                              nsoftware_mode == HARDWARE_DECODING    --> hardware decoding
//-------------------------------------------------------------------------
void KBD_IF_EnableSoftwareMode(const KBD_Nsoftware_mode_t nsoftware_mode)
{
  
  SetField16(KBD_IF_CNTL_REG, NSOFTWARE_MODE, nsoftware_mode);
  
}



//-------------------------------------------------------------------------
//  KBD_IF_SetPTV : Set Pre-scale clock Timer
//-------------------------------------------------------------------------
void KBD_IF_SetPTV(const KBD_PTV_t ptv)
{
  
  KBD_Status_t StatusReg = KBD_IF_STATUS_STATE_MACHINE;
  
  if ( (StatusReg != KBD_IF_TEST_TIMER_DEBOUNCING) && (StatusReg != KBD_IF_TEST_TIMER_LONG_KEY) &&
       (StatusReg != KBD_IF_TEST_TIMER_TIME_OUT)   && (StatusReg != KBD_IF_TEST_TIMER_REPEAT_KEY) ){   
    
    // The PTV can be programmed only when the timer is not running
    SetField16(KBD_IF_CNTL_REG, PTV, ptv);
    
  }
  
}


//-------------------------------------------------------------------------
//  KBD_IF_EnableLongKeyDetection : enable long key process detection
//                                  long_key_process_en == KBD_DETECTION_ENABLED  --> long key detection enabled
//                                  long_key_process_en == KBD_DETECTION_DISABLED --> long key detection disabled
//-------------------------------------------------------------------------
void KBD_IF_EnableLongKeyDetection(const KBD_EnableDetection_t long_key_process_en)
{
  
  SetField16(KBD_IF_CNTL_REG, LONG_KEY_EN, long_key_process_en);
  
}

//-------------------------------------------------------------------------
//  KBD_IF_EnableTimeOutOnReleaseDetection : enable time out empty detection
//                                  time_out_empty_en == KBD_DETECTION_ENABLED  --> time out empty detection enabled
//                                  time_out_empty_en == KBD_DETECTION_DISABLED --> time out empty detection disabled
//-------------------------------------------------------------------------
void KBD_IF_EnableTimeOutOnReleaseDetection(const KBD_EnableDetection_t time_out_empty_en)
{
  
  SetField16(KBD_IF_CNTL_REG, TIME_OUT_EMPTY_EN, time_out_empty_en);
  
}



//-------------------------------------------------------------------------
//  KBD_IF_EnableTimeOutLongKeyDetection : enable time out long key detection
//                                  time_out_long_key_process_en == KBD_DETECTION_ENABLED  --> time out long key detection enabled
//                                  time_out_long_key_process_en == KBD_DETECTION_DISABLED --> time out long key detection disabled
//-------------------------------------------------------------------------
void KBD_IF_EnableTimeOutLongKeyDetection(const KBD_EnableDetection_t time_out_long_key_en)
{
  SetField16(KBD_IF_CNTL_REG, TIME_OUT_LONG_KEY_EN, time_out_long_key_en);
}



//-------------------------------------------------------------------------
//  KBD_IF_EnableRepeatModeDetection : enable long key process detection
//                                  repeat_mode_en == KBD_DETECTION_ENABLED  --> repeat mode detection enabled
//                                  repeat_mode_en == KBD_DETECTION_DISABLED --> repeat mode detection disabled
//-------------------------------------------------------------------------
void KBD_IF_EnableRepeatModeDetection(const KBD_EnableDetection_t repeat_mode_en)
{
  
  SetField16(KBD_IF_CNTL_REG, REPEAT_MODE_EN, repeat_mode_en);
  
}





////////////////////////////////////////
//                                    //
//       Times initializations        //
//                                    //
////////////////////////////////////////


//-------------------------------------------------------------------------
//  KBD_IF_SetDebouncingTime : Set the desired value of debouncing time
//-------------------------------------------------------------------------
void KBD_IF_SetDebouncingTime(const UWORD8 debouncing_time)
{
  
  KBD_IF_DEBOUNCING_TIME = debouncing_time;
  
}


//-------------------------------------------------------------------------
//  KBD_IF_SetLongKeyTime : Set the desired value of long key time
//-------------------------------------------------------------------------
void KBD_IF_SetLongKeyTime(const UWORD16 long_key_time)
{
  
  KBD_IF_LONG_KEY = long_key_time;
  
}



//-------------------------------------------------------------------------
//  KBD_IF_SetTimeOut : Set the desired value of time out
//-------------------------------------------------------------------------
void KBD_IF_SetTimeOut(const UWORD16 time_out)
{
  
  KBD_IF_TIME_OUT = time_out;
  
}





////////////////////////////////////////
//                                    //
//         Interrupt Enable           //
//                                    //
////////////////////////////////////////



//--------------------------------------------------------------------------------------
//  KBD_IF_Init_ItEnable :  Initialize Interrupt Enable -> connect or disconnect
//                          event, long key & time out interrupts 
//
//                          it_enable_value == summ of flag as follow (enable all interrupts) :
//                          KBD_IF_Init_ItEnable(KBD_IF_IT_EVENT_VALID | KBD_IF_IT_KEY_VALID |
//                                               KBD_IF_IT_LONG_KEY_VALID | KBD_IF_IT_TIME_OUT_VALID) 
//--------------------------------------------------------------------------------------
void KBD_IF_Init_ItEnable(const UWORD8 it_enable_value)
{
    
  KBD_IF_INTERRUPT_ENABLE = it_enable_value;

}




//--------------------------------------------------------------------------------------
//  KBD_IF_SetItEventEnable :   it_event_valid == KBD_IT_ENABLE_DISCONNECT --> disconnect it_event on kbd_if_it
//                              it_event_valid == KBD_IT_ENABLE_CONNECT    --> connect it_event on kbd_if_it
//--------------------------------------------------------------------------------------
void KBD_IF_SetItEventEnable(const KBD_InterruptEnable_t it_event_valid)
{
    
  SetField16(KBD_IF_INTERRUPT_ENABLE, IT_EVENT_VALID, it_event_valid);

}



//--------------------------------------------------------------------------------------
//  KBD_IF_SetItLongKeyEnable : it_long_key_valid == KBD_IT_ENABLE_DISCONNECT --> disconnect it_long_key on kbd_if_it
//                              it_long_key_valid == KBD_IT_ENABLE_CONNECT    --> connect it_long_key on kbd_if_it
//--------------------------------------------------------------------------------------
void KBD_IF_SetItLongKeyEnable(const KBD_InterruptEnable_t it_long_key_valid)
{
    
  SetField16(KBD_IF_INTERRUPT_ENABLE, IT_LONG_KEY_VALID, it_long_key_valid);

}



//--------------------------------------------------------------------------------------
//  KBD_IF_SetItTimeOutEnable : it_time_out_valid == KBD_IT_ENABLE_DISCONNECT --> disconnect it_time_out on kbd_if_it
//                              it_time_out_valid == KBD_IT_ENABLE_CONNECT    --> connect it_time_out on kbd_if_it
//--------------------------------------------------------------------------------------
void KBD_IF_SetItTimeOutEnable(const KBD_InterruptEnable_t it_time_out_valid)
{
    
  SetField16(KBD_IF_INTERRUPT_ENABLE, IT_TIME_OUT_VALID, it_time_out_valid);

}



//-------------------------------------------------------------------------
//  KBD_IF_GetInterruptEnable : Read the Interrupt Enable register
//-------------------------------------------------------------------------

void KBD_IF_GetInterruptEnable(KBD_InterruptEnable_t *const it_event_valid, 
			       KBD_InterruptEnable_t *const it_long_key_valid,
			       KBD_InterruptEnable_t *const it_time_out_valid)
{
  UWORD16 memReg = KBD_IF_INTERRUPT_ENABLE; 
  
  *it_event_valid    =  memReg & KBD_IF_IT_EVENT_MASK;
  *it_long_key_valid = (memReg & KBD_IF_IT_LONG_KEY_MASK) >> KBD_IF_INTERRUPT_ENABLE_IT_LONG_KEY_VALID_POS;
  *it_time_out_valid = (memReg & KBD_IF_IT_TIME_OUT_MASK) >> KBD_IF_INTERRUPT_ENABLE_IT_TIME_OUT_VALID_POS;

}






////////////////////////////////////////
//                                    //
//        Status State Machine        //
//                                    //
////////////////////////////////////////



void KBD_IF_GetStatusStateMachine(KBD_Status_t *const state_machine_status)
{

  UWORD16 memReg = KBD_IF_STATUS_STATE_MACHINE;

  *state_machine_status = memReg & KBD_IF_STATUS_STATE_MACHINE_MASK;

}


////////////////////////////////////////
//                                    //
//       Keyboard row inputs          //
//                                    //
////////////////////////////////////////

//-------------------------------------------------------------------------
//  KBD_IF_GetKbrLatch : Read the Keyboard row inputs register
//-------------------------------------------------------------------------