keydriver.c

uClinux 基于S3C44B0X 键盘驱动

/************************************************************************************************
* 								
*	Copyright (C) EVOC  Co., LTD. 2003		
*								
*	File name:	keydriver.c				
*	Description:    
*	  							
*	Revision history					
*               2006.06.13      Bing yu liu	start.	
*								
************************************************************************************************/
/* Include files--------------------------------------------------------------*/
 
 
#include "keydriver.h"

//struct KBDDEV;
//static KBDDEV *keydev
static U16 key;
static struct timer_list key_timer;

static void s3c44b0_getkey(void);
static void key_timer_handler(unsigned long data);

//***************************************************
// time=0: adjust the Delay function by WatchDog timer.
// 100us resolution.
//***************************************************
static void Delay0(U32 time)
{
	U32 i=0;
	for(;time>0;time--)
		for(i=0; i<delayLoopCount; i++);
}

//****************************************
//****************************************
static U8	SnapKey(void)
{
	U16 b;	
	b = CPLD_Key_Addr ;
	return	(b&NO_KEY);	
}
//****************************************
//****************************************
static U16 ScanKey(void)
{
	U16 ucTemp=0;
  U16	i;
  CPLD_Key_Addr = 0x0;
	ucTemp = SnapKey();	
	if(ucTemp!=NO_KEY)
	{	
		for(i=0;i<8;i++)
		{
			CPLD_Key_Addr = ~(1<<i);
			ucTemp = SnapKey();	
			if (ucTemp==NO_KEY)
				  continue;
			ucTemp = (i<<8)+ucTemp;
			return	ucTemp;
		}		
	}
	return NO_KEY;      		 
}
//****************************************
//****************************************
U16 KeyPad(void)
{ 
	U16 ucTemp,ucTemp1;
	ucTemp	= ScanKey();
	Delay0(20);
	ucTemp1 = ScanKey();
	
	if((ucTemp1 == ucTemp)&&(ucTemp1 != NO_KEY))
	{
		return ucTemp1;
	}
	return(NO_KEY);
}	 
//****************************************
//****************************************
U16 GetKey(void)
{
	U16	KeyValue=0;	
	KeyValue= KeyPad();
	while(KeyValue == NO_KEY)
	{
		KeyValue= KeyPad();
	}
	return	KeyValue;		
}
//****************************************
//****************************************
unsigned char KBhit(void)
{
		return (ScanKey()==NO_KEY)? 0:1;	
}
//****************************************
//****************************************
static int key_open(struct inode *inode,
										struct file *filp)
{
  MOD_INC_USE_COUNT;
  //keydev->head=keydev->tail=0;
  //keyEvent=keyEvent_raw;
  //key_timer.expires = jiffies + KEY_TIMER_DELAY1;
  //add_timer(&key_timer);
  printk("key_driver open!\n");
  return 0;
}
//*****************************************
//*****************************************
static int key_release(struct inode *inode,
                       struct file *filp)
{   
	MOD_DEC_USE_COUNT;
	//keyEvent=keyEvent_dummy;
  printk("key_driver close!\n");
  //del_timer(&key_timer);  
  return 0;  
}

//*******************************************
//*******************************************
static ssize_t key_read(struct file *filp,char * buff,size_t count,
                        loff_t * f_pos)
{
		U16 key_ret;
		key_ret = KeyPad();
		if(key_ret != NO_KEY)
		{
				copy_to_user(buff,(char*)&key_ret,sizeof(U16));
				return 2;
		}
		return -1;		
		 			
}
//********************************************
//********************************************
static int key_ioctl(struct inode *inode, 
                     struct file *filp,
		                 unsigned int cmd,     // the command to the ioctl 
		                 unsigned long arg)    // the parameter to it      
{ 	
  return 0;
}
//*******************************************************
//*******************************************************
static void s3c44b0_getkey(void)
{
		key=KeyPad();
		//if(key!=NO_KEY)keyEvent();
}
//*******************************************************
//*******************************************************
static struct file_operations key_fops={
		owner:    THIS_MODULE,
		read :    key_read,
		ioctl:    key_ioctl,
		open :    key_open,
		release:  key_release,	
};
//*********************************************
//*********************************************
static int __init key_init(void)
{
		int ret;
		
		//keyEvent=keyEvent_dummy;
		ret = register_chrdev(KEY_MAJOR,DEVICE_NAME,&key_fops);
		if(ret<0)
		{
				printk(DEVICE_NAME": Unable to get major %d\n",KEY_MAJOR);
		}
	#ifdef CONFIG_DEVFS_FS
	  devfs_kbd_dir=devfs_mk_dir(NULL,"keyboard",NULL);
	  devfs_kbdraw=devfs_register(devfs_kbd_dir,"0raw",
	               DEVFS_FL_DEFAULT,KEY_MAJOR,KEY_MINOR,
	               S_IFCHR|S_IRUSR|S_IWUSR,&key_fops,NULL);
  #endif
		//Enable interrupt		
		printk(DEVICE_NAME"initialized\n");
}
void __exit key_cleanup(void)
{
 #ifdef CONFIG_DEVFS_FS
	devfs_unregister(devfs_kbdraw);
	devfs_unregister(devfs_kbd_dir);
#endif
	unregister_chrdev(KEY_MAJOR,DEVICE_NAME);
	return ;
}
module_init(key_init);
module_exit(key_cleanup);
MODULE_LICENSE("GPL");