裸机开发要点
- 通用中断控制器(GIC)
- 中断类型、硬件中断号、分发器和cpu接口单元
- 中断向量表
- 一级查表、二级查表
- 中断处理流程
- 进入irq模式、保护现场、获取硬件中断编号、执行中断处理函数、还原现场
设备树构造
分为 gic中断控制器设备树节点 其他外设中断控制器节点 需要使用中断的设备节点
gic中断控制器设备树节点
gic中断控制器在设备树里面的节点
虽然有compatible属性 但没有对应驱动,因为中断不可少,linux启动一定会初始化,也就不用驱动来匹配了
intc: interrupt-controller@a01000 {
compatible = "arm,cortex-a7-gic";
#interrupt-cells = <3>; //描述下一级中断信息所需要的单元个数
interrupt-controller; //表示该设备是一个中断控制器，外设可以连接在该中断控制器上
reg = <0xa01000 0x1000>, //指分发器寄存器地址
<0xa02000 0x100>; //cpu接口单元寄存器地址
};
其他外设中断控制器节点
有些外设和中断关系密切,这时把这个外设节点也作为一个中断控制器节点
这样可以用这个外设节点对某一个具体的中断进行管理
gpio5: gpio@20ac000 {
compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
reg = <0x20ac000 0x4000>;
interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>, //负责管理的中断类型通过 interrupts属性说明,这里有三个,和gic#interrupt-cells = <3>; 有关
<GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
clocks = <&clks IMX6UL_CLK_GPIO5>;
gpio-controller;
#gpio-cells = <2>;
interrupt-controller; //说明gpio5节点作为中断控制器
#interrupt-cells = <2>; //设置其他外设想使用这个中断的描述格式
gpio-ranges = <&iomuxc 0 7 10>, <&iomuxc 10 5 2>;
};
interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>,
//负责管理的中断类型通过 interrupts属性说明,这里有三个,和gic#interrupt-cells = <3>; 有关
- GIC_SPI：中断类型，0 表示 SPI 中断，1 表示 PPI 中断
- 74：中断号，对于 SPI 中断来说中断号的范围为 0~987，对于 PPI 中断来说中断号的范围为 0~15
74中断号对应gpio5低16位IO中断,75中断号对应高16位IO中断
- IRQ_TYPE_LEVEL_HIGH：中断类型，高电平触发
其他设备使用中断控制器节点
设置iomux
设置iomux 给这个gpio_5_1 设置为普通io 输入 用来检测信号
pinctrl_button: button{
fsl,pins = <
MX6UL_PAD_SNVS_TAMPER1__GPIO5_IO01 0x000110A1
>;
};
编写设备节点_button
想在button_interrupt节点使用 gpio5管理的中断类型
button_interrupt {
compatible = "button_interrupt";
pinctrl-names = "default"; //pinctrl子系统链接iomux节点进行io初始化
pinctrl-0 = <&pinctrl_button>; //gpio子系统
button_gpio = <&gpio5 1 GPIO_ACTIVE_LOW>;
status = "okay";
interrupt-parent = <&gpio5>; //需要使用的具体中断控制器,但是gpio5有32个
interrupts = <1 IRQ_TYPE_EDGE_RISING>; //想使用的中断GPIO5-1 和如何触发中断
};
设备驱动构造
记录按了多少次
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/of_irq.h>
#include "interrupt.h"
/*------------------字符设备内容----------------------*/
#define DEV_NAME "button"
#define DEV_CNT (1)
static dev_t button_devno; //定义字符设备的设备号
static struct cdev button_chr_dev; //定义字符设备结构体chr_dev
struct class *class_button; //保存创建的类
struct device *device_button; // 保存创建的设备
struct device_node *button_device_node = NULL; //定义按键设备节点结构体
unsigned button_GPIO_number = 0; //保存button使用的GPIO引脚编号
u32 interrupt_number = 0; // button 引脚中断编号
atomic_t button_status = ATOMIC_INIT(0); //定义整型原子变量，保存按键状态 ，设置初始值为0
static irqreturn_t button_irq_hander(int irq, void *dev_id)
{
// printk_green("button on \n");
/*按键状态加一*/
atomic_inc(&button_status);
return IRQ_HANDLED;
}
static int button_open(struct inode *inode, struct file *filp)
{
int error = -1;
/*添加初始化代码*/
// printk_green("button_open");
/*获取按键 设备树节点*/
button_device_node = of_find_node_by_path("/button_interrupt");
if(NULL == button_device_node)
{
printk("of_find_node_by_path error!");
return -1;
}
/*获取按键使用的GPIO*/
button_GPIO_number = of_get_named_gpio(button_device_node ,"button_gpio", 0);
if(0 == button_GPIO_number)
{
printk("of_get_named_gpio error");
return -1;
}
/*申请GPIO , 记得释放*/
error = gpio_request(button_GPIO_number, "button_gpio");
if(error < 0)
{
printk("gpio_request error");
gpio_free(button_GPIO_number);
return -1;
}
error = gpio_direction_input(button_GPIO_number);//设置引脚为输入模式
/*获取中断号*/
interrupt_number = irq_of_parse_and_map(button_device_node, 0);//检测设备树里面的interrupts属性值,根据后面的索引号
//比如这里为0,就是拿取第一个中断属性,interrupts = <1 IRQ_TYPE_EDGE_RISING>;
printk("\n irq_of_parse_and_map! = %d \n",interrupt_number);
/*申请中断, 记得释放*/
//interrupt_number 对应的中断号
//button_irq_hander 处理中断函数
//IRQF_TRIGGER_RISING flag标志位 表明用什么样的方式触发
//"button_interrupt" 中断名
//device_button 中断使用的设备 devices_create(),这时候中断号和设备绑定在一起
error = request_irq(interrupt_number,button_irq_hander,IRQF_TRIGGER_RISING,"button_interrupt",device_button);
if(error != 0)
{
printk("request_irq error");
free_irq(interrupt_number, device_button);
return -1;
}
/*申请之后已经开启了，切记不要再次打开，否则运行时报错*/
// // enable_irq(interrupt_number);
return 0;
}
static int button_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int error = -1;
int button_countervc = 0;
/*读取按键状态值*/
button_countervc = atomic_read(&button_status);
/*结果拷贝到用户空间*/
error = copy_to_user(buf, &button_countervc, sizeof(button_countervc));
if(error < 0)
{
printk("copy_to_user error");
return -1;
}
/*清零按键状态值*/
atomic_set(&button_status,0);
return 0;
}
/*字符设备操作函数集，.release函数实现*/
static int button_release(struct inode *inode, struct file *filp)
{
/*释放申请的引脚,和中断*/
gpio_free(button_GPIO_number);
free_irq(interrupt_number, device_button);
return 0;
}
/*字符设备操作函数集*/
static struct file_operations button_chr_dev_fops = {
.owner = THIS_MODULE,
.open = button_open,
.read = button_read,
.release = button_release,
};
/*
*驱动初始化函数
*/
static int __init button_driver_init(void)
{
int error = -1;
/*采用动态分配的方式，获取设备编号，次设备号为0，*/
error = alloc_chrdev_region(&button_devno, 0, DEV_CNT, DEV_NAME);
if (error < 0)
{
printk("fail to alloc button_devno\n");
goto alloc_err;
}
/*关联字符设备结构体cdev与文件操作结构体file_operations*/
button_chr_dev.owner = THIS_MODULE;
cdev_init(&button_chr_dev, &button_chr_dev_fops);
/*添加设备至cdev_map散列表中*/
error = cdev_add(&button_chr_dev, button_devno, DEV_CNT);
if (error < 0)
{
printk("fail to add cdev\n");
goto add_err;
}
class_button = class_create(THIS_MODULE, DEV_NAME); //创建类
device_button = device_create(class_button, NULL, button_devno, NULL, DEV_NAME);//创建设备 DEV_NAME 指定设备名，
return 0;
add_err:
unregister_chrdev_region(button_devno, DEV_CNT); // 添加设备失败时，需要注销设备号
printk("\n error! \n");
alloc_err:
return -1;
}
/*
*驱动注销函数
*/
static void __exit button_driver_exit(void)
{
pr_info("button_driver_exit\n");
/*删除设备*/
device_destroy(class_button, button_devno); //清除设备
class_destroy(class_button); //清除类
cdev_del(&button_chr_dev); //清除设备号
unregister_chrdev_region(button_devno, DEV_CNT); //取消注册字符设备
}
module_init(button_driver_init);
module_exit(button_driver_exit);
MODULE_LICENSE("GPL");
各种驱动中使用中断的函数
request_irq()函数
申请中断
include/linux/interrupt.h
static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
const char *name, void *dev)
参数：
- irq：要申请的中断号
- handler：中断处理函数
- flags：中断标志
- name：中断名字
- dev：传递给中断处理函数的第二个参数
- device结构体变量，区分不同设备共用同一中断
返回值：
-
成功：0
-
失败：负数
irq_handler_t
typedef irqreturn_t (*irq_handler_t)(int, void *);
irqreturn_t
enum irqreturn {
IRQ_NONE = (0 << 0),
IRQ_HANDLED = (1 << 0),
IRQ_WAKE_THREAD = (1 << 1),
};
typedef enum irqreturn irqreturn_t;
- IRQ_NONE：不是本驱动程序的中断，不处理
- IRQ_HANDLED：正常处理
- IRQ_WAKE_THREAD：使用中断下半部处理
flags
include/linux/interrupt.h
#define IRQF_SHARED 0x00000080
#define IRQF_ONESHOT 0x00002000
#define IRQF_TRIGGER_NONE 0x00000000
#define IRQF_TRIGGER_RISING 0x00000001
#define IRQF_TRIGGER_FALLING 0x00000002
#define IRQF_TRIGGER_HIGH 0x00000004
#define IRQF_TRIGGER_LOW 0x00000008
free_irq()函数
释放中断
include/linux/interrupt.h
const void *free_irq(unsigned int irq, void *dev_id)
参数：
-
irq：要释放的中断号
-
dev：传递给中断处理函数的第二个参数
返回值：
无
enable_irq()函数
使能中断
kernel/irq/manage.c
void enable_irq(unsigned int irq)
参数：
- irq：要使能的中断号
返回值：
无
disable_irq()函数
禁止中断，等待中断执行完毕
kernel/irq/manage.c
void disable_irq(unsigned int irq)
参数：
- irq：要禁止的中断号
返回值：
无
disable_irq_nosync()函数
禁止中断，不等待中断执行完
kernel/irq/manage.c
void disable_irq_nosync(unsigned int irq)
参数：
- irq：要禁止的中断号
返回值：
无
local_irq_disable()宏
include/linux/irqflags.h
禁止处理器中断
#define local_irq_disable() do { raw_local_irq_disable(); } while (0)
local_irq_enable()宏
include/linux/irqflags.h
开处理器中断
#define local_irq_enable() do { raw_local_irq_enable(); } while (0)
中断2:中断上下部分
下半部分有两种写法 tasklet和工作队列
tasklet队列和工作队列一样 都放在下半部
tasklet机制
- 软中断也中断所以会有下面这些
- 软中断环境下执行、不允许休眠、降低系统实时性,所以操作不能特别特别长
工作队列机制
类似于kthread_worker 线程流水线工人
进程上下文环境执行、允许休眠、不影响实时性
tasklet总结
因为中断需要越快越好 所以耗时的地方就变成了中断上下部机制
上半部就是上面的传统的部分 马上结束中断
下半部弄一下耗时的事情
linux开机的时候 会自动创造一个 软件中断叫 tasklet 软中断
我们要做的事情就是在驱动里面 创建一个tasklet结构体 给我们创建的tasklet结构体初始化和注册函数
在上半部分的中断函数中 唤醒一下 tasklet结构体 结束中断即可
所以这样的好处是 上部分弄完后 马上就能再次响应中断了 不会卡死在中断中太久
tasklet_struct结构体和相关api
在驱动中 增加一个tasklet_struct结构体 在驱动打开的时候进行 tasklet_init()
同时在触发的中断函数中 使用tasklet_schedule()函数 再马上关中断就好
struct tasklet_struct
{
struct tasklet_struct *next;//链接下一个tasket
unsigned long state; //tasklet_struct结构体的状态,比如初始,调度,运行状态
atomic_t count; //计数器，记录对tasket的引用数
void (*func)(unsigned long); //函数指针 用来出来tasklet_struct结构体的一些任务,任务在中断上半部分进行设置
unsigned long data; //函数参数
};
//下面是tasklet_struct结构体 相关的api
tasklet_init()函数
初始化一个tasket对象 这时候tasklet_struct->state 为初始化状态
include/linux/interrupt.h
void tasklet_init(struct tasklet_struct *t,
void (*func)(unsigned long), unsigned long data)
- t：要初始化的tasket
- func：tasklet执行的函数
- data：函数参数
tasklet_schedule()函数
设置tasklet_struct 为调度状态 当设置为调度状态的时候
tasklet的tasklet_action在遍历tasklet_struct就会执行里面的 tasklet_struct->func()函数了
tasklet_kill()函数
使用完后可以进行注销
代码实例
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/of_irq.h>
#include "interrupt.h"
/*------------------字符设备内容----------------------*/
#define DEV_NAME "button"
#define DEV_CNT (1)
static dev_t button_devno; //定义字符设备的设备号
static struct cdev button_chr_dev; //定义字符设备结构体chr_dev
struct class *class_button; //保存创建的类
struct device *device_button; // 保存创建的设备
struct device_node *button_device_node = NULL; //定义按键设备节点结构体
unsigned button_GPIO_number = 0; //保存button使用的GPIO引脚编号
u32 interrupt_number = 0; // button 引脚中断编号
atomic_t button_status = ATOMIC_INIT(0); //定义整型原子变量，保存按键状态 ，设置初始值为0
struct tasklet_struct button_tasklet;
void button_tasklet_hander(unsigned long data)
{
int counter = 1;
mdelay(200);
printk(KERN_ERR "button_tasklet_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "button_tasklet_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "button_tasklet_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "button_tasklet_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "button_tasklet_hander counter = %d \n", counter++);
}
static irqreturn_t button_irq_hander(int irq, void *dev_id)
{
printk(KERN_ERR "button_irq_hander----------inter");
/*按键状态加一*/
atomic_inc(&button_status);
tasklet_schedule(&button_tasklet); //中断触发的时候把负责的事情放入初始化好的tasklet
printk(KERN_ERR "button_irq_hander-----------exit");
return IRQ_HANDLED;
}
static int button_open(struct inode *inode, struct file *filp)
{
int error = -1;
/*获取按键 设备树节点*/
button_device_node = of_find_node_by_path("/button_interrupt");
if(NULL == button_device_node)
{
printk("of_find_node_by_path error!");
return -1;
}
/*获取按键使用的GPIO*/
button_GPIO_number = of_get_named_gpio(button_device_node ,"button_gpio", 0);
if(0 == button_GPIO_number)
{
printk("of_get_named_gpio error");
return -1;
}
/*申请GPIO , 记得释放*/
error = gpio_request(button_GPIO_number, "button_gpio");
if(error < 0)
{
printk("gpio_request error");
gpio_free(button_GPIO_number);
return -1;
}
error = gpio_direction_input(button_GPIO_number);//设置引脚为输入模式
/*获取中断号*/
interrupt_number = irq_of_parse_and_map(button_device_node, 0);
printk("\n irq_of_parse_and_map! = %d \n",interrupt_number);
/*申请中断, 记得释放*/
error = request_irq(interrupt_number,button_irq_hander,IRQF_TRIGGER_RISING,"button_interrupt",device_button);
if(error != 0)
{
printk("request_irq error");
free_irq(interrupt_number, device_button);
return -1;
}
/*初始化button_tasklet*/
tasklet_init(&button_tasklet,button_tasklet_hander,0);
/*申请之后已经开启了，切记不要再次打开，否则运行时报错*/
// // enable_irq(interrupt_number);
return 0;
}
static int button_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int error = -1;
int button_countervc = 0;
/*读取按键状态值*/
button_countervc = atomic_read(&button_status);
/*结果拷贝到用户空间*/
error = copy_to_user(buf, &button_countervc, sizeof(button_countervc));
if(error < 0)
{
printk("copy_to_user error");
return -1;
}
/*清零按键状态值*/
atomic_set(&button_status,0);
return 0;
}
/*字符设备操作函数集，.release函数实现*/
static int button_release(struct inode *inode, struct file *filp)
{
/*释放申请的引脚,和中断*/
gpio_free(button_GPIO_number);
free_irq(interrupt_number, device_button);
return 0;
}
/*字符设备操作函数集*/
static struct file_operations button_chr_dev_fops = {
.owner = THIS_MODULE,
.open = button_open,
.read = button_read,
.release = button_release};
/*
*驱动初始化函数
*/
static int __init button_driver_init(void)
{
int error = -1;
/*采用动态分配的方式，获取设备编号，次设备号为0，*/
error = alloc_chrdev_region(&button_devno, 0, DEV_CNT, DEV_NAME);
if (error < 0)
{
printk("fail to alloc button_devno\n");
goto alloc_err;
}
/*关联字符设备结构体cdev与文件操作结构体file_operations*/
button_chr_dev.owner = THIS_MODULE;
cdev_init(&button_chr_dev, &button_chr_dev_fops);
/*添加设备至cdev_map散列表中*/
error = cdev_add(&button_chr_dev, button_devno, DEV_CNT);
if (error < 0)
{
printk("fail to add cdev\n");
goto add_err;
}
class_button = class_create(THIS_MODULE, DEV_NAME); //创建类
device_button = device_create(class_button, NULL, button_devno, NULL, DEV_NAME);//创建设备 DEV_NAME 指定设备名，
return 0;
add_err:
unregister_chrdev_region(button_devno, DEV_CNT); // 添加设备失败时，需要注销设备号
printk("\n error! \n");
alloc_err:
return -1;
}
/*
*驱动注销函数
*/
static void __exit button_driver_exit(void)
{
pr_info("button_driver_exit\n");
/*删除设备*/
device_destroy(class_button, button_devno); //清除设备
class_destroy(class_button); //清除类
cdev_del(&button_chr_dev); //清除设备号
unregister_chrdev_region(button_devno, DEV_CNT); //取消注册字符设备
}
module_init(button_driver_init);
module_exit(button_driver_exit);
MODULE_LICENSE("GPL");
详细介绍
这里不看也无所谓
linux有各种各样的软终端 下面说说怎么注册的软终端
include/linux/interrupt.h
struct softirq_action
{
void (*action)(struct softirq_action *);
};
static struct softirq_action softirq_vec[NR_SOFTIRQS];
enum //这个枚举表示各种软中断
{
HI_SOFTIRQ=0, /* 最高优先级软中断 */
TIMER_SOFTIRQ, /* 定时器软中断 */
NET_TX_SOFTIRQ, /* 网络数据发送软中断 */
NET_RX_SOFTIRQ, /* 网络数据接收软中断 */
BLOCK_SOFTIRQ, /*块设备软中断*/
BLOCK_IOPOLL_SOFTIRQ,
TASKLET_SOFTIRQ, /* tasklet 软中断 这个是我们要用的 */
SCHED_SOFTIRQ, /* 调度软中断 */
HRTIMER_SOFTIRQ, /* 高精度定时器软中断 */
RCU_SOFTIRQ, /* RCU服务软中断 */
NR_SOFTIRQS
}; //内核规定了各种软中断的用法
注册一个软中断
void open_softirq(int nr, void (*action)(struct softirq_action *));
nr：要开启的软中断
action：相应的处理函数
上面注册完后 还需要进行触发 才能运行
void raise_softirq(unsigned int nr);
nr：指定激活的软中断
}
有了上面软终端怎么注册 下面是开机后 自动运行注册软终端 tasklet
现在开始讲 tasklet机制
基于软中断实现的下半部机制，运行在软中断环境下
kernel/softirq.c
开机后自动运行 softirq_init()函数
void __init softirq_init(void)
{
int cpu;
for_each_possible_cpu(cpu) {
per_cpu(tasklet_vec, cpu).tail =
&per_cpu(tasklet_vec, cpu).head;
per_cpu(tasklet_hi_vec, cpu).tail =
&per_cpu(tasklet_hi_vec, cpu).head;
}
open_softirq(TASKLET_SOFTIRQ, tasklet_action); //tasklet_action函数给指定的软终端增加处理函数,循环遍历所有的tasklet_struct结构体
//判断tasklet_struct->state是不是调度状态,是的话就执行 tasklet_struct->func()
//因为在中断上半部分来指定 tasklet_struct->func()
//所以给下半部分安排的任务就会被tasklet_action进行调用
open_softirq(HI_SOFTIRQ, tasklet_hi_action); //
工作队列总结
tasklet队列和工作队列一样 都放在下半部
tasklet机制
- 软中断也中断所以会有下面这些
- 软中断环境下执行、不允许休眠、降低系统实时性,所以操作不能特别特别长
工作队列机制
类似于kthread_worker 线程流水线工人
进程上下文环境执行、允许休眠、不影响实时性
工作队列使用结构体&&api
linux内核默认给我们创建了工作队列 这里只用看看就好
创建工作队列 alloc_workqueue()
include/linux/workqueue.h
#define alloc_workqueue(fmt, flags, max_active, args...) \
__alloc_workqueue_key((fmt), (flags), (max_active), \
NULL, NULL, ##args)
使用linux系统给我们创建的工作队列
work_struct结构体 用来表示一个具体的工作
struct work_struct {
atomic_long_t data;
struct list_head entry; //链表节点,进行串联
work_func_t func; //函数指针,具体处理函数
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
INIT_WORK 宏
#define INIT_WORK(_work, _func)
\ __INIT_WORK((_work), (_func), 0)
//work就是上面的具体工作 func表示具体处理函数
schedule_work()函数
//和tasklet一样 在上半部中断中调用,把工作加入工作队列,让工作开始工作
实例操作
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/of_irq.h>
#include "interrupt.h"
/*------------------字符设备内容----------------------*/
#define DEV_NAME "button"
#define DEV_CNT (1)
static dev_t button_devno; //定义字符设备的设备号
static struct cdev button_chr_dev; //定义字符设备结构体chr_dev
struct class *class_button; //保存创建的类
struct device *device_button; // 保存创建的设备
struct device_node *button_device_node = NULL; //定义按键设备节点结构体
unsigned button_GPIO_number = 0; //保存button使用的GPIO引脚编号
u32 interrupt_number = 0; // button 引脚中断编号
atomic_t button_status = ATOMIC_INIT(0); //定义整型原子变量，保存按键状态 ，设置初始值为0
struct work_struct button_work; //定义工作结构体
/*定义工作执行函数*/
void work_hander(struct work_struct *work)
{
int counter = 1;
mdelay(200);
printk(KERN_ERR "work_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "work_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "work_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "work_hander counter = %d \n", counter++);
mdelay(200);
printk(KERN_ERR "work_hander counter = %d \n", counter++);
}
/*定义按键中断服务函数*/
static irqreturn_t button_irq_hander(int irq, void *dev_id)
{
/*按键状态加一*/
atomic_inc(&button_status);
schedule_work(&button_work); //触发工作
return IRQ_HANDLED;
}
static int button_open(struct inode *inode, struct file *filp)
{
int error = -1;
/*获取按键 设备树节点*/
button_device_node = of_find_node_by_path("/button_interrupt");
if(NULL == button_device_node)
{
printk("of_find_node_by_path error!");
return -1;
}
/*获取按键使用的GPIO*/
button_GPIO_number = of_get_named_gpio(button_device_node ,"button_gpio", 0);
if(0 == button_GPIO_number)
{
printk("of_get_named_gpio error");
return -1;
}
/*申请GPIO , 记得释放*/
error = gpio_request(button_GPIO_number, "button_gpio");
if(error < 0)
{
printk("gpio_request error");
gpio_free(button_GPIO_number);
return -1;
}
error = gpio_direction_input(button_GPIO_number);//设置引脚为输入模式
/*获取中断号*/
interrupt_number = irq_of_parse_and_map(button_device_node, 0);
printk("\n irq_of_parse_and_map! = %d \n",interrupt_number);
/*申请中断, 记得释放*/
error = request_irq(interrupt_number,button_irq_hander,IRQF_TRIGGER_RISING,"button_interrupt",device_button);
if(error != 0)
{
printk("request_irq error");
free_irq(interrupt_number, device_button);
return -1;
}
/*初始化button_work*/
INIT_WORK(&button_work, work_hander);
/*申请之后已经开启了，切记不要再次打开，否则运行时报错*/
// // enable_irq(interrupt_number);
return 0;
}
static int button_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int error = -1;
int button_countervc = 0;
/*读取按键状态值*/
button_countervc = atomic_read(&button_status);
/*结果拷贝到用户空间*/
error = copy_to_user(buf, &button_countervc, sizeof(button_countervc));
if(error < 0)
{
printk("copy_to_user error");
return -1;
}
/*清零按键状态值*/
atomic_set(&button_status,0);
return 0;
}
/*字符设备操作函数集，.release函数实现*/
static int button_release(struct inode *inode, struct file *filp)
{
/*释放申请的引脚,和中断*/
gpio_free(button_GPIO_number);
free_irq(interrupt_number, device_button);
return 0;
}
/*字符设备操作函数集*/
static struct file_operations button_chr_dev_fops = {
.owner = THIS_MODULE,
.open = button_open,
.read = button_read,
.release = button_release};
/*
*驱动初始化函数
*/
static int __init button_driver_init(void)
{
int error = -1;
/*采用动态分配的方式，获取设备编号，次设备号为0，*/
error = alloc_chrdev_region(&button_devno, 0, DEV_CNT, DEV_NAME);
if (error < 0)
{
printk("fail to alloc button_devno\n");
goto alloc_err;
}
/*关联字符设备结构体cdev与文件操作结构体file_operations*/
button_chr_dev.owner = THIS_MODULE;
cdev_init(&button_chr_dev, &button_chr_dev_fops);
/*添加设备至cdev_map散列表中*/
error = cdev_add(&button_chr_dev, button_devno, DEV_CNT);
if (error < 0)
{
printk("fail to add cdev\n");
goto add_err;
}
class_button = class_create(THIS_MODULE, DEV_NAME); //创建类
device_button = device_create(class_button, NULL, button_devno, NULL, DEV_NAME);//创建设备 DEV_NAME 指定设备名，
return 0;
add_err:
unregister_chrdev_region(button_devno, DEV_CNT); // 添加设备失败时，需要注销设备号
printk("\n error! \n");
alloc_err:
return -1;
}
/*
*驱动注销函数
*/
static void __exit button_driver_exit(void)
{
pr_info("button_driver_exit\n");
/*删除设备*/
device_destroy(class_button, button_devno); //清除设备
class_destroy(class_button); //清除类
cdev_del(&button_chr_dev); //清除设备号
unregister_chrdev_region(button_devno, DEV_CNT); //取消注册字符设备
}
module_init(button_driver_init);
module_exit(button_driver_exit);
MODULE_LICENSE("GPL");
1373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
