《Linux驱动：s3c2410/s3c2440 ts驱动分析 -- 终结篇》

一，前言

前面结合“平台总线-设备-驱动”模型分析了ts(触摸)驱动的加载过程，现在进入驱动程序分析下其具体的实现。涉及到输入子系统详解、input输入子系统核心层程序分析、evdev输入子系统事件处理层程序分析、ts输入子系统设备驱动层程序分析、字符设备驱动分析、主设备号和次设备号的使用、以及s3c2440的ADC转换和触摸控制器的操作。

二，涉及的寄存器

三，调用probe函数

根据上一篇的分析，驱动层通过platform_driver_register注册后，会调用到该驱动层的probe函数。

四，s3c2410ts_probe函数分析

4.1 硬件寄存器设置

4.1.1 获取设备参数

    struct s3c2410_ts_mach_info *info;

	info = ( struct s3c2410_ts_mach_info *)pdev->dev.platform_data;

	/*
	info
		.delay = 10000,   // ADC conversion start delay value
    	.presc = 49,      // ADC clk
    	.oversampling_shift = 2, // 采样精度
	*/

	if (!info)
	{
		printk(KERN_ERR "Hm... too bad : no platform data for ts\n");
		return -EINVAL;
	}

4.1.2 使能ADC

adc_clock = clk_get(NULL, "adc");
if (!adc_clock) {
    printk(KERN_ERR "failed to get adc clock source\n");
    return -ENOENT;
}
clk_enable(adc_clock);

4.1.3 获取ADC & TOUCH SCREEN 寄存器

static inline void s3c2410_ts_connect(void)
{
	s3c2410_gpio_cfgpin(S3C2410_GPG12, S3C2410_GPG12_XMON);
	s3c2410_gpio_cfgpin(S3C2410_GPG13, S3C2410_GPG13_nXPON);
	s3c2410_gpio_cfgpin(S3C2410_GPG14, S3C2410_GPG14_YMON);
	s3c2410_gpio_cfgpin(S3C2410_GPG15, S3C2410_GPG15_nYPON);
}

{
    .....
    base_addr=ioremap(S3C2410_PA_ADC,0x20);  //#define S3C2410_PA_ADC	   (0x58000000)
	if (base_addr == NULL) {
		printk(KERN_ERR "Failed to remap register block\n");
		return -ENOMEM;
	}

	/* Configure GPIOs */
	s3c2410_ts_connect(); // 设置GPIO功能
    .....
}
    

4.1.4 设置ADC转换频率

if ((info->presc&0xff) > 0)
		iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\
			     base_addr+S3C2410_ADCCON);    
// 设置ADC clk 
// A/D converter freq = PCLK/(info->presc+1)  
// 一次adc转换所需时间Conversion time = 1/(A/D converter freq / 5cycles)

4.1.5 设置ADC转换开始的延时时间

因为ADC中断产生后的一段时间内电压还未稳定，如果立即进行ADC转换，那么转换值会有误差，这时就可以通过设置延时时间，待电压稳定后再执行转换以确保数值的准确性。

// 设置ADC conversion start delay value
if ((info->delay&0xffff) > 0)
		iowrite32(info->delay & 0xffff,  base_addr+S3C2410_ADCDLY);  

4.1.6 进入等待触摸按下模式

iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  // 等待触摸按下中断模式

自此，ADC & TOUCH SCREEN 寄存器初始设置完成。

4.2 注册ADC和TC中断

注册TC中断，监测触摸屏的按下和抬起；注册ADC中断，进行ADC转换。

/* Get irqs */
if (request_irq(IRQ_ADC, stylus_action, IRQF_SAMPLE_RANDOM | SA_SHIRQ,
                "s3c2410_action", ts.dev)) {
    printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_ADC !\n");
    iounmap(base_addr);
    return -EIO;
}
if (request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM,
                "s3c2410_action", ts.dev)) {
    printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_TC !\n");
    iounmap(base_addr);
    return -EIO;
}

4.2.1 TC中断处理函数 stylus_updown

static irqreturn_t stylus_updown(int irq, void *dev_id)
{
	unsigned long data0;
	unsigned long data1;
	int updown;

    // 读取寄存器DATA0和DATA1获取x,y轴的ADC转换值
	data0 = ioread32(base_addr+S3C2410_ADCDAT0);
	data1 = ioread32(base_addr+S3C2410_ADCDAT1);

	// ADCDAT0 bit[15] 0 为按下，1 为松开 即updown 为true 则按下，为false 则松开
	updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

	/* TODO we should never get an interrupt with updown set while
	 * the timer is running, but maybe we ought to verify that the
	 * timer isn't running anyways. */

	if (updown)
	{
		// 如果为按下状态
		touch_timer_fire(0);
	}

	return IRQ_HANDLED;
}

4.2.2 ADC中断处理函数 stylus_action

static irqreturn_t stylus_action(int irq, void *dev_id)
{
	unsigned long data0;
	unsigned long data1;

//	if (bADCForTS) {
	
		data0 = ioread32(base_addr+S3C2410_ADCDAT0);
		data1 = ioread32(base_addr+S3C2410_ADCDAT1);
	
		ts.xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;  // 为四次adc转换值的累加
		ts.yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;  // 为四次adc转换值的累加
		ts.count++;

//		bADCForTS = 0;
//		up(&gADClock);
		//  ts.count < 4 ,即四次adc转换值为一次按下的结果            					
	    if (ts.count < (1<<ts.shift)) {
//				if (!down_trylock(&gADClock)) {
//					bADCForTS = 1;
					iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC); // 进入 等待adc 转换模式 
					iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON); // 开启adc转换，转换在info->delay后进行，转换完成后会产生一个ADC中断
//			}
		} else {

			mod_timer(&touch_timer, jiffies+1); // 启动一个定时器，一个jiffies（系统滴答时间） 后进入定时器处理函数 touch_timer_fire
			iowrite32(WAIT4INT(1), base_addr+S3C2410_ADCTSC); // 同时等待 触摸抬起中断
		}
//	}
	return IRQ_HANDLED;
}

4.2.3 定时器处理函数 touch_timer_fire

static struct timer_list touch_timer =
		TIMER_INITIALIZER(touch_timer_fire, 0, 0);

static void touch_timer_fire(unsigned long data)
{
  	unsigned long data0;
  	unsigned long data1;
	int updown;

  	data0 = ioread32(base_addr+S3C2410_ADCDAT0);
  	data1 = ioread32(base_addr+S3C2410_ADCDAT1);

 	updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));
	// updown 为true 则按下，为false 则松开

 	if (updown) {
		// 处于按下状态的处理

		// 首次按下 产生了四次ADC转换后，才去处理x,y值
 		if (ts.count != 0) {
			long tmp;  

			// 横纵坐标转换
			tmp = ts.xp;
			ts.xp = ts.yp;
			ts.yp = tmp;

 			ts.xp >>= ts.shift; // 四次adc转换值的平均值为一次按下的结果
 			ts.yp >>= ts.shift; // 四次adc转换值的平均值为一次按下的结果

#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
 			{
 				struct timeval tv;
 				do_gettimeofday(&tv);
 				printk(DEBUG_LVL "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts.xp, ts.yp);
 			}
#endif

 			input_report_abs(ts.dev, ABS_X, ts.xp);   // 上报x的坐标
 			input_report_abs(ts.dev, ABS_Y, ts.yp);	  // 上报y的坐标

 			input_report_key(ts.dev, BTN_TOUCH, 1);		// 上报BIN_TOUCH 按下
 			input_report_abs(ts.dev, ABS_PRESSURE, 1);  // 上报ABS_PRESSURE 按下
 			input_sync(ts.dev);							// 上报事件完成
 		}

 		ts.xp = 0;
 		ts.yp = 0;
 		ts.count = 0;

//		if (!down_trylock(&gADClock)) {
//			bADCForTS = 1;
  		iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);  // 进入 等待adc 转换模式 
  		iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON); // 开启adc转换，完成后会产生一个ADC中断
//  	}
 	} else {
		// 松开的处理

 		ts.count = 0;

 		input_report_key(ts.dev, BTN_TOUCH, 0);   // 上报BIN_TOUCH 松开
 		input_report_abs(ts.dev, ABS_PRESSURE, 0);// 上报ABS_PRESSURE 松开
 		input_sync(ts.dev);						  // 上报事件完成

 		iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  // 进入等待触摸按下中断
 	}
}

4.3 注册到输入子系统

4.3.1 申请input_dev

input_dev = input_allocate_device();

if (!input_dev) {
    printk(KERN_ERR "Unable to allocate the input device !!\n");
    return -ENOMEM;
}

4.3.2 设置input_dev

ts.dev = input_dev;
// 设置产生的事件类型，同步类事件、按键类事件和绝对位移事件
ts.dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
// 设置某类事件类型中的具体事件
// 按键类事件中的触摸事件
ts.dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
// 绝对位移类事件中的ABS_X、ABS_Y、压力值的值范围，0x3ff是该ADC转换器是10bit精度的，最大为0x3fff
input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0);
input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0);
input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0); // 只设置有按下和抬起（0，1），没有具体的压力值

ts.dev->private = &ts;
ts.dev->name = s3c2410ts_name;
ts.dev->id.bustype = BUS_RS232;
ts.dev->id.vendor = 0xDEAD;
ts.dev->id.product = 0xBEEF;
ts.dev->id.version = S3C2410TSVERSION;

4.3.3 注册

input_register_device(ts.dev);

自此，该驱动设备注册到输入子系统中，会和事件处理层程序evdev匹配。

五，输入子系统

输入子系统分为三个层次，设备驱动层、核心层、以及事件处理层。

图片来源于网络

三个层级间的处理和联系

图片来源于网络

详细见csdn：https://blog.csdn.net/qq_40709487/article/details/126002350

六，驱动层ts程序和事件处理层程序evdev匹配

6.1 evdev的注册

编译进内核，系统启动时自动加载，进而调用其evdev_init函数。

6.1.1 编译进内核

linux-2.6.22.6/drivers/input/Makefile

obj-$(CONFIG_INPUT_EVDEV)   += evdev.o

linux-2.6.22.6/.config

CONFIG_INPUT_EVDEV=y

6.1.2 调用evdev_init，注册到输入子系统

static struct input_handler evdev_handler = {
    .event =	evdev_event,
    .connect =	evdev_connect,
    .disconnect =	evdev_disconnect,
    .fops =		&evdev_fops,
    .minor =	EVDEV_MINOR_BASE,
    .name =		"evdev",
    .id_table =	evdev_ids,
};

static int __init evdev_init(void)
{
    return input_register_handler(&evdev_handler);
}

6.2 驱动层ts程序注册到输入子系统

由第四点的s3c2410ts_probe函数分析可知，驱动层通过input_register_device接口注册到输入子系统。

input_register_device(ts.dev);

6.3 匹配

6.3.1 evdev注册时尝试匹配驱动层ts程序

int input_register_handler(struct input_handler *handler)
{
	struct input_dev *dev;

	INIT_LIST_HEAD(&handler->h_list);

	if (handler->fops != NULL) {
		if (input_table[handler->minor >> 5])
			return -EBUSY;

		input_table[handler->minor >> 5] = handler;
	}
    
    // 将处理层程序加入到input_handler_list链表
	list_add_tail(&handler->node, &input_handler_list);  

    // 从设备驱动层链表中取出每一个设备驱动层程序，和事件处理层程序匹配
	list_for_each_entry(dev, &input_dev_list, node)     
		input_attach_handler(dev, handler);

	input_wakeup_procfs_readers();
	return 0;
}

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;

	// 和事件处理层程序中设置的黑名单进行匹配，如果设备驱动层程序在白名单中，则忽略！
	if (handler->blacklist && input_match_device(handler->blacklist, dev))
		return -ENODEV;

	// 进行匹配
	id = input_match_device(handler->id_table, dev);
	if (!id)
		return -ENODEV;

	// 调用事件处理层程序中的connect函数 使事件处理层程序和设备驱动层程序建立联系。
	error = handler->connect(handler, dev, id);
	if (error && error != -ENODEV)
		printk(KERN_ERR
			"input: failed to attach handler %s to device %s, "
			"error: %d\n",
			handler->name, kobject_name(&dev->cdev.kobj), error);

	return error;
}

static const struct input_device_id *input_match_device(const struct input_device_id *id,
							struct input_dev *dev)
{
	int i;

	// id:
	// static const struct input_device_id evdev_ids[] = {
	// 	{ .driver_info = 1 },	/* Matches all devices */
	// 	{ },			/* Terminating zero entry */
	// };
	
	// dev:
	// ts.dev->id.bustype = BUS_RS232;
	// ts.dev->id.vendor = 0xDEAD;
	// ts.dev->id.product = 0xBEEF;
	// ts.dev->id.version = S3C2410TSVERSION;
    
    // evdev事件处理层程序成功匹配ts驱动层程序
	for (; id->flags || id->driver_info; id++) {

		if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
			if (id->bustype != dev->id.bustype)
				continue;

		if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
			if (id->vendor != dev->id.vendor)
				continue;

		if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
			if (id->product != dev->id.product)
				continue;

		if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
			if (id->version != dev->id.version)
				continue;

		MATCH_BIT(evbit,  EV_MAX);
		MATCH_BIT(keybit, KEY_MAX);
		MATCH_BIT(relbit, REL_MAX);
		MATCH_BIT(absbit, ABS_MAX);
		MATCH_BIT(mscbit, MSC_MAX);
		MATCH_BIT(ledbit, LED_MAX);
		MATCH_BIT(sndbit, SND_MAX);
		MATCH_BIT(ffbit,  FF_MAX);
		MATCH_BIT(swbit,  SW_MAX);

		return id;
	}

	return NULL;
}

6.3.2 驱动层ts程序注册时尝试匹配evdev

int input_register_device(struct input_dev *dev)
{
	static atomic_t input_no = ATOMIC_INIT(0);
	struct input_handler *handler;
	const char *path;
	int error;

	set_bit(EV_SYN, dev->evbit);

	/*
	 * If delay and period are pre-set by the driver, then autorepeating
	 * is handled by the driver itself and we don't do it in input.c.
	 */

	init_timer(&dev->timer);
	if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
		dev->timer.data = (long) dev;
		dev->timer.function = input_repeat_key;
		dev->rep[REP_DELAY] = 250;
		dev->rep[REP_PERIOD] = 33;
	}

    /* 没有定义设备的getkeycode函数，则使用默认的获取键值函数 */
	if (!dev->getkeycode)
		dev->getkeycode = input_default_getkeycode;

     /*没有定义设备的setkeycode函数，则使用默认的设定键值函数*/
	if (!dev->setkeycode)
		dev->setkeycode = input_default_setkeycode;

	// 将设备驱动层程序加入到input_dev_list链表
	list_add_tail(&dev->node, &input_dev_list);

	snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id),
		 "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);

	if (!dev->cdev.dev)
		dev->cdev.dev = dev->dev.parent;
    
    // 会在/sys/class/input设备类下创建设备 /sys/class/input/input%ld
	error = class_device_add(&dev->cdev);
	if (error)
		return error;

	path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL);
	printk(KERN_INFO "input: %s as %s\n",
		dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
	kfree(path);

	// 从事件处理层程序链表中取出每一个事件处理层程序，和设备驱动层程序匹配
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);

	input_wakeup_procfs_readers();

	return 0;
}

调用 input_attach_handler 之后的流程和evdev注册时尝试匹配驱动层ts程序一样

6.3.3 匹配成功建立联系

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
{
	struct evdev *evdev;
	struct class_device *cdev;
	dev_t devt;
	int minor;
	int error;

	// 从evdev_table数组中取出空位。最多支持32个设备。
	for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);
	if (minor == EVDEV_MINORS) {
		printk(KERN_ERR "evdev: no more free evdev devices\n");
		return -ENFILE;
	}

	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	if (!evdev)
		return -ENOMEM;

	INIT_LIST_HEAD(&evdev->client_list);
	init_waitqueue_head(&evdev->wait);

	evdev->exist = 1;
	evdev->minor = minor;
	// handle中的handler成员指向了配对成功的handler,
    // 			 dev成员指向了配对成功的device，
    //           private成员则指向了evdev设备本身。
	// 将设备驱动层程序存储在evdev handle中
	evdev->handle.dev = dev;
	evdev->handle.name = evdev->name;
	// 将事件处理层程序存储在evdev handle中
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;
	sprintf(evdev->name, "event%d", minor);

	evdev_table[minor] = evdev;

	// 在/sys/class/input设备类下创建设备/sys/class/input/event0，并创建设备节点/dev/event%d  自此应用程序就可以通过设备节点读取与设置硬件设备
    //           input类的主设备号        创建设备的次设备号
    devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
    cdev = class_device_create(&input_class, &dev->cdev, devt,dev->cdev.dev, evdev->name);
    if (IS_ERR(cdev)) {
        error = PTR_ERR(cdev);
        goto err_free_evdev;
    }

	/* temporary symlink to keep userspace happy */
	error = sysfs_create_link(&input_class.subsys.kobj,
				  &cdev->kobj, evdev->name);
	if (error)
		goto err_cdev_destroy;

	
	error = input_register_handle(&evdev->handle);
	if (error)
		goto err_remove_link;

	return 0;

 err_remove_link:
	sysfs_remove_link(&input_class.subsys.kobj, evdev->name);
 err_cdev_destroy:
	class_device_destroy(&input_class, devt);
 err_free_evdev:
	kfree(evdev);
	evdev_table[minor] = NULL;
	return error;
}

int input_register_handle(struct input_handle *handle)
{
	struct input_handler *handler = handle->handler;

	// 将handle放到匹配成功的设备驱动层中的h_list上，将handle放到匹配成功的事件处理层中的h_list上
	list_add_tail(&handle->d_node, &handle->dev->h_list);
	list_add_tail(&handle->h_node, &handler->h_list);

	if (handler->start)
		handler->start(handle);

	return 0;
}

自此，事件处理层程序和设备驱动层程序，成功建立联系。并成功创建设备节点，以供应用程序通过设备节点访问硬件设备。通过上文分析，链表input_handler_list和input_dev_list保存了handler与device，这两条链表都是全局链表，而input_hande 不是一个全局的链表。它注册的时候将自己分别挂在了input_dev_list和input_handler_list的h_list上了。

图片来源于网络

6.3.4 字符设备驱动–关于设备节点的创建和使用

1，在输入子系统初始化时注册了设备类，并注册了字符设备驱动。

static int __init input_init(void)
{
	int err;

	// 注册 intput 设备类
	err = class_register(&input_class);
	if (err) {
		printk(KERN_ERR "input: unable to register input_dev class\n");
		return err;
	}

	err = input_proc_init();
	if (err)
		goto fail1;

	// 注册 字符设备
	err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
	if (err) {
		printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
		goto fail2;
	}

	return 0;

 fail2:	input_proc_exit();
 fail1:	class_unregister(&input_class);
	return err;
}

2，在驱动程序调用input_register_device接口注册时，会创建一个input类设备"input0"；在设备驱动层程序与事件处理层程序匹配成功调用evdev_connect接口时，会创建一个input类设备"event0"，并为其创建一个设备节点，应用程序就可以通过这个设备节点去执行访问硬件设备。

设备ts0 和 设备节点/dev/ts0 为input子系统中另一事件处理层程序创建。

在应用程序中open(/dev/event0,0)时，根据该设备节点的主设备号，在字符设备驱动链表中，找到对应的驱动程序，进而通过该驱动程序file_operations结构体中的open接口来打开设备。
拿/dev/event0设备节点来说，其主设备号为13，对应于输入子系统的核心层驱动。

#define INPUT_MAJOR		13

static const struct file_operations input_fops = {
	.owner = THIS_MODULE,
	.open = input_open_file,
};

err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (err) {
    printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
    goto fail2;
}

其次设备号为64，在evdev事件处理层程序注册到输入子系统中的时候，其通过 input_register_handler 接口将handler以"handler->minor >> 5"为下标放在了input_table数组中。

int input_register_handler(struct input_handler *handler)
{
	struct input_dev *dev;

	INIT_LIST_HEAD(&handler->h_list);

	if (handler->fops != NULL) {
		if (input_table[handler->minor >> 5])
			return -EBUSY;

		input_table[handler->minor >> 5] = handler;
	}

	list_add_tail(&handler->node, &input_handler_list);

	list_for_each_entry(dev, &input_dev_list, node)
		input_attach_handler(dev, handler);

	input_wakeup_procfs_readers();
	return 0;
}

当应用程序打开设备时调用input_open_file，再次通过设备节点的次设备号64>>5为下标从input_table数组中取出对应的handler，即evdev程序。进而得到evdev程序中的file_operations结构，将这个file_operations结构赋值给file->f_op，那么之后应用程序通过设备节点文件句柄来read、write等操作时，实际上就是调用evdev程序里的file_operations结构中的接口。

static int input_open_file(struct inode *inode, struct file *file)
{
    // iminor(inode) 获取次设备号
	struct input_handler *handler = input_table[iminor(inode) >> 5];
	const struct file_operations *old_fops, *new_fops = NULL;
	int err;

	/* No load-on-demand here? */
	if (!handler || !(new_fops = fops_get(handler->fops)))
		return -ENODEV;

	/*
	 * That's _really_ odd. Usually NULL ->open means "nothing special",
	 * not "no device". Oh, well...
	 */
	if (!new_fops->open) {
		fops_put(new_fops);
		return -ENODEV;
	}
	old_fops = file->f_op;
	file->f_op = new_fops;

	err = new_fops->open(inode, file);

	if (err) {
		fops_put(file->f_op);
		file->f_op = fops_get(old_fops);
	}
	fops_put(old_fops);
	return err;
}

evdev程序里的file_operations结构。

static const struct file_operations evdev_fops = {
	.owner =	THIS_MODULE,
	.read =		evdev_read,
	.write =	evdev_write,
	.poll =		evdev_poll,
	.open =		evdev_open,
	.release =	evdev_release,
	.unlocked_ioctl = evdev_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl =	evdev_ioctl_compat,
#endif
	.fasync =	evdev_fasync,
	.flush =	evdev_flush
};

七，事件上报过程

7.1 设备驱动层程序上报事件

input_report_abs(ts.dev, ABS_X, ts.xp); ->
    input_event(dev, EV_ABS, code, value); ->
        handle->handler->event(handle, type, code, value); 即evdev_event(handle, type, code, value); ->
            // 给应用程序发可读信号，同时唤醒休眠队列，以便应用程序能够读到数据
            kill_fasync(&client->fasync, SIGIO, POLL_IN); wake_up_interruptible(&evdev->wait);

应用程序 read ->
    evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos); ->
        (evdev_event_to_user(buffer + retval, event); ->
             copy_to_user(buffer, event, sizeof(struct input_event))
         
自此 设备驱动层程序完成一次上报事件给到应用程序。