热门标签
热门文章
- 1Kotlin学习笔记（三）—— 字符和字符串_kotlin字符位置
- 2Android编译内核并刷入_内核刷入工具
- 3AIGC内容分享(一)：一次性搞懂什么是AIGC_巨量引擎 aigc
- 42021年10月国产数据库大事记-墨天轮_数据库故障 事件 国内大厂
- 5STM32的在线升级（IAP）实现方法：BOOT+APP原理详解_stm32的在线升级(iap)实现方法:boot+app原理详解
- 6ubuntu18.04更换gcc版本_ubuntu 18.04 gcc升级
- 7centos7配置rabbitmq服务_centos7手动将rabbitmq 配置为系统服务
- 8[数据结构] 数组与链表的优缺点和区别_链表和数组的区别和优缺点
- 9STL算法库总结
- 10在Github上创建自己的项目_github创建项目
当前位置: article > 正文
Linux学习笔记（17.10）—— 按键的中断线程化处理_linux 中断线程化
作者：Cpp五条 | 2024-05-18 02:05:26
赞
踩
linux 中断线程化
本文主要参考韦东山老师视频及文档
-
Linux中断处理流程
-
中断系统中相关数据结构
每一个irq_desc数组项中都有一个函数：handle_irq，还有一个action链表。要理解它们，需要先看中断结构图：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GEIBRiW6-1647057964616)(E:/Glen/Linux/Linux%E9%A9%B1%E5%8A%A8%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/Linux%E8%AE%BE%E5%A4%87%E9%A9%B1%E5%8A%A8%E4%B9%8B%E4%B8%AD%E6%96%AD%E7%BA%BF%E7%A8%8B%E5%8C%96%E5%A4%84%E7%90%86.assets/image-20220312100124272.png)]](https://img-blog.csdnimg.cn/cea1867293164824a642cb999ee0cb1e.png)
外部设备1、外部设备n共享一个GPIO中断B，多个GPIO中断汇聚到GIC(通用中断控制器)的A号中断，GIC再去中断CPU。那么软件处理时就是反过来，先读取GIC获得中断号A，再细分出GPIO中断B，最后判断是哪一个外部芯片发生了中断。
所以，中断的处理函数来源有三：
① GIC的处理函数：
假设
irq_desc[A].handle_irq是XXX_gpio_irq_handler，这个函数需要读取芯片的GPIO控制器，细分发生的是哪一个GPIO中断(假设是B)，再去调用irq_desc[B]. handle_irq。注意：
irq_desc[A].handle_irq细分出中断后B，调用对应的irq_desc[B].handle_irq。显然中断A是CPU接收到的顶层中断，GIC中断CPU时，CPU读取GIC状态得到中断A。
② 模块的中断处理函数：
比如对于GPIO模块向GIC发出的中断B，它的处理函数是
irq_desc[B].handle_irq。BSP开发人员会设置对应的处理函数，一般是
handle_level_irq或handle_edge_irq，是用来处理电平触发的中断、边沿触发的中断。注意：导致GPIO中断B发生的原因很多，可能是外部设备1，可能是外部设备n，可能只是某一个设备，也可能是多个设备。所以
irq_desc[B].handle_irq会调用某个链表里的函数，这些函数由外部设备提供。这些函数自行判断该中断是否自己产生，若是则处理。③ 外部设备提供的处理函数：
这里说的“外部设备”可能是芯片，也可能总是简单的按键。它们的处理函数由自己驱动程序提供，这是最熟悉这个设备的“人”：它知道如何判断设备是否发生了中断，如何处理中断。
对于共享中断，比如GPIO中断B，它的中断来源可能有多个，每个中断源对应一个中断处理函数。所以
irq_desc[B]中应该有一个链表，存放着多个中断源的处理函数。一旦程序确定发生了GPIO中断B，那么就会从链表里把那些函数取出来一一执行。这个链表就是action链表。-
struct irq_desc结构体/** * struct irq_desc - interrupt descriptor * @irq_data: per irq and chip data passed down to chip functions * @preflow_handler: handler called before the flow handler (currently used by sparc) * @action: the irq action chain * @name: flow handler name for /proc/interrupts output */ struct irq_desc { struct irq_data irq_data; irq_flow_handler_t handle_irq; struct irqaction *action; /* IRQ action list */ int threads_handled_last; const char *name; ...... };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
-
struct irqaction结构体struct irqaction { irq_handler_t handler; void *dev_id; void __percpu *percpu_dev_id; struct irqaction *next; irq_handler_t thread_fn; struct task_struct *thread; unsigned int irq; unsigned int flags; unsigned long thread_flags; unsigned long thread_mask; const char *name; struct proc_dir_entry *dir; };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
当调用
request_irq、request_threaded_irq注册中断处理函数时，内核就会构造一个irqaction结构体。在里面保存name、dev_id等，最重要的是handler、thread_fn、thread。
handler是中断处理的上半部函数，用来处理紧急的事情。
thread_fn对应一个内核线程thread，当handler执行完毕，Linux内核会唤醒对应的内核线程。在内核线程里，会调用thread_fn函数。 可以提供
handler而不提供thread_fn，就退化为一般的request_irq函数。 可以不提供
handler只提供thread_fn，完全由内核线程来处理中断。 也可以既提供
handler也提供thread_fn，这就是中断上半部、下半部。在
reqeust_irq时可以传入dev_id，其作用有以下两点：① 中断处理函数执行时，可以使用
dev_id② 卸载中断时要传入
dev_id，这样才能在action链表中根据dev_id找到对应项所以在共享中断中必须提供
dev_id，非共享中断可以不提供。 -
struct irq_data结构体struct irq_data { u32 mask; unsigned int irq; unsigned long hwirq; unsigned int node; unsigned int state_use_accessors; struct irq_chip *chip; struct irq_domain *domain; #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY struct irq_data *parent_data; #endif void *handler_data; void *chip_data; struct msi_desc *msi_desc; cpumask_var_t affinity; };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
它就是个中转站，里面有
irq_chip指针irq_domain指针，都是指向别的结构体。
irq、hwirq，irq是软件中断号，hwirq是硬件中断号。上面的例子，在GPIO中断B是软件中断号，可以找到irq_desc[B]这个数组项；GPIO里的第x号中断，这就是hwirq。 谁来建立
irq、hwirq之间的联系呢？由irq_domain来建立。irq_domain会把本地的hwirq映射为全局的irq，什么意思？比如GPIO控制器里有第1号中断，UART模块里也有第1号中断，这两个“第1号中断”是不一样的，它们属于不同的“域”──irq_domain。 -
struct irq_chip结构体struct irq_chip { void (*irq_enable)(struct irq_data *data); void (*irq_disable)(struct irq_data *data); void (*irq_ack)(struct irq_data *data); void (*irq_mask)(struct irq_data *data); void (*irq_mask_ack)(struct irq_data *data); ...... };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
这个结构体跟“chip”即芯片相关，里面各成员的作用在头文件中也列得很清楚，摘录部分如下：
* @irq_startup: start up the interrupt (defaults to ->enable if NULL) * @irq_shutdown: shut down the interrupt (defaults to ->disable if NULL) * @irq_enable: enable the interrupt (defaults to chip->unmask if NULL) * @irq_disable: disable the interrupt * @irq_ack: start of a new interrupt * @irq_mask: mask an interrupt source * @irq_mask_ack: ack and mask an interrupt source * @irq_unmask: unmask an interrupt source * @irq_eoi: end of interrupt- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
在
request_irq后，并不需要手动去使能中断，原因就是系统调用对应的irq_chip里的函数已使能了中断。 我们提供的中断处理函数中，也不需要执行主芯片相关的清中断操作，也是系统帮我们调用
irq_chip中的相关函数。 但是对于外部设备相关的清中断操作，还是需要我们自己做的。
就像上面图里的“外部设备1“、“外部设备n”，外设备千变万化，内核里可没有对应的清除中断操作。
-
struct irq_domain结构体struct irq_domain { const struct irq_domain_ops *ops; irq_hw_number_t hwirq_max; unsigned int revmap_size; unsigned int linear_revmap[]; };- 1
- 2
- 3
- 4
- 5
- 6
- 7
在驱动中会使用
request_irq(irq, handler)这样的函数来注册中断，irq是什么？它是软件中断号，它可以从设备树中interrupt-parent = <&www>、interrupts = <n xxx>转换得来。 谁把
hwirq转换为irq？由www的相关数据结构，就是www对应的irq_domain结构体。irq_domain结构体中有一个irq_domain_ops结构体，里面有各种操作函数，主要是：①
xlate用来解析设备树的中断属性，提取出hwirq、type等信息。②
map把hwirq转换为irq。 -
struct irq_domain_ops结构体struct irq_domain_ops { int (*match)(struct irq_domain *d, struct device_node *node); int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw); void (*unmap)(struct irq_domain *d, unsigned int virq); int (*xlate)(struct irq_domain *d, struct device_node *node, const u32 *intspec, unsigned int intsize, unsigned long *out_hwirq, unsigned int *out_type); ...... };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
-
-
中断的线程化处理
中断线程化主要是考虑到实时性的要求。如果实时任务不能抢占ISR，那么其执行的延迟(
latency)时间将不确定，这不符合实时性的要求。如果内核在编译的时候配置了CONFIG_PREEMPT选项，那么将支持线程抢占，借此就可以实现中断线程化，线程化的中断处理部分被称为threaded interrupt handler。
__do_softirq()执行次数/时间超过限制后触发ksoftirqd只是中断线程化的一种情况，更通用的是使用request_threaded_irq()，只要没有在flag参数中指定"IRQF_NO_THREAD"，那么就将按中断线程化的方式处理。 当使用ps命令查看的时候，格式为"irq/%d-%s"就是这些
threaded interrupt handler，其中"d"为irq号，"s"为名称：/drv_module # ps -ef | grep "\[irq" 46 0 0:00 [irq/40-edt-ft54] 47 0 0:00 [irq/225-mmc0] 48 0 0:00 [irq/50-2190000.] 49 0 0:00 [irq/226-mmc1] 59 0 0:00 [irq/205-imx_the] 83 0 0:00 grep \[irq- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
这些线程是在
__setup_irq()中创建的：__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new) { ... /* * Create a handler thread when a thread function is supplied * and the interrupt does not nest into another interrupt * thread. */ if (new->thread_fn && !nested) { struct task_struct *t; static const struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO/2, }; t = kthread_create(irq_thread, new, "irq/%d-%s", irq, new->name); ... sched_setscheduler_nocheck(t, SCHED_FIFO, ¶m); /* * We keep the reference to the task struct even if * the thread dies to avoid that the interrupt code * references an already freed task_struct. */ get_task_struct(t); new->thread = t; /* * Tell the thread to set its affinity. This is * important for shared interrupt handlers as we do * not invoke setup_affinity() for the secondary * handlers as everything is already set up. Even for * interrupts marked with IRQF_NO_BALANCE this is * correct as we want the thread to move to the cpu(s) * on which the requesting code placed the interrupt. */ set_bit(IRQTF_AFFINITY, &new->thread_flags); } ... }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
线程的入口函数存放在
new->thread_fn中，而这个thread_fn就是request_threaded_irq()相较于传统的request_irq()新增的那个参数。 实际上，
threaded irq，为每一个中断创建一个内核线程；多个中断的内核线程可以分配到多个CPU上执行，这提高了效率。 -
以按键进行编程实践
5.1 按键设备驱动文件
在button_drv.c文件中，-
加载模块时，
btn_hw_drv_probe函数中调用request_threaded_irq将按键工作中断上半部处理函数gpio_btn_isr、button_threaded_isr_fun赋给struct irq_desc数组的action指针； -
gpio_btn_isr按键中断服务程序(中断上半部)处理完毕，返回IRQ_WAKE_THREAD，用以后续调用button_threaded_isr_fun处理比较耗时的事情； -
button_threaded_isr_fun为内核线程所调用，进一步执行。
-
/** * 文件 : button_drv.c * 作者 : glen * 描述 : button driver文件 */ #include <linux/types.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/ide.h> #include <linux/init.h> #include <linux/poll.h> #include <linux/module.h> #include <linux/errno.h> #include <linux/gpio.h> #include <linux/cdev.h> #include <linux/of.h> #include <linux/of_gpio.h> #include <linux/platform_device.h> #include <linux/gpio/consumer.h> #include <asm/mach/map.h> #include <asm/uaccess.h> #include <asm/io.h> #include <linux/fs.h> #include <linux/time.h> #include <linux/timer.h> #include <linux/proc_fs.h> #include <linux/stat.h> #include <linux/device.h> #include <linux/module.h> #include <linux/poll.h> #include <linux/fs.h> #include <linux/errno.h> #include <linux/miscdevice.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/device.h> #include <linux/tty.h> #include <linux/kmod.h> #include <linux/gfp.h> #include <linux/of_irq.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/slab.h> #include <linux/fcntl.h> #include <linux/workqueue.h> #define KEY_BUF_LEN 16 #define NEXT_POS(x) ((x+1) % KEY_BUF_LEN) struct gbtn_irq { int gpio; struct gpio_desc *gpiod; int flag; int irq; int idx; char kval[KEY_BUF_LEN]; int r, w; struct fasync_struct *fp; struct timer_list key_timer; struct tasklet_struct tasklet; struct work_struct wq; }; struct button_drv { struct class *class; struct gbtn_irq *gbtn_irq; char *name; int count; int major; }; static struct button_drv *btn_drv; static int is_key_buf_empty(void *arg) { struct gbtn_irq *p = (struct gbtn_irq *)arg; return (p->r == p->w); } static int is_key_buf_full(void *arg) { struct gbtn_irq *p = (struct gbtn_irq *)arg; return (p->r == NEXT_POS(p->w)); } static void put_key(char key, void *arg) { struct gbtn_irq *p = (struct gbtn_irq *)arg; if (!is_key_buf_full(arg)) { p->kval[p->w] = key; p->w = NEXT_POS(p->w); } } static char get_key(void *arg) { char key = 'N'; struct gbtn_irq *p = (struct gbtn_irq *)arg; if (!is_key_buf_full(arg)) { key = p->kval[p->r]; p->r = NEXT_POS(p->r); } return key; } /* 等待队列头的静态初始化 */ static DECLARE_WAIT_QUEUE_HEAD(gpio_button_wait); static void key_timer_expire(unsigned long data) { int val; char key; struct gbtn_irq *ops = (struct gbtn_irq *)data; /* 读取按键的值 */ val = gpiod_get_value(ops->gpiod); printk("button%d %d %d\n", ops->idx, ops->gpio, val); key = (ops->gpio << 4) | val; put_key(key, ops); /* 唤醒等待队列 */ wake_up_interruptible(&gpio_button_wait); kill_fasync(&ops->fp, SIGIO, POLL_IN); /* enable btn*/ enable_irq(ops->irq); } /* 实现file_operations结构体成员 read 函数 */ ssize_t button_drv_read (struct file *filp, char __user *buf, size_t size, loff_t *pos) { int minor = iminor(filp->f_inode); struct gbtn_irq *ops = (struct gbtn_irq *)filp->private_data; char kval; size = (size >= 1) ? 1 : 0; if (ops == NULL) { printk("Please register button instance %s %s, %d\n", __FILE__, __FUNCTION__, __LINE__); return -EIO; } if (is_key_buf_empty(ops) && (filp->f_flags & O_NONBLOCK)) return -EAGAIN; wait_event_interruptible(gpio_button_wait, !is_key_buf_empty(ops)); kval = get_key(ops); if (copy_to_user(buf, &kval, size)) return -EFAULT; printk("Read button%d value successfully:", minor); return size; } /* 实现file_operations结构体成员 open 函数 */ int button_drv_open(struct inode *nd, struct file *filp) { int ret; int minor = iminor(nd); struct gbtn_irq *ops; if (btn_drv == NULL) { printk("Please register button instance %s %s, %d\n", __FILE__, __FUNCTION__, __LINE__); return -EIO; } ops = &btn_drv->gbtn_irq[minor]; ret = gpiod_direction_input(ops->gpiod); if (ret) printk("Set the button pin as input error %s %s, %d\n", __FILE__, __FUNCTION__, __LINE__); else printk("Set the button%d pin as input successfully!\n", minor); filp->private_data = ops; return 0; } /* 实现file_operations结构体成员 release 函数 */ int button_drv_release (struct inode *nd, struct file *filp) { struct gbtn_irq *ops = (struct gbtn_irq *)filp->private_data; if (ops == NULL) { printk("Please register button instance %s %s, %d\n", __FILE__, __FUNCTION__, __LINE__); return -EIO; } filp->private_data = NULL; return 0; } /* 实现file_operations结构体成员 poll 函数 */ unsigned int button_drv_poll (struct file *filp, struct poll_table_struct * wait) { int minor = iminor(filp->f_inode); printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); poll_wait(filp, &gpio_button_wait, wait); return (is_key_buf_empty(&btn_drv->gbtn_irq[minor]) ? 0 : POLLIN | POLLRDNORM); } static int button_drv_fasync(int fd, struct file *filp, int on) { struct gbtn_irq *ops = (struct gbtn_irq *)filp->private_data; if (fasync_helper(fd, filp, on, &ops->fp) >= 0) return 0; else return -EIO; } /** * 1. 构造file_operations结构体 */ static struct file_operations button_drv_ops = { .owner = THIS_MODULE, .read = button_drv_read, .open = button_drv_open, .release = button_drv_release, .poll = button_drv_poll, .fasync = button_drv_fasync, }; /* 中断服务函数 */ static irqreturn_t gpio_btn_isr (int irq, void *dev_id) { struct gbtn_irq *ops = dev_id; // printk("gpio_btn_isr key %d irq happened\n", ops->gpio); tasklet_schedule(&ops->tasklet); mod_timer(&ops->key_timer, jiffies + HZ / 50); schedule_work(&ops->wq); disable_irq_nosync(irq); return IRQ_WAKE_THREAD; } /* tasklet action function */ static void button_tasklet_func (unsigned long data) { int val; struct gbtn_irq *ops = (struct gbtn_irq *)data; /* 读取按键的值 */ val = gpiod_get_value(ops->gpiod); printk("button_tasklet_func key%d %d %d\n", ops->idx, ops->gpio, val); } static void button_work_func (struct work_struct *work) { int val; struct gbtn_irq *ops = container_of(work, struct gbtn_irq, wq); /* 读取按键的值 */ val = gpiod_get_value(ops->gpiod); printk("button_work_func: the process is %s pid %d\n", current->comm, current->pid); printk("button_work_func key%d %d %d\n", ops->idx, ops->gpio, val); } static irqreturn_t button_threaded_isr_fun (int irq, void *dev) { int val; struct gbtn_irq *ops = dev; /* 读取按键的值 */ val = gpiod_get_value(ops->gpiod); printk("button_threaded_isr_fun: the process is %s pid %d\n", current->comm, current->pid); printk("button_threaded_isr_fun key%d %d %d\n", ops->idx, ops->gpio, val); return IRQ_HANDLED; } /* platform_driver结构体的 probe成员函数实现 */ int btn_hw_drv_probe (struct platform_device *pdev) { int i; int ret; int count; // enum of_gpio_flags flag; struct device_node *node = pdev->dev.of_node; /* 从设备节点获取gpio数量 */ count = of_gpio_count(node); if (!count) { printk("%s %s line %d, there isn't any gpio available!\n", __FILE__, __FUNCTION__, __LINE__); return -EIO; } btn_drv = kzalloc(sizeof(struct button_drv), GFP_KERNEL); if (btn_drv == NULL) return -ENOMEM; btn_drv->gbtn_irq = kzalloc(sizeof(struct gbtn_irq) * count, GFP_KERNEL); if (btn_drv->gbtn_irq == NULL) return -ENOMEM; for (i = 0; i < count; i++) { btn_drv->gbtn_irq[i].gpiod = gpiod_get_index_optional(&pdev->dev, NULL, i, GPIOD_ASIS); if (btn_drv->gbtn_irq[i].gpiod == NULL) { printk("%s %s line %d, gpiod_get_index_optional failed!\n", __FILE__, __FUNCTION__, __LINE__); return -EIO; } btn_drv->gbtn_irq[i].irq = gpiod_to_irq(btn_drv->gbtn_irq[i].gpiod); btn_drv->gbtn_irq[i].gpio = desc_to_gpio(btn_drv->gbtn_irq[i].gpiod); setup_timer(&btn_drv->gbtn_irq[i].key_timer, key_timer_expire, &btn_drv->gbtn_irq[i]); btn_drv->gbtn_irq[i].key_timer.expires = ~0; add_timer(&btn_drv->gbtn_irq[i].key_timer); tasklet_init(&btn_drv->gbtn_irq[i].tasklet, button_tasklet_func, &btn_drv->gbtn_irq[i]); INIT_WORK(&btn_drv->gbtn_irq[i].wq, button_work_func); btn_drv->gbtn_irq[i].idx = i; } for (i = 0; i < count; i++) /* 申请irq中断, 将中断服务程序注册到上半部 */ // ret = request_irq(btn_drv->gbtn_irq[i].irq, gpio_btn_isr, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, // "gpio_btn", &btn_drv->gbtn_irq[i]); request_threaded_irq(btn_drv->gbtn_irq[i].irq, gpio_btn_isr, button_threaded_isr_fun, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "gpio_btn", &btn_drv->gbtn_irq[i]); /* 注册file_operationss结构体对象 -- button_drv_ops */ btn_drv->major = register_chrdev(btn_drv->major, "gbtn", &button_drv_ops); btn_drv->class = class_create(THIS_MODULE, "gbtn"); if (IS_ERR(btn_drv->class)) { printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); unregister_chrdev(btn_drv->major, "gbtn"); return PTR_ERR(btn_drv->class); } for (i = 0; i < count; i++) device_create(btn_drv->class, NULL, MKDEV(btn_drv->major, i), NULL, "gbtn%d", i); btn_drv->count = count; return 0; } /* platform_driver结构体的 remove成员函数实现 */ int btn_hw_drv_remove(struct platform_device *pdev) { int i; struct device_node *node = pdev->dev.of_node; int count = of_gpio_count(node); for (i = 0; i < count; i++) { device_destroy(btn_drv->class, MKDEV(btn_drv->major, i)); free_irq(btn_drv->gbtn_irq[i].irq, &btn_drv->gbtn_irq[i]); del_timer(&btn_drv->gbtn_irq[i].key_timer); tasklet_kill(&btn_drv->gbtn_irq[i].tasklet); } class_destroy(btn_drv->class); unregister_chrdev(btn_drv->major, "gbtn"); kfree(btn_drv); return 0; } /* 构造用于配置的设备属性 */ static const struct of_device_id gbtns_id[] = { {.compatible = "glen,gbtn"}, { }, }; /* 构造(初始化)file_operations结构体 */ static struct platform_driver btn_hw_drv = { .driver = { .name = "gbtn", .of_match_table = gbtns_id, }, .probe = btn_hw_drv_probe, .remove = btn_hw_drv_remove, }; /* 初始化 */ static int __init button_drv_init(void) { int ret; ret = platform_driver_register(&btn_hw_drv); if (ret) pr_err("Unable to initialize button driver\n"); else pr_info("The button driver is registered.\n"); return 0; } module_init(button_drv_init); static void __exit button_drv_exit(void) { platform_driver_unregister(&btn_hw_drv); printk(" %s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); } module_exit(button_drv_exit); /* insert author information for module */ MODULE_AUTHOR("glen"); /* insert license for module */ MODULE_LICENSE("GPL");
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
- 413
- 414
- 415
- 416
- 417
- 418
- 419
- 420
- 421
probe函数采用了先获取按键节点数量，然后分别读取gpio描述符并通过其获取为gpio和irq号，并申请注册中断服务程序。
3.2 设备树文件（不作更改）
pinctrl_btn0:btn0 { fsl,pins = < MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080 /* KEY0 */ >; }; pinctrl_btn1:btn1 { fsl,pins = < MX6UL_PAD_GPIO1_IO03__GPIO1_IO03 0xF080 /* KEY1 此按键不存在 */ >; }; /* 在根节点下添加基于pinctrl的gbtns设备节点 */ gbtns { compatible = "glen,gbtn"; #address-cells = <1>; pinctrl-names = "default"; pinctrl-0 = <&pinctrl_btn0 &pinctrl_btn1>; gpio-controller; #gpio-cells = <2>; gpios = <&gpio1 18 GPIO_ACTIVE_LOW /* button0 */ &gpio1 3 GPIO_ACTIVE_LOW>; /* button1 */ };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
-
取消了gpios前缀“xxx-"，相应地，在驱动程序用gpiod_get_index_optional函数获取gpio描述符时，第2个形参 ”const char *con_id“ 传递NULL即可；
-
将pinctrl-0、gpios属性值由 “<>,<>;” 改为 “<>;"，效果是一样的
3.3 应用程序
应用程序文件button_drv_test.c提供：
- 定义sig_fun信号处理函数并注册信号，以后APP收到SIGIO信号时，这个函数会被自动调用；
- fcntl(fd, F_SETOWN, getpid()); 把APP的PID(进程ID)告诉驱动程序，这个调用不涉及驱动程序，在内核的文件系统层次记录PID；
- oflags = fcntl(fd, F_GETFL); 读取驱动程序文件oflags
- fcntl(fd, F_SETFL, oflags | FASYNC); 设置oflags里面的FASYNC位为1：当FASYNC位发生变化时，会导致驱动程序的fasync被调用
/* * 文件名 : button_drv_test.c * 作者 : glen * 描述 : button_drv应用程序 */ #include "stdio.h" #include "sys/types.h" #include "sys/stat.h" #include "stdlib.h" #include "string.h" #include "poll.h" #include <signal.h> #include <unistd.h> #include <fcntl.h> int fd; static void sig_fun(int sig) { char kval; read(fd, &kval, 1); printf("The glen button value is: %d!\n", kval); } /** * @brief : main函数 * @par : argc argv数组元素的个数 * argv 参数数组 * @retval : 0 成功 其它 失败 */ int main(int argc, char *argv[]) { int ret; int oflags; char *filename; if (argc != 2) { printf("Error Usage!\r\n"); return -1; } signal(SIGIO, sig_fun); filename = argv[1]; /* 打开驱动文件 */ fd = open(filename, O_RDWR); if (fd < 0) { printf("Can't open file %s\r\n", filename); return -1; } fcntl(fd, F_SETOWN, getpid()); oflags = fcntl(fd, F_GETFL); fcntl(fd, F_SETFL, oflags | FASYNC); while (1) { sleep(2); printf("Read the glen button in sleepping!\n"); } /* 关闭文件 */ ret = close(fd); if (ret < 0) { printf("file %s close failed!\r\n", argv[1]); return -1; } return 0; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
3.4 在alientek_linux_alpha开发板实测验证如下
/drv_module # insmod button_drv.ko The button driver is registered. /drv_module # ./btn_drv_test /dev/gbtn0 /drv_module # button_tasklet_func key0 18 1 button_threaded_isr_fun: the process is irq/49-gpio_btn pid 83 button_threaded_isr_fun key0 18 1 button_work_func: the process is kworker/0:2 pid 45 button_work_func key0 18 1 button0 18 1 button_tasklet_func key0 18 0 button_threaded_isr_fun: the process is irq/49-gpio_btn pid 83 button_threaded_isr_fun key0 18 0 button_work_func: the process is kworker/0:2 pid 45 button_work_func key0 18 0 button0 18 0 button_tasklet_func key0 18 1 button_threaded_isr_fun: the process is irq/49-gpio_btn pid 83 button_threaded_isr_fun key0 18 1 button_work_func: the process is kworker/0:2 pid 45 button_work_func key0 18 1 button0 18 1 button_tasklet_func key0 18 0 button_threaded_isr_fun: the process is irq/49-gpio_btn pid 83 button_threaded_isr_fun key0 18 0 button_work_func: the process is kworker/0:2 pid 45 button_work_func key0 18 0 button0 18 0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/586183
推荐阅读
相关标签
