//=================================================================================================================================
[1] >> 中断编程知识点
[
1>>中断号解析而来
2>>查看设备树:/proc/device-tree/key
3>> EINT = External interrupt 外部中断
4>>中断编程:中断号与中断服务函数
5>>DTS == Device Tree Source 设备树源码
6>>DTB == 设备树镜像（bin = 二进制 = 镜像）
7>>register_chrdev( ); #注册登记字符设备
8>>kzalloc( ) #分配堆栈内存
9>>class_create( ) #类创造
10>>device_create( ) #设备构建
11>>copy_to_user( ) #复制到用户
12>>init_waitqueue_head( ) #初始化等待队列头
13>>wait_event_interruptible( )#等待事件可中断
#将当前进程加入到等待队列头中并设置成TASK_INTERRUPTIBLE
14>>wake_up_interruptible() #唤醒可中断
15>>signal( ) #信号 #处理方法
16>>fcntl(fd, F_SETOWN, getpid());#file-control文件控制 #当前进程设置成SIGIO的属主进程
17>>fcntl(fd, F_SETFL, flags | FASYNC );#将io模式设置成异步模式
18>>asynchronization(异步)
19>>TASK_INTERRUPTIBLE = 任务可打断-->可以休眠与退出休眠的任务
20>>O_NONBLOCK = 非阻塞模式 ; 阻塞模式是默认模式
21>>中断与轮询的关系
[
传统CPU采用轮询的方式获取设备数据,中断完美解决了该问题,中断类似于门铃,门铃一响就中断正在做的事情
举个例子:今天有快递与外卖送到门口,外卖的优先级更高,但是你要洗衣服
轮询:要么你隔5分钟去门口看一看;这就是CPU轮询
CPU中断:你洗你的衣服(当前线程),快递员(中断源1)与外卖员(中断源2)都到了按下(中断触发;电平跳变)一个门铃按钮,门铃智能系统 ((中断控制器:屏蔽/优先级/区分))
识别到外卖员与快递员,选择优先发出外卖到了的声响:外卖到啦!外卖到啦!外卖到啦!然后你(你就是CPU)停下手下的活去取外卖(外部中断的服务函数) ;
]
22>>驱动阻塞的步骤
[
1,加入等待队列
add_wait_queue(wait_queue_head_t * q, wait_queue_t * wait)
2，（任务）设置当前状态TASK_INTERRUPTIBLE；current（当前）
set_current_state(TASK_INTERRUPTIBLE)
3，让出调度 = 休眠
schedule(void)
更加智能的接口，等同于上面的三个接口：等待事件可中断
wait_event_interruptible(wq, condition)
]
]
//=================================================================================================================================
=异步信号通知====
异步信号通知： 当有数据到时候，驱动会发送信号(SIGIO)给应用，就可以异步去读写数据，不用主动去读写
// 1,设置信号处理方法
signal(SIGIO,catch_signale);
// 2，将当前进程设置成SIGIO的属主进程
fcntl(fd, F_SETOWN, getpid());
// 3，将io模式设置成异步模式
int flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | FASYNC );
第二节
| 步骤1:查看设备中断 |  |
|---|---|
| 步骤2:为该中断编写设备树节点 |  |
| 步骤三:编译设备树源码DTS | make dtbs //将dts设备树源码编译成设备树镜像 |
| 步骤四:更新开发板的设备树镜像 >>不用烧写,直接复制 | 1>>将dtb设备树镜像复制到开发板 ; 2>>重启开发板 == 重启内核(设备树位于内核) |
| 步骤五:使用代码从设备树的节点获取中断号 |  |
| 步骤六:向系统申请中断服务函数 |  |
按键中断驱动代码key_drv.c
功能[1]:1.1申请中断服务函数 ; 1.2申请中断号 ; 1.3释放中断
功能[2]:2.1字符设备框架 ; 2.2注册设备 ; 2.3申请主设备号 ; 2.4创建类与设备节点
功能[3]:文件IO模型之阻塞 = 休眠与唤醒
功能[4]:文件IO模型之非阻塞
功能[5]:文件IO模型之多路复用
功能[6]:文件IO模型之异步信号通知
功能[7]:工作队列实现中断下半部
/*************头文件***********/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#define GPXCON_REG 0x11000C20 //控制寄存器
#define KEY_ENTER 28 //28 == key_event->code
// 设计一个描述按键的数据的对象
struct key_event{
int code; // 表示按键的类型: home, esc, Q,W,E,R,T, ENTER
int value; // 表示按下还是抬起 1 / 0
};
//设计一个全局设备对象--描述按键信息
struct key_desc{
unsigned int dev_major; //主设备号
struct class *cls; //类结构体
struct device *dev; //设备结构体
int irqno; //中断号
void *reg_base; //基地址的map地址
struct key_event event; //描述按键的数据的对象
wait_queue_head_t wq_head; //等待队列头 --> 用于阻塞/休眠
int key_state; //按键状态
struct fasync_struct *faysnc; //文件异步信号结构体 --> 存储
struct work_struct mywork; //工作队列结构体 --> 实现下半部中断
};
struct key_desc *key_dev;
//[7]中断后半段(中断不能长时间占用主线程,中断实在太长就在中断后半段完成) --> 由工作队列实现
void work_irq_half(struct work_struct *work)
{
printk("-------%s-------------\n", __FUNCTION__);
//表示有数据,唤醒 --> 退出阻塞
wake_up_interruptible(&key_dev->wq_head);
//设置标志位
key_dev->key_state = 1;
//发送SIGIO信号
kill_fasync(&key_dev->faysnc, SIGIO, POLLIN);
}
//[1][7]中断服务函数
irqreturn_t key_irq_handler(int irqno, void *devid)
{
printk("-------%s-------------\n", __FUNCTION__);
//读取数据寄存器
int value = readl(key_dev->reg_base + 4) & (1<<2);
if(value){ // 1 == 抬起
printk("key3 up\n");
key_dev->event.code = KEY_ENTER;
key_dev->event.value = 0;
}else{ // 0 == 按下
printk("key3 pressed\n");
key_dev->event.code = KEY_ENTER;
key_dev->event.value = 1;
}
//工作队列函数 --> 启动下半部中断
schedule_work(&key_dev->mywork);
return IRQ_HANDLED;
}
//[1]从设备树节点中获取中断号
int get_irqno_from_node(void)
{
//查找设备树节点,并将设备树节点信息存储到设备结构体作为返回值
struct device_node *np = of_find_node_by_path("/key_int_node");
if(np){
printk("find node ok\n");
}else{
printk("find node failed\n");
}
//从设备结构体中解析中断号
int irqno = irq_of_parse_and_map(np, 0);
printk("irqno = %d\n", irqno);
return irqno;
}
//[2]key_drv_open( ) <--> open( )
int key_drv_open(struct inode *inode, struct file *filp)
{
printk("-------%s-------------\n", __FUNCTION__);
return 0;
}
//[2]key_drv_read( ) <--> read( )
ssize_t key_drv_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
{
printk("-------%s-------------\n", __FUNCTION__);
//1,判断文件是阻塞/非阻塞模式 ;非阻塞模式O_NONBLOCK如果没有数据，立马返回一个出错码
if(filp->f_flags & O_NONBLOCK && !key_dev->key_state)
return -EAGAIN;
int ret;
//2，将当前进程加入到等待队列头中,当前进程状态设置成TASK_INTERRUPTIBLE,进入休眠
//key_dev->key_state == 0 --> 进入休眠 ; key_dev->key_state == 1 --> 不进入休眠
wait_event_interruptible(key_dev->wq_head, key_dev->key_state);
// 表示有数据 ; 内核层 --> 应用层
ret = copy_to_user(buf, &key_dev->event, count);
if(ret > 0)
{
printk("copy_to_user error\n");
return -EFAULT;
}
// 传递给用户数据之后，将数据清除掉
memset(&key_dev->event, 0, sizeof(key_dev->event));
key_dev->key_state = 0;
return count;
}
//[2]key_drv_write( ) <--> write( )
ssize_t key_drv_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
{
printk("-------%s-------------\n", __FUNCTION__);
return 0;
}
//[2]key_drv_close( ) <--> close( )
int key_drv_close (struct inode *inode, struct file *filp)
{
printk("-------%s-------------\n", __FUNCTION__);
return 0;
}
//[5]key_drv_poll( ) <--> poll( )
unsigned int key_drv_poll(struct file *filp, struct poll_table_struct *pts)
{
//返回一个mask值
unsigned int ret;
//调用poll_wait,将当前到等待队列注册系统中
poll_wait(filp, &key_dev->wq_head, pts);
// 1，当没有数据到时候返回一个0
if(!key_dev->key_state)
ret = 0;
// 2，有数据返回一个POLLIN
if(key_dev->key_state)
ret |= POLLIN;
return ret;
}
//[6]文件异步信号量函数
int key_drv_fasync(int fd, struct file *filp,int on)
{
//记录信号该发送给谁
return fasync_helper(fd, filp, on, &key_dev->faysnc);
}
//文件操作结构体
const struct file_operations key_fops = {
.open = key_drv_open,
.read = key_drv_read,
.write = key_drv_write,
.release = key_drv_close,
.poll = key_drv_poll,
.fasync = key_drv_fasync,
};
//模块加载函数
static int __init key_drv_init(void)
{
int ret;
//[2] 1,申请堆栈内存 --> 全局设备对象
key_dev = kzalloc(sizeof(struct key_desc), GFP_KERNEL);
//[2] 2,自动申请主设备号
key_dev->dev_major = register_chrdev(0, "key_drv", &key_fops);
//[2] 3,创建设备节点文件 --> 3.1先申请class ; 3.2在class中申请设备节点
key_dev->cls = class_create(THIS_MODULE, "key_cls");
key_dev->dev = device_create(key_dev->cls,NULL,MKDEV(key_dev->dev_major,0), NULL,"key0");
//[1] 4,硬件的初始化--地址映射或者中断申请
key_dev->irqno = get_irqno_from_node(); //获取中断号
//[1] 5,申请中断服务函数key_irq_handler(IRQF_TRIGGER_FALLING == 下降沿触发 ; IRQF_TRIGGER_RISING == 上升沿触发 ) ; 参数4：中断的描述/proc/interrupts内 参数5：传递给参数2中函数指针的值
ret = request_irq(key_dev->irqno, key_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "key3_eint10", NULL);
if(ret != 0)//申请失败
{
printk("request_irq error\n");
return ret;
}
//[1] 6,连续映射:控制寄存器+数据寄存器 ; 4字节=32位=一个寄存器
key_dev->reg_base = ioremap(GPXCON_REG, 8);
//[6] 7,初始化等待队列头
init_waitqueue_head(&key_dev->wq_head);
//[7] 8,初始化工作队列(参数1:工作队列结构体 参数2:中断下半部)
INIT_WORK(&key_dev->mywork, work_irq_half);
return 0;
}
//模块卸载
static void __exit key_drv_exit(void)
{
//断开io映射
iounmap(key_dev->reg_base);
//释放中断号
free_irq(key_dev->irqno, NULL);
//设备节点注销
device_destroy(key_dev->cls, MKDEV(key_dev->dev_major,0));
//类注销
class_destroy(key_dev->cls);
//设备注销
unregister_chrdev(key_dev->dev_major, "key_drv");
//释放堆栈
kfree(key_dev);
}
module_init(key_drv_init);
module_exit(key_drv_exit);
MODULE_LICENSE("GPL");
文件IO模型之阻塞测试key_test.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
//接收内核数据
struct key_event{
int code; // 表示按键的类型: home, esc, Q,W,E,R,T, ENTER
int value; // 表示按下还是抬起 1 / 0
};
#define KEY_ENTER 28
int main(int argc, char *argv[])
{
struct key_event event;
//以阻塞模型打开设备节点(默认模式)
int fd = open("/dev/key0", O_RDWR);
if(fd < 0)
{
perror("open");
exit(1);
}
while(1)
{
//阻塞模式:接收内核数据
read(fd, &event, sizeof(struct key_event));
if(event.code == KEY_ENTER)
{
if(event.value)
{
printf("APP__ key enter pressed\n");
}else{
printf("APP__ key enter up\n");
}
}
}
close(fd);
return 0;
}
文件IO模型之多路复用测试key_test.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
struct key_event{
int code; // 表示按键的类型: home, esc, Q,W,E,R,T, ENTER
int value; // 表示按下还是抬起 1 / 0
};
#define KEY_ENTER 28
int main(int argc, char *argv[])
{
int ret;
struct key_event event;
char in_buf[128];
//打开设备节点
int fd = open("/dev/key0", O_RDWR);
if(fd < 0)
{
perror("open");
exit(1);
}
//创建两个pollfd对象
struct pollfd pfd[2];
pfd[0].fd = fd; //监控按键设备
pfd[0].events = POLLIN; //pollin模式 = 监测fd被写入
pfd[1].fd = 0; //标准输入 = 0 ;标准输出 = 1 ; 标准错误 = 2 ;
pfd[1].events = POLLIN; //pollin模式 = 监测输入
while(1)
{
ret = poll(pfd, 2, -1); // 驱动需要去实现poll接口 ; -1 = 一直监听 ; 2 = 监听两个pollfd对象
if(ret > 0)
{
if(pfd[0].revents & POLLIN) //监听到的话 -->pfd.revents == pfd.events
{
//此时read虽然是阻塞IO,但是能直接读取到数据 --> 非阻塞
read(pfd[0].fd, &event, sizeof(struct key_event));
if(event.code == KEY_ENTER)
{
if(event.value)
{
printf("APP__ key enter pressed\n");
}else
{
printf("APP__ key enter up\n");
}
}
}
if(pfd[1].revents & POLLIN)
{
fgets(in_buf, 128, stdin);
printf("in_buf = %s\n", in_buf);
}
}else{
perror("poll");
exit(1);
}
}
close(pfd[0].fd);
return 0;
}
文件IO模型之异步信号通知测试key_test.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <signal.h>
struct key_event{
int code; // 表示按键的类型: home, esc, Q,W,E,R,T, ENTER
int value; // 表示按下还是抬起 1 / 0
};
#define KEY_ENTER 28
static int fd;
static struct key_event event;
//信号处理函数
void catch_signale(int signo)
{
if(signo == SIGIO)
{
printf("we got sigal SIGIO\n");
// 读取数据
read(fd, &event, sizeof(struct key_event));
if(event.code == KEY_ENTER)
{
if(event.value)
{
printf("APP__ key enter pressed\n");
}else
{
printf("APP__ key enter up\n");
}
}
}
}
int main(int argc, char *argv[])
{
int ret;
fd = open("/dev/key0", O_RDWR);
if(fd < 0)
{
perror("open");
exit(1);
}
// 1,设置SIGIO信号处理方法
signal(SIGIO,catch_signale);
// 2，将当前进程设置成SIGIO的属主进程
fcntl(fd, F_SETOWN, getpid());
// 3，将io模式设置成异步模式
int flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | FASYNC );
while(1)
{
// 可以做其他的事情,当SIGIO信号发来会自动进入catch_signale()函数
printf("I am waiting......\n");
sleep(1);
}
close(fd);
return 0;
}
Makefile文件
ROOTFS_DIR = /opt/4412/rootfs #开发板NFS路径
MODULE_NAME = key_drv
APP_NAME = key_test
CROSS_COMPILE = /home/george/Linux_4412/toolchain/gcc-4.6.4/bin/arm-none-linux-gnueabi-
CC = $(CROSS_COMPILE)gcc
ifeq ($(KERNELRELEASE), )
KERNEL_DIR = /home/george/Linux_4412/kernel/linux-3.14
CUR_DIR = $(shell pwd)
all :
make -C $(KERNEL_DIR) M=$(CUR_DIR) modules #生成模块
$(CC) $(APP_NAME).c -o $(APP_NAME)
clean :
make -C $(KERNEL_DIR) M=$(CUR_DIR) clean
rm -rf $(APP_NAME)
install:
cp -raf *.ko $(APP_NAME) $(ROOTFS_DIR)/drv_module
else
obj-m += $(MODULE_NAME).o
endif
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
