一、IO 模型
五种网络IO模型_Oh-Why_not的博客-CSDN博客_五种网络io模型
二、Linux 内核等待队列
Linux 内核等待队列_爱洋葱的博客-CSDN博客_内核等待队列
三、IO 多路复用
select()函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET_迟到的螃蟹的博客-CSDN博客_fd_zero
四、Linux 中断基本概念
i.MX 6ULL 驱动开发 九:中断(非阻塞处理)_lqonlylove的博客-CSDN博客
五、按键原理
i.MX 6ULL 驱动开发 九:中断(非阻塞处理)_lqonlylove的博客-CSDN博客
六、设计思路
1、poll机制
韦东山:Linux驱动基石之POLL机制_韦东山的博客-CSDN博客
poll机制分析(韦东山)_Wenleon的博客-CSDN博客
linux的poll_wait函数,等待队列和poll机制_Scott Johnson的博客-CSDN博客
2、应用程序设计思路
1、使用 open
打开设备文件时,控制 fd
是否阻塞访问(使用 O_NONBLOCK
标识符,控制 fd
是否阻塞访问)。
2、使用 FD_ZERO
、FD_SET
、FD_ISSET
和 FD_CLR
函数设置需要操作的文件描述符。
3、使用 select
或 poll
函数触发驱动中的 poll
函数,获取按键值状态。
4、当按键可以访问时,使用 read
函数读取按键值。
3、驱动程序设计思路
1、当应用程序通过 select
或 poll
函数触发驱动中 poll
函数时,驱动 poll
函数返回当前按键状态。
2、驱动程序中 poll
函数中调用 poll_wait
函数将将等待队列注册到 poll_table
中(poll_wait
函数作用配合等待队列,可以在驱动中唤醒应用程序中 poll
函数,唤醒方法通过等待队列提供一些 API
接口)。
3、在驱动 read
函数中将按键值返回到应用程序。
4、poll 处理机制总结
1、在应用程序中通过 select
或 poll
函数触发驱动中 poll
函数,进行获取当前资源状态;
2、在资源满足情况下,使用 read
进行读取。
3、read
进行读取时,可以分为阻塞或非阻塞操作(在调用 read
时,已经确定资源满足操作状态,因此不需要阻塞)。
七、添加设备树
1、确定引脚
通过原理图可以确定 key
使用 UART1_CTS
引脚。
2、查找引脚定义是否冲突
3、添加 pinctrl 子系统相关配置
pinctrl_key: keygrp {
fsl,pins = <
MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080 /* KEY0 */
>;
};
4、添加 gpio 子系统相关配置
key {
#address-cells = <1>;
#size-cells = <1>;
compatible = "lq-key";
pinctrl-names = "default";
pinctrl-0 = <&pinctrl_key>;
key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>; /* KEY0 */
status = "okay";
};
5、添加 interrupts 相关配置
key {
#address-cells = <1>;
#size-cells = <1>;
compatible = "lq-key";
pinctrl-names = "default";
pinctrl-0 = <&pinctrl_key>;
key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>; /* KEY0 */
interrupt-parent = <&gpio1>;
interrupts = <18 IRQ_TYPE_LEVEL_LOW>; /* 低电平触发 */
status = "okay";
};
主要添加 interrupt-parent
和 interrupts
属性。
6、测试
1、编译设备树
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ make dtbs
CHK include/config/kernel.release
CHK include/generated/uapi/linux/version.h
CHK include/generated/utsrelease.h
make[1]: 'include/generated/mach-types.h' is up to date.
CHK include/generated/bounds.h
CHK include/generated/asm-offsets.h
CALL scripts/checksyscalls.sh
DTC arch/arm/boot/dts/imx6ull-alientek-emmc.dtb
DTC arch/arm/boot/dts/imx6ull-alientek-nand.dtb
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$
2、拷贝编译成功的设备树文件
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ ls /home/onlylove/my/tftp/ -l
total 11528
-rwxrwxr-x 1 onlylove onlylove 5901744 Sep 17 04:04 zImage
-rwxrwxr-x 1 onlylove onlylove 5901752 Aug 20 01:24 zImage.bak
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ cp arch/arm/boot/dts/imx6ull-alientek-emmc.dtb /home/onlylove/my/tftp
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ ls /home/onlylove/my/tftp/ -l
total 11568
-rw-rw-r-- 1 onlylove onlylove 39084 Sep 23 21:18 imx6ull-alientek-emmc.dtb
-rwxrwxr-x 1 onlylove onlylove 5901744 Sep 17 04:04 zImage
-rwxrwxr-x 1 onlylove onlylove 5901752 Aug 20 01:24 zImage.bak
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$
3、启动 linux
查看设备树解析是否成功
/ # cd /proc/
/proc # ls
1 41 65 driver mounts
10 46 66 execdomains mtd
11 47 7 fb net
12 48 8 filesystems pagetypeinfo
13 49 83 fs partitions
14 5 84 interrupts self
15 50 9 iomem softirqs
16 51 95 ioports stat
17 52 asound irq swaps
18 53 buddyinfo kallsyms sys
19 54 bus key-users sysrq-trigger
2 55 cgroups keys sysvipc
20 56 cmdline kmsg thread-self
21 57 consoles kpagecount timer_list
22 58 cpu kpageflags tty
23 59 cpuinfo loadavg uptime
24 6 crypto locks version
3 60 device-tree meminfo vmallocinfo
4 61 devices misc vmstat
40 62 diskstats modules zoneinfo
/proc # cd device-tree/
/sys/firmware/devicetree/base # ls
#address-cells key
#size-cells memory
aliases model
alphaled name
backlight pxp_v4l2
beep regulators
chosen reserved-memory
clocks sii902x-reset
compatible soc
cpus sound
gpioled spi4
interrupt-controller@00a01000
/sys/firmware/devicetree/base # cd key/
/sys/firmware/devicetree/base/key # ls
#address-cells interrupt-parent name status
#size-cells interrupts pinctrl-0
compatible key-gpio pinctrl-names
/sys/firmware/devicetree/base/key # cat compatible
lq-key
/sys/firmware/devicetree/base/key #
/sys/firmware/devicetree/base/key #
八、驱动编写
#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include <linux/uaccess.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#define NEWCHRDEV_MAJOR 0 /* 主设备号(如果为0则让系统自动分配,如果大于0则使用指定设备号) */
#define NEWCHRDEV_MINOR 0 /* 次设备号 */
#define NEWCHRDEV_COUNT 1 /* 设备号个数 */
#define NEWCHRDEV_NAME "key" /* 名子 */
#define TIMEOUT 1000 /* 定时器超时时间 */
#define KEY_OFF 0xFF /* 按键未按下 */
#define KEY_ON 0x01 /* 按键按下 */
typedef struct{
struct device_node *nd; /* 设备节点 */
int gpio; /* key gpio */
int irqnum; /* 中断号 */
struct tasklet_struct tasklet; /* tasklet 变量(中断下半部) */
unsigned long tasklet_data; /* 传递给 tasklet 处理函数的参数 */
struct work_struct work; /* 工作队列 变量(中断下半部) */
struct timer_list timer; /* key 消抖定时器 */
atomic_t keyvalue; /* 按键状态 */
wait_queue_head_t rq; /* 读等待队列头 */
}lqkey_t;
typedef struct{
struct cdev dev; /* cdev 结构体 */
int major; /* 主设备号 */
int minor; /* 次设备号 */
dev_t devid; /* 设备号 */
struct class *class; /* 类 */
struct device *device; /* 设备 */
lqkey_t key_data; /* key 相关数据 */
}newchrdev_t;
newchrdev_t newchrdev;
static int keyio_read_wait_init(void)
{
/* 初始化读等待队列头 */
init_waitqueue_head(&newchrdev.key_data.rq);
return 0;
}
/*
* @description : 按键IO初始化
* @param : 无
* @return : 无
*/
static int keyio_init(void)
{
int ret = 0;
/***** 处理设备树 *****/
/* 1、获取设备树节点 */
newchrdev.key_data.nd = of_find_node_by_path("/key");
if (newchrdev.key_data.nd== NULL){
printk("key node not find!\r\n");
goto keyio_init_error1;
}else {
printk("beep node find!\r\n");
}
/* 1、获取设备树中的gpio属性 */
newchrdev.key_data.gpio = of_get_named_gpio(newchrdev.key_data.nd, "key-gpio", 0);
if(newchrdev.key_data.gpio < 0) {
printk("can't get key-gpio");
goto keyio_init_error1;
}
printk("key num = %d\r\n", newchrdev.key_data.gpio);
/***** 使用gpio子系统设置引脚 *****/
/* 1、向 gpio 子系统申请 GPIO 管脚 */
ret = gpio_request(newchrdev.key_data.gpio,"key");
if(ret){
printk("can't request key-gpio!\r\n");
goto keyio_init_error1;
}
/* 2、设置key-gpio为输入 */
gpio_direction_input(newchrdev.key_data.gpio);
if(ret < 0) {
printk("can't set key-gpio!\r\n");
goto keyio_init_error2;
}
return 0;
keyio_init_error2:
gpio_free(newchrdev.key_data.gpio);
keyio_init_error1:
return 1;
}
static int keyio_exit(void)
{
/* 1、向gpio子系统请求释放gpio */
gpio_free(newchrdev.key_data.gpio);
return 0;
}
static void key_tasklet(unsigned long data)
{
printk("key_tasklet\r\n");
}
static void key_work(struct work_struct *work)
{
printk("key_work\r\n");
mod_timer(&newchrdev.key_data.timer, jiffies + msecs_to_jiffies(TIMEOUT));
}
/* @description : 中断服务函数
* 定时器用于按键消抖
* @param - irq : 中断号
* @param - dev_id : 设备结构
* @return : 中断执行结果
*/
static irqreturn_t key0_handler(int irq, void *dev_id)
{
printk("key0_handler\r\n");
// tasklet_schedule(&newchrdev.key_data.tasklet);
schedule_work(&newchrdev.key_data.work);
return IRQ_RETVAL(IRQ_HANDLED);
}
/*
* @description : key中断初始化
* @param : 无
* @return : 无
*/
static int keyirq_init(void)
{
int ret = 0;
/***** 使用中断子系统设置 *****/
/* 1、从设备树获取key-gpio对于中断号 */
newchrdev.key_data.irqnum = irq_of_parse_and_map(newchrdev.key_data.nd, 0);
if (!newchrdev.key_data.irqnum){
goto keyirq_init_error1;
}
/* 2、向中断子系统请求中断号 */
ret = request_irq(newchrdev.key_data.irqnum, key0_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,"KEY0",&newchrdev);
if(ret < 0){
printk("can't request irq!\r\n");
goto keyirq_init_error1;
}
/***** 使用中断上下部(tasklet和工作队列选择一个) *****/
/* 1、初始化中断下半部 */
// tasklet_init(&newchrdev.key_data.tasklet,key_tasklet,newchrdev.key_data.tasklet_data);
INIT_WORK(&newchrdev.key_data.work, key_work);
return 0;
keyirq_init_error1:
return 1;
}
static int keyirq_exit(void)
{
/* 1、向中断子系统请求释放中断号 */
free_irq(newchrdev.key_data.irqnum,&newchrdev);
/***** 使用中断上下部(tasklet和工作队列选择一个) *****/
/* 1、销毁中断下半部 */
// tasklet_kill(&newchrdev.key_data.tasklet);
flush_work(&newchrdev.key_data.work);
return 0;
}
void key_timer_function(unsigned long arg)
{
printk("key_timer_function\r\n");
/* 1、设置按键状态(按键按下) */
atomic_set(&newchrdev.key_data.keyvalue,0x01);
/* 2、唤醒等待队列 */
wake_up_interruptible(&newchrdev.key_data.rq);
}
/*
* @description : key消抖定时器初始化
* @param : 无
* @return : 无
*/
static int keytimer_init(void)
{
/* 1、创建定时器 */
init_timer(&newchrdev.key_data.timer);
newchrdev.key_data.timer.function = key_timer_function;
newchrdev.key_data.timer.expires = jiffies + msecs_to_jiffies(TIMEOUT);
newchrdev.key_data.timer.data = (unsigned long)&newchrdev;
return 0;
}
static int keytimer_exit(void)
{
/* 删除、创建定时器 */
del_timer(&newchrdev.key_data.timer);
return 0;
}
/*
* @description : 打开设备
* @param - inode : 传递给驱动的inode
* @param - filp : 设备文件,file结构体有个叫做private_data的成员变量
* 一般在open的时候将private_data指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int newchrdev_open(struct inode *inode, struct file *filp)
{
printk("newchrdev_open!\r\n");
filp->private_data = &newchrdev; /* 设置私有数据 */
return 0;
}
/*
* @description : 从设备读取数据
* @param - filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 读取的字节数,如果为负值,表示读取失败
*/
static ssize_t newchrdev_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret = 0;
unsigned char keystatus = 0;
// printk("newchrdev_read!\r\n");
newchrdev_t *dev = (newchrdev_t *)filp->private_data;
/* 1、获取按键值 */
keystatus = atomic_read(&dev->key_data.keyvalue);
if(filp->f_flags & O_NONBLOCK){
/***** 处理非阻塞情况 *****/
/* 2、如果没有按下,返回异常 */
if(keystatus == KEY_OFF){
return -EAGAIN;
}
}
/* 3、获取按键值返回到应用程序 */
if(keystatus == KEY_ON){
ret = copy_to_user(buf, &keystatus, sizeof(keystatus));
atomic_set(&dev->key_data.keyvalue,0xFF);
}else{
ret = -EINVAL;
goto data_error;
}
return 0;
data_error:
return ret;
}
/*
* @description : 向设备写数据
* @param - filp : 设备文件,表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 写入的字节数,如果为负值,表示写入失败
*/
static ssize_t newchrdev_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
printk("newchrdev_write!\r\n");
return 0;
}
/*
* @description : 关闭/释放设备
* @param - filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int newchrdev_release(struct inode *inode, struct file *filp)
{
printk("newchrdev_release!\r\n");
return 0;
}
/*
* @description : 监控文件描述符
* @param - filp : 要关闭的设备文件(文件描述符)
* @param - wait : 等待列表(poll_table)
* @return : 设备或者资源状态
*/
static unsigned int newchrdev_poll(struct file *filp, struct poll_table_struct *wait)
{
unsigned int mask = 0;
newchrdev_t *dev = (newchrdev_t *)filp->private_data;
// printk("newchrdev_poll!\r\n");
/* 1、将等待队列注册到poll_table中 */
poll_wait(filp, &dev->key_data.rq, wait);
/* 2、获取按键状态 */
if(atomic_read(&newchrdev.key_data.keyvalue)==KEY_ON){
/* 3、按键按下 */
mask = POLLIN | POLLRDNORM;
}
return mask;
}
static const struct file_operations newchrdevops = {
.owner = THIS_MODULE,
.open = newchrdev_open,
.read = newchrdev_read,
.write = newchrdev_write,
.release = newchrdev_release,
.poll = newchrdev_poll,
};
/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
/* 驱动入口函数具体内容 */
/* 1、字符设备号分配 */
int ret;
newchrdev.major = NEWCHRDEV_MAJOR;
if(newchrdev.major){
newchrdev.minor = NEWCHRDEV_MINOR;
newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
}else{
ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
newchrdev.major = MAJOR(newchrdev.devid);
newchrdev.minor = MINOR(newchrdev.devid);
}
if(ret < 0){
printk("newchrdev xxx_chrdev_region failed!\r\n");
goto newchrdev_chrdev_region_failed;
}
printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);
/* 2、注册字符设备 */
newchrdev.dev.owner = THIS_MODULE;
cdev_init(&newchrdev.dev,&newchrdevops);
ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
if(ret < 0){
printk("newchrdev cdev_add failed!\r\n");
goto newchrdev_cdev_add_failed;
}
/* 3、创建类 */
newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
if(IS_ERR(newchrdev.class)) {
printk("newchrdev class_create failed!\r\n");
goto newchrdev_class_create_failed;
}
/* 4、创建设备 */
newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
if(IS_ERR(newchrdev.device)){
printk("newchrdev device_create failed!\r\n");
goto neschrdev_device_creat_failed;
}
ret = keyio_init();
if(ret != 0){
goto keyio_init_failed;
}
ret = keyirq_init();
if(ret != 0){
goto keyirq_init_failed;
}
keytimer_init();
/* 初始化按键状态值 */
atomic_set(&newchrdev.key_data.keyvalue,KEY_OFF);
keyio_read_wait_init();
return 0;
keyirq_init_failed:
keyio_exit();
keyio_init_failed:
neschrdev_device_creat_failed:
class_destroy(newchrdev.class);
newchrdev_class_create_failed:
cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:
unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
newchrdev_chrdev_region_failed: /* 字符设备号分配失败处理函数(未分配资源,因此不做处理) */
return ret;
}
/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
keytimer_exit();
keyirq_exit();
keyio_exit();
/* 驱动卸载函数具体内容 */
/* 4、删除设备 */
device_destroy(newchrdev.class,newchrdev.devid);
/* 3、删除类 */
class_destroy(newchrdev.class);
/* 2、注销字符设备 */
cdev_del(&newchrdev.dev);
/* 1、释放设备号 */
unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}
module_init(newchrdev_init);
module_exit(newchrdev_exit);
MODULE_LICENSE("GPL");
九、应用程序编写
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "stdio.h"
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
int fd = 0, retvalue = 0;
char readbuf = 0;
fd_set readfds;
struct timeval timeout;
if(argc != 2){
printf("Error Usage!\r\n");
return -1;
}
fd = open(argv[1],O_RDWR|O_NONBLOCK);
if(fd < 0){
printf("Can't open file %s\r\n", argv[1]);
return -1;
}
while(1){
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
/* 构造超时时间 */
timeout.tv_sec = 0;
timeout.tv_usec = 500000; /* 500ms */
retvalue = select(fd + 1, &readfds, NULL, NULL, &timeout);
switch (retvalue) {
case 0: /* 超时 */
break;
case -1: /* 错误 */
break;
default: /* 可以读取数据 */
retvalue = read(fd, &readbuf, sizeof(readbuf));
if (retvalue < 0){
}else{
if (readbuf)
printf("key value = %#X\r\n", readbuf);
}
}
}
close(fd);
return 0;
}
十、特别说明
1、wait_event_interruptible 函数使用说明
/**
* wait_event_interruptible - sleep until a condition gets true
* wait_event_interruptible - 一直睡到条件变为真
* @wq: the waitqueue to wait on 等待队列
* @condition: a C expression for the event to wait for 等待事件的C表达式
*
* The process is put to sleep (TASK_INTERRUPTIBLE) until the
* @condition evaluates to true or a signal is received.
* 进程将进入睡眠状态(TASK INTERRUPTIBLE),直到@condition的计算结果为true或接收到信号。
* The @condition is checked each time the waitqueue @wq is woken up.
* 每次唤醒等待队列@wq时,都会检查@condition。
*
* wake_up() has to be called after changing any variable that could
* change the result of the wait condition.
* wake_up() 必须在更改任何可能更改等待条件结果的变量后调用。
*
* The function will return -ERESTARTSYS if it was interrupted by a
* signal and 0 if @condition evaluated to true.
* 如果该函数被信号中断,则该函数将返回 -ERESTARTSYS,如果@condition计算结果为 true,则该函数将返回 0。
*/
#define wait_event_interruptible(wq, condition) \
({ \
int __ret = 0; \
might_sleep(); \
if (!(condition)) \
__ret = __wait_event_interruptible(wq, condition); \
__ret; \
})
通过 if (!(condition))
语句可以确定,当 condition
为 0
时 __wait_event_interruptible
函数被调用。因此,condition
值定义如下:
0
:条件不满足;- 非
0
:添加满足;
2、poll_wait 函数说明
static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
if (p && p->_qproc && wait_address)
p->_qproc(filp, wait_address, p);
}
驱动中 poll
函数中最核心是 poll_wait
函数,poll_wait
是一个非阻塞函数。
poll_wait
函数需要和等待队列配合使用,poll_wait
函数**将对应的等待队列头添加到 poll_table
**中。
poll_wait
作用:通过等待队列,在驱动中将应用程序 poll
函数唤醒,不需要等待应用程序中 poll
函数超时返回。
特别说明:
1、如果驱动中不调用 poll_wait
函数,应用程中 poll
一直等到超时事件结束,才进行返回。
2、如果驱动中调用 poll_wait
函数,应用程序中 poll
函数可以被驱动进行唤醒,提前返回,可以有效实施处理数据。