字符设备驱动-9.内核定时器

1 引入定时器

前面的gpio按键驱动 引入了中断，当按键按下会记录按键信息，理想状况是按下一次按键记录一组数据，但实际上按下机械振动导致电平反复跳动最后才稳定，按下一次gpio irq会触发多次，这个被叫做“抖动”，那么可以利用定时器进行“去抖”。

到linux_5.10版本struct timer_list变成了

unsigned long exoires; //设定的超时的值
void(*function)(unsigned long); //超时处理函数
unsigned long data; //超时处理函数参数

1.1 内核函数

在内核中使用定时器很简单，涉及这些函数(参考内核源码include\linux\timer.h)

1. setup_timer(timer, fn, data)
   

到linux_5.10版本变成了timer_setup

设置定时器，主要是初始化 timer_list 结构体，设置其中的函数、参数。

2. void add_timer(struct timer_list *timer)
   
   向内核添加定时器。 timer->expires 表示超时时间。
   当超时时间到达 ， 就会调用这个函数 ：timer->function(timer->data)。

3. int mod_timer(struct timer_list *timer, unsigned long expires)
   

   修改定时器的超时时间，
   它等同于： del_timer(timer);
   timer->expires = expires;
   add_timer(timer);但是更加高效。

4. int del_timer(struct timer_list *timer)
   删除定时器。

1.2 定时器时间单位

可以在内核源码根目录下用“ ls -a”看到一个隐藏文件.config, 可以看到如下这项：会被内核转换成include/generated/autoconf.h，HZ定义头文件uapi/asm-generic/param.h和include/asm-generic/param.h

CONFIG_HZ=100

这表示内核每秒中会发生 100 次系统滴答中断(tick)，这就像人类的心跳一样，这是 Linux 系统的心跳。每发生一次 tick 中断，全局变量 jiffies 就会累加 1。
CONFIG_HZ=100 表示每个滴答是 10ms。
定时器的时间就是基于 jiffies 的，我们修改超时时间时，一般使用这 2 种方法：

1. add_timer 之前，直接修改：
   imer.expires = jiffies + xxx; // xxx 表示多少个滴答后超时，也就是 xxx*10ms
imer.expires = jiffies + 2*HZ; // HZ 等于 CONFIG_HZ， 2*HZ HZ是100个10ms, 就相当于 2 秒
2. add_timer 之后，使用 mod_timer 修改：
   mod_timer(&timer, jiffies + xxx); // xxx 表示多少个滴答后超时，也就是 xxx*10ms
mod_timer(&timer, jiffies + 2*HZ); // HZ 等于 CONFIG_HZ， 2*HZ 就相当于 2 秒

1.2.1 jiffies与秒的转换

将 jiffies转换为秒，可采用公式：(jiffies/HZ) 计算。
将秒转换为jiffies，可采用公式：(seconds*HZ) 计算。

1.2.2 内核时间获取

ktime_t curTime = 0;
curTime = ktime_get();//不包含了设备进入休眠的时间
TIME_TEST_INFO("ktime_get:%lld ns", curTime);
//结果：timeTest:ktime_drv_init,63:ktime_get:492257307974640 ns


ktime_t curTime = 0;
curTime = ktime_get_boottime();包含了设备进入休眠的时间
TIME_TEST_INFO("ktime_get_boottime:%lld ns", curTime);
//结果： [492257.266168] timeTest:ktime_drv_init,73:ktime_get_boottime:581660801601637 ns

void ktime_get_ts64(struct timespec64 *ts); //这也是一种

ktime_t start, end, elapsed;
start = ktime_get_boottime();
...
end = ktime_get_boottime();
elapsed = ktime_sub(end, start);
elapsed_msecs = ktime_to_ms(elapsed);

printk("%d.%03d seconds", elapsed_msecs / 1000,elapsed_msecs % 1000);

1.2.2.1 秒-毫秒-微秒-纳秒和jiffies兑换

int jiffies_to_msecs(const unsigned long j);
int jiffies_to_usecs(const unsigned long j);
u64 jiffies_to_nsecs(const unsigned long j);
long msecs_to_jiffies(const unsigned int m);
long usecs_to_jiffies(const unsigned int u);//jiffies.h
unsigned long nsecs_to_jiffies(u64 n);

static inline s64 ktime_to_us(const ktime_t kt);//ktime.h
static inline s64 ktime_to_ms(const ktime_t kt);
static inline s64 ktime_to_ns(const ktime_t kt);

1.2.2.2 usleep_range

void __sched usleep_range(unsigned long min, unsigned long max)；

1.2.3 CLOCK_MONOTONIC与CLOCK_REALTIME

CLOCK_MONOTONIC(即monotonic time)
CLOCK_MONOTONIC：以绝对时间为准，获取的时间为系统重启到现在的时间，更改系统时间对它没有影响。
字面意义：单调时间，表示系统启动后流逝的时间，由变量jiffies来记录的。
系统每次启动时，jiffies初始化为0。每来一个timer interrupt，jiffies加1，即它代表系统启动后流逝的tick数。
jiffies一定是单调递增的，因为时间不可逆。

CLOCK_REALTIME(即wall time)
CLOCK_REALTIME：相对时间，从1970.1.1到目前的时间。更改系统时间会更改获取的值。它以系统时间为坐标。
字面意思: wall time挂钟时间，表示现实的时间，由变量xtime来记录的。
一些题外话：
一些应用软件可能就是用到了这个wall time。比如以前用vmware workstation，一启动提示试用期已过，但是只要把系统时间调整一下提前一年，再启动就不会有提示了。这很可能就是因为它启动时，用gettimeofday去读wall time，然后判断是否过期，只要将wall time改一下，就可以欺骗过去了.

2内核定时器实例

就前面讲到的gpio按键中断来举例，每次发生gpio 中断，irq中我们都去调用一次mod_timer函数判断是不是抖动带来的垃圾数据。如果是抖动，那么irq会一直触发，一直调用mod_timer，一直推迟定时器中断函数的触发。
当按下按键键值稳定下来后机械振动没了，电平数据趋于稳定了，那么gpio irq就不会一直响应了，也就是mod_timer函数不会一直调用了，那么等到timer超时，上报数据，整个流程如下图所示：

按键为下降沿触发，因此会在 t1、t2 和 t3 这三个时刻会触发按键中断，每次进入中断处理函数都会重新开器定时器中断，但是 t1~t2 和 t2~t3 这两个时间段是小于我们设置的定时器中断周期(也就是消抖时间，比如 10ms)，所以虽然 t1 开启了定时器，但是定时器定时时间还没到呢 t2 时刻就重置了定时器，最终只有 t3 时刻开启的定时器能完整的完成整个定时周期并触发中断，我们就可以在中断处理函数里面做按键处理了，这就是定时器实现按键防抖的原理。

驱动代码

#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>

struct gpio_key{
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
	struct timer_list key_timer;
} ;

static struct gpio_key *gpio_keys_100ask;

/* 主设备号                                                                 */
static int major = 0;
static struct class *gpio_key_class;

/* 环形缓冲区 */
#define BUF_LEN 128
static int g_keys[BUF_LEN];
static int r, w;

struct fasync_struct *button_fasync;

#define NEXT_POS(x) ((x+1) % BUF_LEN)

static int is_key_buf_empty(void)
{
	return (r == w);
}

static int is_key_buf_full(void)
{
	return (r == NEXT_POS(w));
}

static void put_key(int key)
{
	if (!is_key_buf_full())
	{
		g_keys[w] = key;
		w = NEXT_POS(w);
	}
}

static int get_key(void)
{
	int key = 0;
	if (!is_key_buf_empty())
	{
		key = g_keys[r];
		r = NEXT_POS(r);
	}
	return key;
}


static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);

static void key_timer_expire(unsigned long data)
{
	/* data ==> gpio */
	struct gpio_key *gpio_key = data;
	int val;
	int key;

	val = gpiod_get_value(gpio_key->gpiod);


	printk("key_timer_expire key %d %d\n", gpio_key->gpio, val);
	key = (gpio_key->gpio << 8) | val;
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);
	kill_fasync(&button_fasync, SIGIO, POLL_IN);
}


/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	int err;
	int key;

	if (is_key_buf_empty() && (file->f_flags & O_NONBLOCK))
		return -EAGAIN;
	
	wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
	key = get_key();
	err = copy_to_user(buf, &key, 4);
	
	return 4;
}

static unsigned int gpio_key_drv_poll(struct file *fp, poll_table * wait)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	poll_wait(fp, &gpio_key_wait, wait);
	return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
}

static int gpio_key_drv_fasync(int fd, struct file *file, int on)
{
	if (fasync_helper(fd, file, on, &button_fasync) >= 0)
		return 0;
	else
		return -EIO;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations gpio_key_drv = {
	.owner	 = THIS_MODULE,
	.read    = gpio_key_drv_read,
	.poll    = gpio_key_drv_poll,
	.fasync  = gpio_key_drv_fasync,
};


static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
	struct gpio_key *gpio_key = dev_id;
	printk("gpio_key_isr key %d irq happened\n", gpio_key->gpio);
	mod_timer(&gpio_key->key_timer, jiffies + HZ/5);
	return IRQ_HANDLED;
}

/* 1. 从platform_device获得GPIO
 * 2. gpio=>irq
 * 3. request_irq
 */
static int gpio_key_probe(struct platform_device *pdev)
{
	int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;
	enum of_gpio_flags flag;
		
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	count = of_gpio_count(node);
	if (!count)
	{
		printk("%s %s line %d, there isn't any gpio available\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}

	gpio_keys_100ask = kzalloc(sizeof(struct gpio_key) * count, GFP_KERNEL);
	for (i = 0; i < count; i++)
	{		
		gpio_keys_100ask[i].gpio = of_get_gpio_flags(node, i, &flag);
		if (gpio_keys_100ask[i].gpio < 0)
		{
			printk("%s %s line %d, of_get_gpio_flags fail\n", __FILE__, __FUNCTION__, __LINE__);
			return -1;
		}
		gpio_keys_100ask[i].gpiod = gpio_to_desc(gpio_keys_100ask[i].gpio);
		gpio_keys_100ask[i].flag = flag & OF_GPIO_ACTIVE_LOW;
		gpio_keys_100ask[i].irq  = gpio_to_irq(gpio_keys_100ask[i].gpio);

		setup_timer(&gpio_keys_100ask[i].key_timer, key_timer_expire, &gpio_keys_100ask[i]);
		gpio_keys_100ask[i].key_timer.expires = ~0;
		add_timer(&gpio_keys_100ask[i].key_timer);
	}

	for (i = 0; i < count; i++)
	{
		err = request_irq(gpio_keys_100ask[i].irq, gpio_key_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpio_keys_100ask[i]);
	}

	/* 注册file_operations 	*/
	major = register_chrdev(0, "100ask_gpio_key", &gpio_key_drv);  /* /dev/gpio_key */

	gpio_key_class = class_create(THIS_MODULE, "100ask_gpio_key_class");
	if (IS_ERR(gpio_key_class)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		unregister_chrdev(major, "100ask_gpio_key");
		return PTR_ERR(gpio_key_class);
	}

	device_create(gpio_key_class, NULL, MKDEV(major, 0), NULL, "100ask_gpio_key"); /* /dev/100ask_gpio_key */
        
    return 0;
    
}

static int gpio_key_remove(struct platform_device *pdev)
{
	//int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;

	device_destroy(gpio_key_class, MKDEV(major, 0));
	class_destroy(gpio_key_class);
	unregister_chrdev(major, "100ask_gpio_key");

	count = of_gpio_count(node);
	for (i = 0; i < count; i++)
	{
		free_irq(gpio_keys_100ask[i].irq, &gpio_keys_100ask[i]);
		del_timer(&gpio_keys_100ask[i].key_timer);
	}
	kfree(gpio_keys_100ask);
    return 0;
}


static const struct of_device_id ask100_keys[] = {
    { .compatible = "100ask,gpio_key" },
    { },
};

/* 1. 定义platform_driver */
static struct platform_driver gpio_keys_driver = {
    .probe      = gpio_key_probe,
    .remove     = gpio_key_remove,
    .driver     = {
        .name   = "100ask_gpio_key",
        .of_match_table = ask100_keys,
    },
};

/* 2. 在入口函数注册platform_driver */
static int __init gpio_key_init(void)
{
    int err;
    
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
    err = platform_driver_register(&gpio_keys_driver); 
	
	return err;
}

/* 3. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
 *     卸载platform_driver
 */
static void __exit gpio_key_exit(void)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

    platform_driver_unregister(&gpio_keys_driver);
}


/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */

module_init(gpio_key_init);
module_exit(gpio_key_exit);

MODULE_LICENSE("GPL");

分析：

linux_5.10内核版本用法

probe函数进行初始化定时器，这里add_timer前修改expires，为了防止定时器中断提前触发（按键还没按下就触发了定时器中断），因此修改expires为一个最大值。

当按下按键gpio_irq按键中断服务程序响应后，调用mod_timer进行修改定时器超时时间，用来去除“抖动”。jiffies + HZ/5表示延时20个tick时钟滴答，也就是20*10ms，如果这个时间内有多次电平跳动，那么不会去上报数据，而是继续修改定时器超时时间，直到按键数据稳定后，也就是200ms已经到了但是没有人去修改定时器超时时间，那么将会触发定时器中断，上报按键数据。

linux_5.10内核版本用法

2.1 硬件中断和软件中断

1. 硬件中断包含gpio，网卡，外围电路IP等等，tick（产生一次tick系统滴答中断，jiffies加1）
2. 软件中断包含TIMER 表示定时中断、RCU 表示 RCU 锁中断、SCHED 表示内核调度中断

区别：
上半部直接处理硬件请求，也就是硬中断，主要是负责耗时短的工作，特点是快速执行；
下半部是由内核触发，也就说软中断，主要是负责上半部未完成的工作，通常都是耗时比较长的事情，特点是延迟执行
硬中断（上半部）是会打断 CPU 正在执行的任务，然后立即执行中断处理程序，而软中断（下半部）是以内核线程的方式执行

cat /proc/softirqs可以看软件中断信息

cat /proc/interrupts可以看硬件中断

2.2 深入理解定时器中断

定时器就是通过软件中断来实现的，它属于 TIMER_SOFTIRQ 软中断
对于 TIMER_SOFTIRQ 软中断，初始化代码如下：

void __init init_timers(void)
{
	init_timer_cpus();
	init_timer_stats();
	open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
}

当发生硬件中断时，硬件中断处理完后，内核会调用软件中断的处理函数。
对于 TIMER_SOFTIRQ，会调用 run_timer_softirq，它的函数如下：

run_timer_softirq
__run_timers(base);
while (time_after_eq(jiffies, base->clk)) {
……
expire_timers(base, heads + levels);
fn = timer->function;
data = timer->data;
call_timer_fn(timer, fn, data);
fn(data);

简单地说， add_timer 函数会把 timer 放入内核里某个链表；在 TIMER_SOFTIRQ 的处理函数中，会从链表中把这些超时的 timer 取出来，
执行其中的函数。怎么判断是否超时？ jiffies 大于或等于 timer->expires 时， timer 就超时，执行超时处理函数。

找到时钟滴答：
在开发板执行以下命令，可以看到 CPU0 下有一个数值变化特别快，它就是滴答中断tick

以 100ASK_IMX6ULL 为做，滴答中断名字就是“ i.MX Timer Tick”。在 Linux内核源码目录下执行以下命令：

grep "i.MX Timer Tick" * -nr
drivers/clocksource/timer-imx-gpt.c:319: act->name = "i.MX Timer Tick";

⚫ 打开 timer-imx-gpt.c 319 行左右，可得如下源码：

act->name = "i.MX Timer Tick";
act->flags = IRQF_TIMER | IRQF_IRQPOLL;
act->handler = mxc_timer_interrupt;
act->dev_id = ced;
return setup_irq(imxtm->irq, act);

⚫ mxc_timer_interrupt 应该就是滴答中断的处理函数，代码如下：

static irqreturn_t mxc_timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *ced = dev_id;
	struct imx_timer *imxtm = to_imx_timer(ced);
	uint32_t tstat;
	tstat = readl_relaxed(imxtm->base + imxtm->gpt->reg_tstat);472 / 573
	imxtm->gpt->gpt_irq_acknowledge(imxtm);
	ced->event_handler(ced);
	return IRQ_HANDLED;
}

在看ced->event_handler(ced)：ced->event_handler(ced)是哪一个函数？不太好找，使用 QEMU 来调试内核，在 mxc_timer_interrupt 中打断点跟踪代码发现它对应 tick_handle_periodic。
tick_handle_periodic 位于 kernel\time\tick-common.c 中，它里面的调用关系如下：

tick_handle_periodic
tick_periodic(cpu);
do_timer(1);
jiffies_64 += ticks; // jiffies 就是 jiffies_64

为何说 jiffies 就是 jiffies_64？在 arch\arm\kernel\vmlinux.lds.S 有如下代码：

#ifndef __ARMEB__
jiffies = jiffies_64;
#else
jiffies = jiffies_64 + 4;
#endif

上述代码说明了，对于大字节序的 CPU， jiffies 指向 jiffies_64 的高 4字节；对于小字节序的 CPU， jiffies 指向 jiffies_64 的低 4 字节。对 jiffies_64 的累加操作，就是对 jiffies 的累加操作。

extern u64 __cacheline_aligned_in_smp jiffies_64; //include/linux/jiffies.h
extern unsigned long volatile __cacheline_aligned_in_smp __jiffy_arch_data jiffies;