中断下半部 tasklet
当一个中断要耗费很多时间来处理时，它的坏处是：在这段时间内，其他中断无法被处理。也就是说这段时间内，系统是关中断的。
如果某个中断就是要做那么多事，我们能不能把它拆分成两部分：紧急的、不紧急的？
中断下半部的实现有很多种方法，主要有两种
- tasklet（小任务）
- work queue（工作队列）
当下半部比较耗时是能忍受的，并且它的处理比较简单时，可以用 tasklet 来处理下半部。tasklet 是使用软件中断来实现。
假设硬件中断A 的上半部函数为 irq_top_half_A ，下半部为 irq_bottom_half_A 。
使用情景分析，才能理解上述代码：
-
硬件中断A 处理过程中，没有其他中断发生：
一开始，preempt_count = 0;
上述流程图①～⑨依次执行，上半部、下半部的代码各执行一次 -
硬件中断 A 处理过程中，又再次发生了中断 A：
一开始， preempt_count = 0；
执行到第⑥时，一开中断后，中断 A 又再次使得 CPU 跳到中断向量表。
注意：
这时 preempt_count 等于1，并且中断下半部的代码并未执行。
CPU 又从①开始再次执行中断 A 的上半部代码；
在第①步 preempt_count 等于 2；
在第③步 preempt_count 等于 1；
在第④步发现 preempt_count 等于 1，所以直接结束当前第 2 次中断的处理；
注意：重点来了
第2次中断发生后，打断了第一次中断的第⑦步处理。当第2次中断处理完毕， CPU 会继续去执行第⑦步。可以看到，发生 2 次硬件中断 A 时，它的上半部代码执行了 2 次，但是下半部代码只执行了一次。
所以，同一个中断的上半部、下半部，在执行时是多对一的关系。
- 硬件中断 A 处理过程中，又再次发生了中断 B：
一开始， preempt_count = 0；
执行到第⑥时，一开中断后，中断 B 又再次使得 CPU 跳到中断向量表。
注意： 这时 preempt_count 等于 1，并且中断 A 下半部的代码并未执行。
CPU 又从①开始再次执行中断 B 的上半部代码：
在第①步 preempt_count 等于 2；
在第③步 preempt_count 等于 1；
在第④步发现 preempt_count 等于 1，所以直接结束当前第 2 次中断的处理；
注意：重点来了， 第2次中断发生后，打断了第一次中断A的第⑦步处理。当第2次中断B处理完毕， CPU 会继续去执行第⑦步。在第⑦步里，它会去执行中断 A 的下半部，也会去执行中断 B 的下半部。
所以，多个中断的下半部，是汇集在一起处理的。
总结：
- 中断的处理可以分为上半部，下半部
- 中断上半部，用来处理紧急的事，它是在关中断的状态下执行的
- 中断下半部，用来处理耗时的、不那么紧急的事，它是在开中断的状态下执行的
- 中断下半部执行时，有可能会被多次打断，有可能会再次发生同一个中断
- 中断上半部执行完后，触发中断下半部的处理
- 中断上半部、下半部的执行过程中，不能休眠：中断休眠的话，以后谁来调度进程啊？
当发生某一个硬件中断时，内核会调用对应的硬件中断处理函数，处理完之后，会去处理软件中断；从类似soft数组中取出action函数，对于lastlet这种软件中断，对应的函数是tasklet_action，这个函数会从某个队列/链表里取出每一个tasklet结构体，执行里面的函数。
处理硬件中断是上半部（中断禁止）；处理软件中断的是下半部（中断打开，有可能被打断）。
上半部可以使能/调用下半部：把一个tasklet结构体放进队列/链表。
软件中断不会叠加
下半部就是构造tasklet结构体，提供函数。
内核函数
- 定义 tasklet，中断下半部使用结构体tasklet_struct来表示，它在内核源码
include\linux\interrupt.h中定义：
struct tasklet_struct
{
struct tasklet_struct *next;
unsigned long state;
atomic_t count;
void (*func)(unsigned long);
unsigned long data;
};
-
其中的 state 有 2 位：
- bit0 表示 TASKLET_STATE_SCHED等于 1 时表示已经执行了 tasklet_schedule 把该 tasklet 放入队列了；tasklet_schedule 会判断该位，如果已经等于 1 那么它就不会再次把tasklet 放入队列。
- bit1 表示 TASKLET_STATE_RUN等于 1 时，表示正在运行 tasklet 中的 func 函数；函数执行完后内核会把该位清 0。
-
其中的 count 表示该 tasklet 是否使能：等于 0 表示使能了，非 0 表示被禁止了。对于 count 非 0 的 tasklet，里面的 func 函数不会被执行。
使用下半部执勤，要实现一个 tasklet_struct 结构体，这可以用2个宏来定义结构体：
#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
#define DECLARE_TASKLET_DISABLED(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
- 使用
DECLARE_TASKLET定义的tasklet结构体，他是使能的； - 使用
DECLARE_TASKLET_DISABLED定义tasklet结构体，它是禁止的；使用之前要先调用tasklet_enable使能它。
也可以使用函数来初始化 tasklet 结构体
extern void tasklet_init(struct tasklet_struct *t,
void (*func)(unsigned long), unsigned long data);
- 使能/禁止 tasklet
static inline void tasklet_enable(struct tasklet_struct *t);
static inline void tasklet_disable(struct tasklet_struct *t);
tasklet_enable把 count 减1；tasklet_disable把 count 增1。
- 调度
tasklet
static inline void tasklet_schedule(struct tasklet_struct *t);
把 tasklet 放入链表，并且设置它的 TASKLET_STATE_SCHED 状态为 1
- kill tasklet
extern void tasklet_kill(struct tasklet_struct *t);
- 如果一个 tasklet 未被调度， tasklet_kill 会把它的TASKLET_STATE_SCHED 状态清 0；
- 如果一个 tasklet 已被调度， tasklet_kill 会等待它执行完华，再把它的TASKLET_STATE_SCHED 状态清 0。
通常在卸载驱动程序时调用 tasklet_kill。
tasklet 使用方法
先定义 tasklet，需要使用时调用 tasklet_schedule，驱动卸载前调用tasklet_kill。tasklet_schedule 只是把 tasklet 放入内核队列，它的 func 函数会在软件中断的执行过程中被调用。
驱动程序
驱动程序在定时器的基础上修改。
- 在原来的gpio_key结构体中添加一个tasklet属性，每个按键都有一个tasklet；在probe函数中初始化tasklet；在remove函数中删除tasklet；
- 在tasklet处理函数中打印数据；
- 在中断服务程序，启动一个下半部。
#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;
struct tasklet_struct tasklet;
} ;
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);
}
static void key_tasklet_func(unsigned long data)
{
/* data ==> gpio */
struct gpio_key *gpio_key = data;
int val;
int key;
val = gpiod_get_value(gpio_key->gpiod);
printk("key_tasklet_func key %d %d\n", gpio_key->gpio, val);
}
/* 实现对应的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);
tasklet_schedule(&gpio_key->tasklet);
mod_timer(&gpio_key->key_timer, jiffies + HZ/50);
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);
tasklet_init(&gpio_keys_100ask[i].tasklet, key_tasklet_func, &gpio_keys_100ask[i]);
}
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);
tasklet_kill(&gpio_keys_100ask[i].tasklet);
}
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");
编译
测试
把编译出来的设备树文件拷贝到/boot目录下
reboot重启
安装驱动，强制安装
insmod gpio_key_drv.ko
执行测试程序
./button_test /dev/100ask_gpio_key
tasklet执行了
扫一扫
2216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
