十六、输入子系统驱动模型

一、概述

• 输入子系统驱动模型也是字符设备驱动的一种模型，是对普通字符设备驱动的封装，专门用于输入类型的设备。
• 嵌入式linux系统中的输入类型设备：按键、鼠标、键盘、触摸屏、游戏手柄、手写板等等。

二、输入子系统驱动模型的优点

• 简化普通字符设备驱动的设计步骤
• 给应用程序提供统一的标准接口。硬件平台不同，驱动程序不同，但是驱动给应用程序的接口是相同的，应用程序是相同的。

三、查看输入设备

1、输入设备的设备文件

 

输入设备的主设备号都是13，次设备号不同。

2、设备名称

 

 3、查看输入设备驱动信息

 

 4.简单读取输入设备文件的内容

[root@GEC6818 /]#cat /dev/input/event0

四、应用程序如何读取驱动提供的数据

对于输入子系统驱动模型，驱动程序提供应用程序的是一个统一格式的结构体。

struct input_event {
	struct timeval time;    //输入时间发生的时间戳
	__u16 type;              //输入设备的类型    
	__u16 code;             //   
	__s32 value;
};    　

 

结构体成员说明：

（1）time:输入事件发生的时间戳。

（2）type:输入设备的类型。

#define EV_SYN			0x00-----同步类型的事件，按键或触摸屏每次动作都会触发一次同步类型的事件
#define EV_KEY			0x01----按键类型的事件，键盘或鼠标的左右键
#define EV_REL			0x02----相对位移事件，鼠标滑动
#define EV_ABS			0x03----绝对位移事件，触摸屏的点击
#define EV_MSC			0x04
#define EV_SW			0x05
#define EV_LED			0x11
#define EV_SND			0x12
#define EV_REP			0x14
#define EV_FF			0x15
#define EV_PWR			0x16
#define EV_FF_STATUS		0x17
#define EV_MAX			0x1f
#define EV_CNT			(EV_MAX+1)

（3）code:输入事件的编码

• 如果type==EV_ABS(绝对位移)，测code表示的是坐标轴方向。

/*
 * Absolute axes
 */

#define ABS_X			0x00----x坐标轴
#define ABS_Y			0x01----y坐标轴
#define ABS_Z			0x02

• 如果type==EV_REL（相对位移）,那么code表示的是坐标轴方向

#define REL_X			0x00----x坐标轴
#define REL_Y			0x01----y坐标轴
#define REL_Z			0x02----z坐标轴

• 如果type==EV_KEY,那么code表示的是具体哪一个按键

#define KEY_1			2
#define KEY_2			3
#define KEY_3			4
#define KEY_4			5
#define KEY_5			6

#define KEY_A			30
#define KEY_S			31
#define KEY_D			32
#define KEY_F			33

（4）value

如果type==EV_KEY && code == KEY_A,那么value表示的是按键A的状态：0----松开，1----按下，2---长按
如果type==EV_ABS && code == ABS_X,那么value表示的是X轴的具体坐标值
				&& code == ABS_Y,那么value表示的是Y轴的具体坐标值　

五、输入子系统驱动设计---以开发板上按键为例

1、定义一个输入设备（input_dev结构体变量）

struct input_dev
{
	const char *name;----输入设备的名字  #cat /proc/bus/input/devices 
	const char *phys;
	const char *uniq;
	struct input_id id;----I: Bus=0018 Vendor=12fa Product=2143 Version=0100
	----------------------------------------------
	struct input_id {
		__u16 bustype;----总线类型Bus
		__u16 vendor;-----厂商编码Vendor
		__u16 product;----产品编号Product
		__u16 version;----版本号Version
	};
		

	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];-----输入设备的类型标志
	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];----如果type==EV_KEY,keybit标识的是那些按键
	unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
	unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
	unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
	unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
	unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
	unsigned long swbit[BITS_TO_LONGS(SW_CNT)];

	unsigned int hint_events_per_packet;

	unsigned int keycodemax;
	unsigned int keycodesize;
	void *keycode;

	int (*setkeycode)(struct input_dev *dev,
			  const struct input_keymap_entry *ke,
			  unsigned int *old_keycode);
	int (*getkeycode)(struct input_dev *dev,
			  struct input_keymap_entry *ke);

	struct ff_device *ff;

	unsigned int repeat_key;
	struct timer_list timer;

	int rep[REP_CNT];

	struct input_mt_slot *mt;
	int mtsize;
	int slot;
	int trkid;

	struct input_absinfo *absinfo;

	unsigned long key[BITS_TO_LONGS(KEY_CNT)];
	unsigned long led[BITS_TO_LONGS(LED_CNT)];
	unsigned long snd[BITS_TO_LONGS(SND_CNT)];
	unsigned long sw[BITS_TO_LONGS(SW_CNT)];

	int (*open)(struct input_dev *dev);
	void (*close)(struct input_dev *dev);
	int (*flush)(struct input_dev *dev, struct file *file);
	int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

	struct input_handle __rcu *grab;

	spinlock_t event_lock;
	struct mutex mutex;

	unsigned int users;
	unsigned int users_private;
	bool going_away;
	bool disabled;

	bool sync;

	struct device dev;

	struct list_head	h_list;
	struct list_head	node;
}

例如：static struct input_dev *gec6818_key;

2、给输入设备结构体指针分配内存空间，并做基本的初始化。

/**
 * input_allocate_device - allocate memory for new input device
 *
 * Returns prepared struct input_dev or NULL.
 *
 * NOTE: Use input_free_device() to free devices that have not been
 * registered; input_unregister_device() should be used for already
 * registered devices.
 */

struct input_dev *input_allocate_device(void)

3、向内核注册输入设备结构体

/**
 * input_register_device - register device with input core
 * @dev: device to be registered
 *
 * This function registers device with input core. The device must be
 * allocated with input_allocate_device() and all it's capabilities
 * set up before registering.
 * If function fails the device must be freed with input_free_device().
 * Once device has been successfully registered it can be unregistered
 * with input_unregister_device(); input_free_device() should not be
 * called in this case.
 */

int input_register_device(struct input_dev *dev)

4、注册申请中断

static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
	    const char *name, void *dev)

5、中断处理程序

irqreturn_t xxx_handler(int, void *)
{

	//上报输入事件
	void input_event(struct input_dev *dev,
			unsigned int type, unsigned int code, int value)

}

6、驱动模块的出口函数

（1）注销输入设备 ：
void input_unregister_device(struct input_dev *dev)
（2）释放输入设备内存空间  
void input_free_device(struct input_dev *dev)　

　　

六、驱动设计的注意事项

1、输入子系统模型中，自带等待队列。如果没有输入事件，应用程序中的read会阻塞；如果有输入事件，应用程序会被唤醒。

2、输入子系统模型中，自带了默认的文件操作集合，不需要提供文件操作集合

3、输入设备结构体中evbit keybit的位操作，要用到内核源码提供的位接口函数，以下几个位接口函数是原子操作，在位操作时不会 被打断；而”或“和”与“不是原子操作，在与或过程中会被打断。

/*
 * NMI events can occur at any time, including when interrupts have been
 * disabled by *_irqsave().  So you can get NMI events occurring while a
 * *_bit function is holding a spin lock.  If the NMI handler also wants
 * to do bit manipulation (and they do) then you can get a deadlock
 * between the original caller of *_bit() and the NMI handler.
 *
 * by Keith Owens
 */

/**
 * set_bit - Atomically set a bit in memory
 * @nr: the bit to set
 * @addr: the address to start counting from
 *
 * This function is atomic and may not be reordered.  See __set_bit()
 * if you do not require the atomic guarantees.
 *
 * Note: there are no guarantees that this function will not be reordered
 * on non x86 architectures, so if you are writing portable code,
 * make sure not to rely on its reordering guarantees.
 *
 * Note that @nr may be almost arbitrarily large; this function is not
 * restricted to acting on a single-word quantity.
 */
static inline void set_bit(int nr, volatile unsigned long *addr)


/**
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
 *
 * clear_bit() is atomic and may not be reordered.  However, it does
 * not contain a memory barrier, so if it is used for locking purposes,
 * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
 * in order to ensure changes are visible on other processors.
 */
static inline void clear_bit(int nr, volatile unsigned long *addr)


/**
 * change_bit - Toggle a bit in memory
 * @nr: Bit to change
 * @addr: Address to start counting from
 *
 * change_bit() is atomic and may not be reordered. It may be
 * reordered on other architectures than x86.
 * Note that @nr may be almost arbitrarily large; this function is not
 * restricted to acting on a single-word quantity.
 */
static inline void change_bit(int nr, volatile unsigned long *addr)

4、按键驱动中必须有按下和松开两种状态，如果只检测按下（下降沿触发），没有松开，程序会卡死。所以，中断注册时，上升沿和下降沿都触发中断。　　

七、按键输入设备驱动代码

key_drv.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/gpio.h>
#include <cfg_type.h>
#include <linux/interrupt.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/input.h>
struct key_gpio_t{
	unsigned int irq;
	unsigned int gpiono;
	char irqname[20];
	unsigned char keyvalue;
	unsigned int code;
};


static struct input_dev *key_input=NULL;


static struct key_gpio_t key_gpio[]=
{
	{IRQ_GPIO_A_START+28,PAD_GPIO_A+28,"KEY2_GPIOA28",2,KEY_UP},
	{IRQ_GPIO_B_START+30,PAD_GPIO_B+30,"KEY3_GPIOB30",3,KEY_DOWN},
	{IRQ_GPIO_B_START+31,PAD_GPIO_B+31,"KEY4_GPIOB31",4,KEY_LEFT},
	{IRQ_GPIO_B_START+9,  PAD_GPIO_B+9,"KEY6_GPIOB9",6,KEY_LEFT},
};

static irqreturn_t key_handler(int irq, void * dev)
{
   	int value;
	struct key_gpio_t keytmp=*(struct key_gpio_t *)dev;
	value=gpio_get_value(keytmp.gpiono);
	input_report_key(key_input, keytmp.code, !value); //上报输入事件
	input_sync(key_input);  //每次上报事件结束，都需要上报一次同步事件
	return IRQ_HANDLED;
}	

static int __init  key_init(void)
{
      int ret,i;
       printk(KERN_INFO"key_init\n");
	key_input = input_allocate_device();
	if(key_input==NULL)
	{
		printk(KERN_INFO"allocate input device failed.\n");
		ret = -ENOMEM;
		goto input_allocate_device_err;
	}
	key_input->name = "key_input_dev";
	key_input->id.bustype = 0x0001;
	key_input->id.vendor= 0x0002;
	key_input->id.product= 0x0003;
	key_input->id.version = 0x0004;
	//该输入设备能够触发按键类型的事件
	set_bit(EV_KEY,key_input->evbit);
	//触发的是按键类型中 的KEY_UP KEY_DOWN KEY_LEFT KEY_RIGHT
	for(i=0;i<4;i++)
	{
		set_bit(key_gpio[i].code,key_input->keybit);
	}
	
	//注册输入设备
    ret =  input_register_device(key_input);
	if(ret < 0)
	{
		printk(KERN_INFO"register input dev failed.\n");
		goto input_register_device_err;
	}
	
	for(i=0;i<4;i++)
	{
		//按键按下和释放都要检测到
		 ret = request_irq(key_gpio[i].irq, key_handler,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,key_gpio[i].irqname,(void*)&key_gpio[i]);
		 if(ret < 0)
		 {
		 	printk(KERN_INFO"request_irq fail.\n");
			goto irq_request_err;
		 }
	}
	return 0;


irq_request_err:
	while(i--) 
	{
		free_irq(key_gpio[i].irq,NULL);
	}
	input_unregister_device(key_input);
input_register_device_err:
		 input_free_device(key_input);
input_allocate_device_err:
		return ret;
}

static void __exit key_exit(void)
{
	int i;
    printk(KERN_INFO"key_exit\n"); 
     
      for(i=0;i<4;i++) 
     {
		free_irq(key_gpio[i].irq,(void *)&key_gpio[i]);
     }
   input_unregister_device(key_input);	  
    input_free_device(key_input);	  
    	
}

module_init(key_init);
module_exit(key_exit);
MODULE_LICENSE("GPL");　

main.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <linux/input.h>

struct input_event keyinfo;
int main()
{
    int fd,ret;

    fd = open("/dev/input/event4",O_RDONLY);
    if(fd<0)
    {
        perror("open event4 error!");      
        return -1;  
    }
    while(1)
    {
        ret=read(fd,&keyinfo,sizeof(keyinfo));   //没有按键动作，阻塞。
        /*
        if(ret !=1)
        {
            perror("read error");
            continue;
        }*/
       if(keyinfo.type==EV_KEY) 
       {
                switch(keyinfo.code)
                {
                        case KEY_UP:
                                if(keyinfo.value == 1)
                                {
                                    printf("key_up press\n");
                                }
                                else if(keyinfo.value == 0)
                                {
                                    printf("key_up release\n");
                                }
                        break;

                        case KEY_DOWN:
                                if(keyinfo.value == 1)
                                {
                                    printf("KEY_DOWN press\n");
                                }
                                else if(keyinfo.value == 0)
                                {
                                    printf("KEY_DOWN release\n");
                                }
                        break;
                        case KEY_LEFT:
                                if(keyinfo.value == 1)
                                {
                                    printf("KEY_LEFT press\n");
                                }
                                else if(keyinfo.value == 0)
                                {
                                    printf("KEY_LEFT release\n");
                                }
                        break;

                        case KEY_RIGHT:
                                if(keyinfo.value == 1)
                                {
                                    printf("KEY_RIGHT press\n");
                                }
                                else if(keyinfo.value == 0)
                                {
                                    printf("KEY_RIGHT release\n");
                                }
                        break;
                        default:
                         printf("other\n");
                        break;     
                }      
       }
    }
    
     close(fd);
}