keypad.c

s3c6400 ADS下官方测试程序

/**************************************************************************************
* 
*	Project Name : S3C6400 Validation
*
*	Copyright 2006 by Samsung Electronics, Inc.
*	All rights reserved.
*
*	Project Description :
*		This software is only for validating functions of the S3C6400.
*		Anybody can use this software without our permission.
*  
*--------------------------------------------------------------------------------------
* 
*	File Name : keypad.c
*  
*	File Description : This file implements the API functons for KEYPAD
*
*	Author : Woojin.Kim
*	Dept. : AP Development Team
*	Created Date : 2007/01/22
*	Version : 0.1 
* 
*	History"
*	- Created(Woojin.Kim 2007/01/22)
*  
**************************************************************************************/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "keypad.h"

#include "option.h"
#include "library.h"
#include "sfr6400.h"
#include "system.h"
#include "sysc.h"
#include "gpio.h"
#include "intc.h"
#include "timer.h"





//////////
// Function Name : KEYPAD_SelectINT
// Function Description : This function selects Interrupt type
// Input : uSelect [1:Falling edge INT    2:Rising edge INT    3:Both edge INT]
// Output : NONE
// Version : v0.1

void KEYPAD_SelectINT(u8 ucSelect)	//1:Falling edge INT  2:Rising edge INT  3:Both edge INT
{
	u32 uTemp;

	uTemp = Inp32(rKEYIFCON);
	uTemp &= ~(0x3);
	uTemp |=(ucSelect & 0x3);
	Outp32(rKEYIFCON, uTemp);
	
}


//////////
// Function Name : KEYPAD_EnableDFFC
// Function Description : This function enables debouncing filter & filter clock
// Input : uEnDF [ 0: disable	1: enable]
// 		  uEnFC [ 0: disable	1: enable]
// Output : NONE
// Version : v0.1

void KEYPAD_EnableDFFC(u8 ucEnDF,u8 ucEnFC)
{
	u32 uTemp;

	uTemp = Inp32(rKEYIFCON);
	uTemp &= ~(0xc);
	uTemp |= ((ucEnDF<<2|ucEnFC<<3)&0xc);
	Outp32(rKEYIFCON,uTemp);

}


//////////
// Function Name : KEYPAD_EnableWakeup
// Function Description : This function enables Stop/Idle mode wakeup
// Input : uEnWakeup [ 0: disabe	1: Low lvl wake up		2: Rising Edge wake up		4.Filling Edge wake up]
// Output : NONE
// Version : v0.1

void KEYPAD_EnableWakeup(u8 ucEnWakeup)
{
	u32 uTemp;

	uTemp = Inp32(rKEYIFCON);
	uTemp &= ~(0x30);
	uTemp |= ((ucEnWakeup<<4)& 0x30 );

	Outp32(rKEYIFCON,uTemp);

}


//////////
// Function Name : KEYPAD_STSCLR
// Function Description : This function checks Interrupt status and clear register
// Input : P_INT [Pressed interrupt is cleared when write data is '1']
// 		  R_INT [Pressed interrupt is cleared when write data is '1']
// Output : NONE
// Version : v0.1

void KEYPAD_STSCLR(u8 ucP_INT, u8 ucR_INT)
{
	Outp32(rKEYIFSTSCLR, ucP_INT|ucR_INT<<8);
	
}


//////////
// Function Name : KEYPAD_COL
// Function Description : This function checks COL data output and enable tri-state buffer
// Input : COL [ column data output]
// 		  COLLength [0: tri-state buffer enable	1: disable]
// Output : NONE
// Version : v0.1

void KEYPAD_COL(u8 ucCOL,u8 ucCOLLength)
{
	Outp32(rKEYIFCOL,ucCOL|ucCOLLength<<8);
	
}


//////////
// Function Name : KEYPAD_ROW
// Function Description : This function reads ROW data input
// Input : NONE
// Output : rKEYIFROW value(u32)
// Version : v0.1

u32 KEYPAD_ROW(void)
{
	return Inp32(rKEYIFROW);
}


//////////
// Function Name : KEYPAD_FC
// Function Description : This function sets up Debouncing filter clock division
// Input : FC [FCLK = FLT_CLK/(FC+1)]
// Output : NONE
// Version : v0.1

void KEYPAD_FC(u32 uFC)
{
	Outp32(rKEYIFFC,uFC);

}


//////////
// Function Name : Isr_KEYPAD
// Function Description : This function is Interrupt Service Routine of KEYPAD
//									Following KEYPAD Scanning procedure
// Input : NONE
// Output : NONE
// Version : v0.1

void __irq Isr_KEYPAD(void)
{
	u8 aDat_row[8];
	u32 uIcnt=0;


	KEYPAD_STSCLR(0xff,0xff);

	INTC_Disable(NUM_KEYPAD);


while(1)
{


	KEYPAD_COL(0x7f,0);	
//	rKEYIFCOL=0x1f;
	DelayfrTimer(micro,1000);
//   	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[7]=((KEYPAD_ROW())&0xff);
	if(aDat_row[7]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[1]=0;
		aDat_row[2]=0;
		aDat_row[3]=0;
		aDat_row[4]=0;
		aDat_row[5]=0;
		aDat_row[6]=0;		
		break;
	}


	KEYPAD_COL(0xbf,0);	
//	rKEYIFCOL=0x1f;
	DelayfrTimer(micro,1000);
//   	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[6]=((KEYPAD_ROW())&0xff);
	if(aDat_row[6]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[1]=0;
		aDat_row[2]=0;
		aDat_row[3]=0;
		aDat_row[4]=0;
		aDat_row[5]=0;
		aDat_row[7]=0;		
		break;
	}



	KEYPAD_COL(0xdf,0);	
//	rKEYIFCOL=0x1f;
	DelayfrTimer(micro,1000);
//   	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[5]=((KEYPAD_ROW())&0xff);
	if(aDat_row[5]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[1]=0;
		aDat_row[2]=0;
		aDat_row[3]=0;
		aDat_row[4]=0;
		aDat_row[6]=0;
		aDat_row[7]=0;		
		break;
	}

	KEYPAD_COL(0xef,0);
//	rKEYIFCOL=0x2f;
	DelayfrTimer(micro,1000);
//	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[4]=((KEYPAD_ROW())&0xff);
	if(aDat_row[4]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[1]=0;
		aDat_row[2]=0;
		aDat_row[3]=0;
		aDat_row[5]=0;
		aDat_row[6]=0;
		aDat_row[7]=0;		
		break;
	}

	KEYPAD_COL(0xf7,0);
//	rKEYIFCOL=0x37; 
	DelayfrTimer(micro,1000);
//	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[3]=((KEYPAD_ROW())&0xff);
	if(aDat_row[3]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[1]=0;
		aDat_row[2]=0;
		aDat_row[4]=0;
		aDat_row[5]=0;
		aDat_row[6]=0;
		aDat_row[7]=0;		
		break;
	}
	
	KEYPAD_COL(0xfb,0);
//	rKEYIFCOL=0x3b;
	DelayfrTimer(micro,1000);
//	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[2]=((KEYPAD_ROW())&0xff);
	if(aDat_row[2]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[1]=0;
		aDat_row[3]=0;
		aDat_row[4]=0;
		aDat_row[5]=0;
		aDat_row[6]=0;
		aDat_row[7]=0;		
		break;
	}

	KEYPAD_COL(0xfd,0);
//   	rKEYIFCOL=0x3d;
	DelayfrTimer(micro,1000);
//	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
	aDat_row[1]=((KEYPAD_ROW())&0xff);
	if(aDat_row[1]!=0xff) 
	{
		aDat_row[0]=0;
		aDat_row[2]=0;
		aDat_row[3]=0;
		aDat_row[4]=0;
		aDat_row[5]=0;
		aDat_row[6]=0;
		aDat_row[7]=0;
		break;
	}

	KEYPAD_COL(0xfe,0);
//	rKEYIFCOL=0x3e;
	DelayfrTimer(micro,1000);
//	Delay(10);  //delay(100)=10msec, delay(10)=1msec 
	aDat_row[0]=((KEYPAD_ROW())&0xff);
	if(aDat_row[0]!=0xff) 
	{
		aDat_row[1]=0;
		aDat_row[2]=0;
		aDat_row[3]=0;
		aDat_row[4]=0;
		aDat_row[5]=0;
		aDat_row[6]=0;
		aDat_row[7]=0;		
		break;
	}


}


    //printf("row0:%x,row1:%x,row2:%x,row3:%x,row4:%x,row5:%x\n",
    //aDat_row[0],aDat_row[1],aDat_row[2],aDat_row[3],aDat_row[4],aDat_row[5]);

	for(uIcnt=0;uIcnt<9;uIcnt++)
	{
		if(aDat_row[uIcnt]==0xfe)
		{
			printf("[1,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0xfd)
		{
			printf("[2,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0xfb)
		{
			printf("[3,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0xf7)
		{
			printf("[4,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0xef)
		{
			printf("[5,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0xdf)
		{
			printf("[6,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0xbf)
		{
			printf("[7,%d]\n",uIcnt+1);
		}
		else if(aDat_row[uIcnt]==0x7f)
		{
			printf("[8,%d]\n",uIcnt+1);
		}		
	}


	KEYPAD_COL(0,0);
//	rKEYIFCOL=0x0;

//	Outp32(rKEYIFCON,uRestore_keycon);
	
	INTC_Enable(NUM_KEYPAD);
	INTC_ClearVectAddr();
 }


//////////
// Function Name : KEYPAD_Init
// Function Description : This function sets up KEYPAD GPIO(HOST I/F)
// Input : NONE
// Output : NONE
// Version : v0.1

void KEYPAD_Init(void)
{
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_8,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_9,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_10,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_11,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_12,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_13,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_14,3);
	GPIO_SetFunctionEach(eGPIO_K,eGPIO_15,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_0,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_1,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_2,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_3,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_4,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_5,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_6,3);
	GPIO_SetFunctionEach(eGPIO_L,eGPIO_7,3);	
//	rGPGCON=0xaaaaaa;
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_8,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_9,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_10,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_11,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_12,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_13,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_14,0);
	GPIO_SetPullUpDownEach(eGPIO_K,eGPIO_15,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_0,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_1,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_2,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_3,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_4,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_5,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_6,0);
	GPIO_SetPullUpDownEach(eGPIO_L,eGPIO_7,0);
	

//	rGPGPU=0xfff;

	printf("[KEY_PAD Test]\n");
//	printf("GPGCON=0x%x\n",rGPGCON);
}


//////////
// Function Name : KEYPAD_Init
// Function Description : This function sets up KEYPAD GPIO (MMC1&EINT)
// Input : NONE
// Output : NONE
// Version : v0.1

void KEYPAD_Init2(void)
{
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_0,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_1,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_2,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_3,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_4,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_5,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_6,4);
	GPIO_SetFunctionEach(eGPIO_H,eGPIO_7,4);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_0,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_1,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_2,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_3,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_4,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_5,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_6,3);
	GPIO_SetFunctionEach(eGPIO_N,eGPIO_7,3);	
//	rGPGCON=0xaaaaaa;
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_0,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_1,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_2,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_3,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_4,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_5,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_6,0);
	GPIO_SetPullUpDownEach(eGPIO_H,eGPIO_7,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_0,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_1,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_2,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_3,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_4,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_5,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_6,0);
	GPIO_SetPullUpDownEach(eGPIO_N,eGPIO_7,0);
	

//	rGPGPU=0xfff;

	printf("[KEY_PAD Test]\n");
//	printf("GPGCON=0x%x\n",rGPGCON);
}




/*
void KeyPad_SW_Test(void)
{
	uint32 IntType, FilterClk;

	IntType = 1;
	printf("\nInput the KeyPad Interrupt Type : ");
	printf("\n1 : Falling Edge[D],    2 : Rising Edge,    3 : Both Edge \n");
	IntType = GetIntNum(); 
	if( (IntType<1) || (IntType>3) )
		IntType = 1;	//Default Falling Edge Type

	FilterClk = 0;
	printf("\nInput the KeyPad Filter source Clock : ");
	printf("\n0 : RTC Clcok[D],     1 : OSCIN Clock\n");
	FilterClk = GetIntNum(); 
	if( FilterClk>1 )
		FilterClk = 0;	//Default Falling Edge Type

    	//FC_EN[3], DF_EN[2], INT_F_EN[0]
	rKEYIFCON=(FilterClk<<3)|(1<<2)|(IntType<<0);

	if(FilterClk == 0)
		rKEYIFFC=0x2;	//32KHz, 62.5us
	else
		rKEYIFFC=FIN*62500000/1000000;	//FIN, 62.5us
		
	//printf("rKEYIFCON=0x%x\n",rKEYIFCON);

	Key_pad_SWInit();

	//rKEYIFCOL=0x0;
	Key_Column_Output(0);

	rVECTADDR_KEYPAD = (int)Key_SWISR;
	INT_Enable0(BIT_KEYPAD);

	printf("\nPress Any KeyPad .......\n");
	
	while(!Uart_GetKey());

	INT_Disable0(BIT_KEYPAD);
}




void __irq Key_SWISR(void)
{
	unsigned short dat_row[6];
	int i=0,j=0;
	uint32 restore_keycon;

	restore_keycon = rKEYIFCON;
	rKEYIFCON=0x0;	
	rKEYIFSTSCLR=0x3; //Interrupt pending clear
	INT_Disable0(BIT_KEYPAD);

	while(1)
	{
		//rKEYIFCOL=0x1f;
		Key_Column_Output(0x1f);
	    	Delay(10);	//delay(100)=10msec, delay(10)=1msec 
		dat_row[5]=(rKEYIFROW&0x3f);
		if(dat_row[5]!=0x3f) 
		{
			dat_row[0]=0;
			dat_row[1]=0;
			dat_row[2]=0;
			dat_row[3]=0;
			dat_row[4]=0;
			break;
		}

		//rKEYIFCOL=0x2f;
		Key_Column_Output(0x2f);
		Delay(10);	//delay(100)=10msec, delay(10)=1msec 
		dat_row[4]=(rKEYIFROW&0x3f);
		if(dat_row[4]!=0x3f) 
		{
			dat_row[0]=0;
			dat_row[1]=0;
			dat_row[2]=0;
			dat_row[3]=0;
			dat_row[5]=0;
			break;
		}

		//rKEYIFCOL=0x37; 
		Key_Column_Output(0x37);
		Delay(10);	//delay(100)=10msec, delay(10)=1msec 
		dat_row[3]=(rKEYIFROW&0x3f);
		if(dat_row[3]!=0x3f) 
		{
			dat_row[0]=0;
			dat_row[1]=0;
			dat_row[2]=0;
			dat_row[4]=0;
			dat_row[5]=0;
			break;
		}
		
		//rKEYIFCOL=0x3b;
		Key_Column_Output(0x3B);
		Delay(10);	//delay(100)=10msec, delay(10)=1msec 
		dat_row[2]=(rKEYIFROW&0x3f);
		if(dat_row[2]!=0x3f) 
		{
			dat_row[0]=0;
			dat_row[1]=0;
			dat_row[4]=0;
			dat_row[3]=0;
			dat_row[5]=0;
			break;
		}

		//rKEYIFCOL=0x3e;
		Key_Column_Output(0x3E);
		Delay(10);  //delay(100)=10msec, delay(10)=1msec 
		dat_row[0]=(rKEYIFROW&0x3f);
		if(dat_row[0]!=0x3f) 
		{
			dat_row[4]=0;
			dat_row[1]=0;
			dat_row[2]=0;
			dat_row[3]=0;
			dat_row[5]=0;
			break;
		}

	    	//rKEYIFCOL=0x3d;
	    	Key_Column_Output(0x3D);
		Delay(10);	//delay(100)=10msec, delay(10)=1msec 
		dat_row[1]=(rKEYIFROW&0x3f);
		if(dat_row[1]!=0x3f) 
		{
			dat_row[0]=0;
			dat_row[4]=0;
			dat_row[2]=0;
			dat_row[3]=0;
			dat_row[5]=0;
			break;
		}
	}


	for(i=0;i<7;i++)
	{
		if(dat_row[i]==0x3e)
		{
			printf("[1,%d]\n",i+1);
		}
		else if(dat_row[i]==0x3d)
		{
			printf("[2,%d]\n",i+1);
		}
		else if(dat_row[i]==0x3b)
		{
			printf("[3,%d]\n",i+1);
		}
		else if(dat_row[i]==0x37)
		{
			printf("[4,%d]\n",i+1);
		}
		else if(dat_row[i]==0x2f)
		{
			printf("[5,%d]\n",i+1);
		}
		else if(dat_row[i]==0x1f)
		{
			printf("[6,%d]\n",i+1);
		}
	}

	Key_Column_Output(0);
	rKEYIFCON=restore_keycon;

	INT_Enable0(BIT_KEYPAD);
	Write_VECTADDR(0x0);
 }

void Key_Column_Output(uint32 Col_data)
{
	rGPGDAT = (rGPGDAT & ~0xFC0) | (Col_data<<6);
}



void Key_pad_SWInit(void)
{
	rGPGCON=0x555aaa;		// Row : HW,  Column : SW
	rGPGPU=0xfff;

}
*/