字符设备驱动(七)按键异步通知

目录

  • 按键驱动方式对比
  • 进程间发信号
  • 目标
  • 如何让驱动通知应用
  • 程序编写
    • 驱动程序
    • 应用程序
    • 完整代码如下
  • 测试

title: 字符设备驱动(七)按键异步通知

tags: linux

date: 2018-11-24 16:39:47

toc: true

---

按键驱动方式对比

  1. 查询:耗资源
  2. 中断: 没有超时机制，当没有中断作为生产者，read函数一直休眠
  3. poll机制，加入超时机制
  • 上述三种都是app主动去获取按键，使用异步通知的形式可以使按键发生后，通知app去读取

进程间发信号

以前使用kill -9 pid实际也就是发送信号给进程，信号9为关闭进程.我们使用 man signal查看需要头文件 #include <signal.h>测试程序如下如果用在gcc下编译需要为sleep函数添加头文件#include <unistd.h>

NAME
       signal - ANSI C signal handling

SYNOPSIS
       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);

实例函数如下arm-linux-gcc -o test test.c

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

 //typedef void (*sighandler_t)(int);
void my_signal_fun(int signum)
{
    static int cnt=0;
    printf("signum=%d ,%d times\n",signum,++cnt );

}

int main(int argc, char const *argv[])
{
    signal(SIGUSR1,my_signal_fun);
    while(1)
    {

        sleep(100);
    }
    return 0;
}

测试使用kill -USR1 pid后会打印信号

[email protected]:~/stu/dri/code/10th$ ./test &
[3] 4356
[email protected]:~/stu/dri/code/10th$ kill -USR1 4356
signum=10 ,1 times
[email protected]:~/stu/dri/code/10th$ kill -10 4356
signum=10 ,2 times

目标

驱动程序使用信号通知应用程序去读取按键

如何让驱动通知应用

  1. 应用程序注册信号处理函数
  2. 驱动程序发信号
  3. 信号被发给应用程序,应用程序需要告诉自己的pid给驱动程序
  4. 驱动程序 调用void kill_fasync(struct fasync_struct **fp, int sig, int band)发信号

程序编写

驱动程序

搜索下发送信号的函数kill_fasync，寻找一个字符设备是怎么使用的，在drivers/char/rtc.c中有如下调用

kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);

//结构体定义如下:
static struct fasync_struct *rtc_async_queue;
struct fasync_struct {
    int magic;
    int fa_fd;
    struct  fasync_struct   *fa_next; /* singly linked list */
    struct  file        *fa_file;
};

信号的接受者被定义在fasync_struct中，搜索下其初始化函数，发现函数rtc_fasync被调用如下形式，也就是类似于open、close的形式了

static const struct file_operations rtc_fops = {
    .owner      = THIS_MODULE,
    .llseek     = no_llseek,
    .read       = rtc_read,
#ifdef RTC_IRQ
    .poll       = rtc_poll,
#endif
    .ioctl      = rtc_ioctl,
    .open       = rtc_open,
    .release    = rtc_release,
    .fasync     = rtc_fasync,
};

函数的原型如下，这个函数用来初始化结构体，应用程序会最终调用他告知驱动应该信号给哪个pid

static int rtc_fasync (int fd, struct file *filp, int on)
{
    return fasync_helper (fd, filp, on, &rtc_async_queue);
}

也就是是说应用程序通过fasync来调用驱动具体的rtc_fasync，这个函数会设置fasync_struct这个结构体，这个结构体会被当做驱动发送信号函数的参数，也就是说应用程序告诉驱动程序其目标

步骤如下

  1. 定义一个fasync_struct结构体，在中断中使用发送信号
  2. 定义一个供app函数调用的.fasync 
    static int drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: drv_fasync\n");
 return fasync_helper (fd, filp, on, &drv_async_queue);
}

应用程序

  1. 设置哪个进程将接受到来自fd的SIGIO信号，如何获取自身程序的pid

    man pid

SYNOPSIS
       #include <sys/types.h>
       #include <unistd.h>

       pid_t getpid(void);
       pid_t getppid(void);
  2. 获取当前的标志，添加FASYNC机制
? 复制一个现存的描述符(cmd=F_DUPFD)    。
? 获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD)   。
? 获得/设置文件状态标志(cmd=F_GETFL或F_SETFL) 。
? 获得/设置异步I/O有权(cmd=F_GETOWN或F_SETOWN) 。
? 获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW)。

程序

fcntl(fd, F_SETOWN, getpid());          //告知信号发送给哪个进程，
Oflags = fcntl(fd, F_GETFL);            //获取当前的文件状态
fcntl(fd, F_SETFL, Oflags | FASYNC);    // 改变fasync标记，
                                        //最终会调用到驱动的faync > fasync_helper
                                        //初始化/释放fasync_struct
                                        //这个会触发驱动函数的fasync

完整代码如下

驱动

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
//#include <linux/interrupt.h>
volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;
volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;

static struct class *drv_class;
static struct class_device  *drv_class_dev;

// 定义一个名为`button_waitq`的队列
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
// flag=1 means irq happened and need to update
int flag=0;

static struct fasync_struct *drv_async_queue; 

struct pin_desc{
    unsigned int pin;
    unsigned int key_val;
};

/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
    {S3C2410_GPF0, 0x01},
    {S3C2410_GPF2, 0x02},
    {S3C2410_GPG3, 0x03},
    {S3C2410_GPG11, 0x04},
};

static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    printk("irq%d\r\n",irq);

    struct pin_desc * pindesc = (struct pin_desc *)dev_id;
    unsigned int pinval;

    pinval = s3c2410_gpio_getpin(pindesc->pin);

    if (pinval)
    {
        /* 松开 */
        key_val = 0x80 | pindesc->key_val;
    }
    else
    {
        /* 按下 */
        key_val = pindesc->key_val;
    }

    //wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    flag=1;

    kill_fasync (&drv_async_queue, SIGIO, POLL_IN);
    return IRQ_RETVAL(IRQ_HANDLED);
}

static unsigned  drv_poll(struct file *file, poll_table *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait); // 不会立即休眠

    if (flag)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}

static int drv_open(struct inode *inode, struct file *file)
{
    /* 配置GPF0,2为输入引脚 */
    /* 配置GPG3,11为输入引脚 */
    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
    request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
    request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);
    return 0;
}

int drv_close(struct inode *inode, struct file *file)
{
    free_irq(IRQ_EINT0, &pins_desc[0]);
    free_irq(IRQ_EINT2, &pins_desc[1]);
    free_irq(IRQ_EINT11,&pins_desc[2]);
    free_irq(IRQ_EINT19,&pins_desc[3]);
    return 0;
}

static ssize_t drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    //int minor =  MINOR(file->f_dentry->d_inode->i_rdev);
    //printk("drv_write=%d\n",minor);
    return 0;
}

static ssize_t drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
    return -EINVAL;

    /* 如果没有按键动作, 休眠 */
    //wait_event_interruptible(button_waitq, flag);

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    flag = 0;

    return 1;
}

static int drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: drv_fasync\n");
    return fasync_helper (fd, filp, on, &drv_async_queue);
}

static struct file_operations drv_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   drv_open,
    .write  =   drv_write,
    .read   =   drv_read,
    .release =  drv_close,
    .poll    =  drv_poll,
    .fasync  =  drv_fasync,
};

static int major;
static int drv_init(void)
{
    int minor=0;
    major=register_chrdev(0, "drv", &drv_fops); // 注册, 告诉内核
    drv_class = class_create(THIS_MODULE, "drv");
    drv_class_dev = class_device_create(drv_class, NULL, MKDEV(major, 0), NULL, "xyz%d", minor);

    gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
    gpfdat = gpfcon + 1;
    gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
    gpgdat = gpgcon + 1;
    return 0;
}

static void drv_exit(void)
{
    unregister_chrdev(major, "drv"); // 卸载
    class_device_unregister(drv_class_dev);
    class_destroy(drv_class);
    iounmap(gpfcon);
    iounmap(gpgcon);
}

module_init(drv_init);
module_exit(drv_exit);

MODULE_AUTHOR("xxx");
MODULE_VERSION("0.1.0");
MODULE_DESCRIPTION("S3C2410/S3C2440 LED Driver");
MODULE_LICENSE("GPL");

App


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

int fd;

void my_signal_fun(int signum)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val: 0x%x\n", key_val);
}

int main(int argc, char **argv)
{
    unsigned char key_val;
    int ret;
    int Oflags;

    signal(SIGIO, my_signal_fun);

    fd = open("/dev/xyz0", O_RDWR);
    if (fd < 0)
    {
        printf("can‘t open!\n");
    }

    fcntl(fd, F_SETOWN, getpid());
    Oflags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, Oflags | FASYNC);

    while (1)
    {
        sleep(1000);
    }

    return 0;
}

测试

可以发现打开文件的时候会有提示driver: drv_fasync，说明App会主动调用.fasync

# insmod dri.ko
# 后台运行
# ./test &
# driver: drv_fasync
#实际休眠状态的

# ps
  PID  Uid        VSZ Stat Command
  798 0          1308 S   ./test
....

# 按键按下正常打印
# irq55
key_val: 0x3
irq55
key_val: 0x83
irq18

原文地址：https://www.cnblogs.com/zongzi10010/p/10016369.html

时间： 2024-11-02 20:40:57

字符设备驱动(七)按键异步通知的相关文章

《Linux4.0设备驱动开发详解》笔记--第九章：Linux设备驱动中的异步通知与同步I/O

在设备驱动中使用异步通知可以使得对设备的访问可进行时,由驱动主动通知应用程序进行访问.因此,使用无阻塞I/O的应用程序无需轮询设备是否可访问,而阻塞访问也可以被类似"中断"的异步通知所取代.异步通知类似于硬件上的"中断"概念,比较准确的称谓是"信号驱动的异步I/O". 9.1 异步通知的概念和作用 异步通知:一旦设备就绪,则主动通知应用程序,该应用程序无需查询设备状态 几种通知方式比较: 阻塞I/O :一直等待设备可访问后开始访问 非阻塞I/O:

字符设备驱动(五)按键优化休眠

目录 字符设备驱动(五)按键优化 按键值读取 休眠读取 程序设计 测试 title: 字符设备驱动(五)按键优化 tags: linux date: 2018-11-23 17:56:57 toc: true --- 字符设备驱动(五)按键优化 按键值读取 Linux内部有系统函数s3c2410_gpio_getpin能够读取GPIO的值 unsigned int s3c2410_gpio_getpin(unsigned int pin) { void __iomem *base = S3C24

字符设备驱动(六)按键poll机制

title: 字符设备驱动(六)按键poll机制 tags: linux date: 2018-11-23 18:57:40 toc: true --- 字符设备驱动(六)按键poll机制 引入 在字符设备驱动(五)按键休眠中的App中虽然使用了休眠,但是如果Read没有返回的话会一直死等,类似阻塞,我们期望等待一段时间后自动返回,等待的时候程序依然是睡眠的,这里引入poll机制 应用程序的open/close/write/read都有对应的系统内核的sys_open/sys_close/sys

深入浅出~Linux设备驱动之按键设备驱动

在上述的驱动系列博客中,我们已经了解了关于阻塞和非阻塞.异步通知.轮询.内存和I/O口访问.并发控制等知识,按键设备驱动相对来说是比较简单的,本章内容可以加深我们对字符设备驱动架构.阻塞与非阻塞.中断定时器等相关知识的理解.在嵌入式的系统中,按键的硬件原理简单,就是通过一个上拉电阻将处理器的外部中断引脚拉高,电阻的另一端接按钮并接地就可以实现. 1.按键的确认流程如下 2 按键驱动中的有关数据结构 2.1 按键设备结构体以及定时器 #define MAX KEY BUF 16 // 键缓冲区大小

linux 字符设备驱动开发详解

一.设备的分类及特点 1.字符设备 字符设备是面向数据流的设备,没有请求缓冲区,对设备的存取只能按顺序按字节的存取而不能随机访问.    Linux下的大多设备都是字符设备.应用程序是通过字符设备节点来访问字符设备的.通常至少需要实现 open, close, read, 和 write 等系统调用.    设备节点一般都由mknod命令都创建在/dev目录下,包含了设备的类型.主/次设备号以及设备的访问权限控制等,如:crw-rw----  1 root  root 4, 64 Feb 18

字符设备驱动编程(一)

当我们对字符设备进行编程的时候,需要做一些常有的准备工作,获取设备号,对设备文件操作函数的注册,文件信息的初始化,文件的内核表现形式,向内核的注册等等. 对字符设备的访问是通过文件系统内的设备名称进行的,通常在/dev目录下.使用ls -l 每行的第一个字符用来识别该文件类型,c就是字符设备驱动文件.b就是块设备驱动文件.内核通过主次设备号来进行管理设备.主设备号表示对应的驱动程序(虽然linux允许多个驱动程序共享主设备号,但是绝大部分的设备还是一个主设备号对应一个驱动程序),次设备号表示具体

Linux字符设备驱动框架

字符设备是Linux三大设备之一(另外两种是块设备,网络设备),字符设备就是字节流形式通讯的I/O设备,绝大部分设备都是字符设备,常见的字符设备包括鼠标.键盘.显示器.串口等等,当我们执行ls -l /dev的时候,就能看到大量的设备文件,c就是字符设备,b就是块设备,网络设备没有对应的设备文件.编写一个外部模块的字符设备驱动,除了要实现编写一个模块所需要的代码之外,还需要编写作为一个字符设备的代码. 驱动模型 Linux一切皆文件,那么作为一个设备文件,它的操作方法接口封装在struct fi

Linux内核分析（五）----字符设备驱动实现

原文:Linux内核分析(五)----字符设备驱动实现 Linux内核分析(五) 昨天我们对linux内核的子系统进行简单的认识,今天我们正式进入驱动的开发,我们今后的学习为了避免大家没有硬件的缺陷,我们都会以虚拟的设备为例进行学习,所以大家不必害怕没有硬件的问题. 今天我们会分析到以下内容: 1.      字符设备驱动基础 2.      简单字符设备驱动实现 3.      驱动测试 l  字符设备基础 1.       字符设备描述结构 在linux2.6内核中,使用cdev结构体描述一

20150518 字符设备驱动

20150518 字符设备驱动 2015-05-18 Lover雪儿 经过这两个月的学习,相信对设备驱动的编写已经有一个大概的了解了,温故而知新,此处我们再一次的系统性的复习一下字符设备驱动,然后,我们来尝试着自己从零实战写一个AD采集的字符设备驱动. 以前学习使用的是老方法来注册字符设备驱动,此处我们使用字符设备的新方法来学习. 本文参考:华清远见的Linux 设备驱动开发详解-字符设备驱动,具体还请看作者原书 一.cdev结构体 1 struct cdev{ 2 struct kobject