linux驱动程序保存变量,Linux设备驱动程序——高级字符驱动程序操作(异步通知)...

53 阅读 0 评论 35 点赞

我是靠谱客的博主懦弱万宝路，最近开发中收集的这篇文章主要介绍linux驱动程序保存变量,Linux设备驱动程序——高级字符驱动程序操作(异步通知)...，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

---《Linux设备驱动程序》。

阻塞与非阻塞访问、poll()函数提供了较好地解决设备访问的机制，但是如果有了异步通知整套机制就更加完整了。异步通知的意思是：一旦设备就绪，则主动通知应用程序，这样应用程序根本就不需要查询设备状态，这一点非常类似于硬件上“中断”的概念，比较准确的称谓是“信号驱动的异步I/O”。信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。阻塞I/O 意味着一直等待设备可访问后再访问，非阻塞I/O 中使用poll()意味着查询设备是否可访问，而异步通知则意味着设备通知自身可访问，实现了异步I/O。--- 宋宝华《Linux设备驱动程序开发详解》。

二、异步通知的实现方法

2.1 从应用程序application的角度考虑

为了启用文件的异步通知机制，用户程序必须执行两个步骤：首先，它们指定一个进程作为文件的“属主(owner)”，当进程使用fcntl系统调用执行F_SETOWN命令时，属主进程的进程ID号就被保存在filp->f_owner中。

int fcntl(int fd, int cmd, ... /* arg */ );

F_SETOWN(long)：Set the process ID or process group ID that will receive SIGIO and SIGURG signals for events on file descriptor fd to the ID given in arg. A process ID is specified as a positive value; a process group ID is specified as a negative value. Most commonly, the calling process specifies itself as the owner (that is, arg is specified as getpid(2)).

示例：

fcntl(fd, F_SETOWN, getpid());// 告诉驱动，发信号谁(哪个进程)

其次，为了真正启用异步通知机制，用户程序还必须在设备中设置FASYNC标志，这通过fcntl的F_SETFL命令完成。

F_SETFL (long):Set the file status flags to the value specified by arg. File access mode (O_RDONLY, O_WRONLY, O_RDWR) and file reation flags (i.e., O_CREAT, O_EXCL,O_NOCTTY, O_TRUNC) in arg are ignored. On Linux this command can change only the O_APPEND, O_ASYNC, O_DIRECT, O_NOATIME, and O_NONBLOCK flags.

示例：

fcntl(fd, F_SETFL, Oflags | FASYNC); // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct

2.2 从驱动程序的角度考虑

驱动程序实现异步信号的方法：

①. F_SETOWN被调用时对filp->f_owner赋值。

②. 在执行F_SETFL启用FASYNC时，调用驱动程序的fasync方法。只要filp->f_flags中的FASYNC标志发生了变化，就会调用该方法，以便把这个变化通知驱动程序，以使其能正确相应。文件打开时，FASYNC标志被默认是清除的。

③. 当数据到达时，所有注册为异步通知的进程都会被发送一个SIGIO信号，该信号由驱动程序发出。

设备驱动中异步通知编程比较简单，主要用到一项数据结构和两个函数。数据结构是fasync_struct 结构体，两个函数分别是：

a. 当一个打开的文件的FASYNC标志被修改时，调用下面函数处理FASYNC 标志变更。

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp);

b. 当数据到达时，用下面的语句来通知异步读取进程，(发送信号给进程)。

void kill_fasync(struct fasync_struct **fp, int sig, int band);

三、一个示例

该示例来自韦东山老师的视频教程第一期，下载地址，其针对JZ2440进行了讲解，我将其修改到了我的mini2440上，修改后的完整程序fasync.rar

视频中总结了如下几点：

驱动目的：按下按键时，驱动通知应用程序(异步通知)，应用程序不会主动去读取键值，有按键按下了，驱动程序发送信号给应用程序(kill_fasync)。实现遵循如下几点，具体可见程序的实现：

①应用程序，注册信号处理函数

signal(SIGIO,my_signal_fun);

②谁发信号？？驱动发送

③发给谁？？应用程序，要告诉驱动其PID号

fcntl(fd, F_SETOWN, getpid());

④怎么发？？？？

kill_fasync (&buttons_async, SIGIO, POLL_IN);

驱动测试应用程序buttons_int_fasync_drv_test.c

点击(此处)折叠或打开

#include

int fd; //全局变量

void my_signal_fun(int signum)

{

unsigned char key_val;

read(fd,&key_val,1);

printf("key_val:0x%xn",key_val);

}

int main(int argc,char **argv)

{

int ret;

int Oflags;

signal(SIGIO,my_signal_fun);

fd = open("/dev/mini2440_buttons", O_RDWR);

if(fd < 0)

printf("can't openn");

//fcntl

fcntl(fd, F_SETOWN, getpid()); // 告诉内核，发给谁

Oflags = fcntl(fd, F_GETFL);

fcntl(fd, F_SETFL, Oflags | FASYNC); // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct

while(1)

{

sleep(1000);

}

return 0;

}

驱动程序buttons_int_fasync_drv.c

点击(此处)折叠或打开

#include

#define DEVICE_NAME "mini2440_buttons" //设备名称

static struct class *buttons_int_fasync_drv_class;

static struct class_device *buttons_int_fasync_drv_class_dev;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq); //等待队列:当没有按键被按下时，如果有进程调用buttons_int_fasync_drv_read函数，它将休眠

static volatile int ev_press = 0; //中断事件标志, 中断服务程序将它置1，s3c24xx_buttons_read将它清0

static unsigned char key_val; //保存键值

static struct fasync_struct *buttons_async;

//引脚描述结构体

struct pin_desc{

unsigned int pin;

unsigned int key_value;

};

//管脚数组，按键赋键值，按下时是0x01,松开是0x81(最高位为1)

struct pin_desc pins_desc[6] = {

{S3C2410_GPG0, 0x01},

{S3C2410_GPG3, 0x02},

{S3C2410_GPG5, 0x03},

{S3C2410_GPG6, 0x04},

{S3C2410_GPG7, 0x05},

{S3C2410_GPG11,0x06},

};

//确定按键值

static irqreturn_t buttons_irq(int irq, void *dev_id)

{

//printk("irq = %dn",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_value;

}

else

{

//按下

key_val = pindesc->key_value;

}

ev_press = 1;

wake_up_interruptible(&button_waitq);

//kill_fasync(struct fasync_struct * * fp, int sig, int band)

kill_fasync (&buttons_async, SIGIO, POLL_IN);

return IRQ_HANDLED;

}

static int buttons_int_fasync_drv_open(struct inode *inode, struct file *file)

{

int ret;

ret = request_irq(IRQ_EINT8, buttons_irq,IRQT_BOTHEDGE,"KEY1",&pins_desc[0]); //pins_desc[0]传递给buttons_irq

ret = request_irq(IRQ_EINT11,buttons_irq,IRQT_BOTHEDGE,"KEY2",&pins_desc[1]);

ret = request_irq(IRQ_EINT13,buttons_irq,IRQT_BOTHEDGE,"KEY3",&pins_desc[2]);

ret = request_irq(IRQ_EINT14,buttons_irq,IRQT_BOTHEDGE,"KEY4",&pins_desc[3]);

ret = request_irq(IRQ_EINT15,buttons_irq,IRQT_BOTHEDGE,"KEY5",&pins_desc[4]);

ret = request_irq(IRQ_EINT19,buttons_irq,IRQT_BOTHEDGE,"KEY6",&pins_desc[5]);

return 0;

}

ssize_t buttons_int_fasync_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)

{

int ret;

if(size != 1) //读取单个按键

return -EINVAL;

wait_event_interruptible(button_waitq, ev_press); //如果没有按键动作，休眠，让出CPU

ret = copy_to_user(buf, &key_val, 1); //返回键值

ev_press = 0;

return 1;

}

int buttons_int_fasync_drv_close(struct inode *inode, struct file *file)

{

free_irq(IRQ_EINT8, &pins_desc[0]);

free_irq(IRQ_EINT11,&pins_desc[1]);

free_irq(IRQ_EINT13,&pins_desc[2]);

free_irq(IRQ_EINT14,&pins_desc[3]);

free_irq(IRQ_EINT15,&pins_desc[4]);

free_irq(IRQ_EINT19,&pins_desc[5]);

return 0;

}

static unsigned buttons_int_fasync_drv_poll(struct file *file, poll_table *wait)

{

unsigned int mask = 0;

poll_wait(file, &button_waitq, wait); // 不会立即休眠

if (ev_press)

mask |= POLLIN | POLLRDNORM;

return mask;

}

static int buttons_int_fasync_drv_fasync(int fd, struct file *filp, int on)

{

printk("driver:buttons_int_fasync_drv_fasyncn");

return fasync_helper (fd, filp, on, &buttons_async);

}

static struct file_operations buttons_int_fasync_drv_fops = {

.owner = THIS_MODULE,

.open = buttons_int_fasync_drv_open,

.read = buttons_int_fasync_drv_read,

.release = buttons_int_fasync_drv_close,

.poll = buttons_int_fasync_drv_poll,

.fasync = buttons_int_fasync_drv_fasync,

};

int major;

static int __init buttons_int_fasync_drv_init(void)

{

major = register_chrdev(0, DEVICE_NAME, &buttons_int_fasync_drv_fops);

if(major < 0)

{

printk(DEVICE_NAME "t can't register major number!n");

}

buttons_int_fasync_drv_class = class_create(THIS_MODULE, DEVICE_NAME);

buttons_int_fasync_drv_class_dev = class_device_create(buttons_int_fasync_drv_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME); /* /dev/mini2440_buttons */

printk(DEVICE_NAME"t initialized!n");

return 0;

}

static void __exit buttons_int_fasync_drv_exit(void)

{

unregister_chrdev(major, DEVICE_NAME);

class_device_unregister(buttons_int_fasync_drv_class_dev);

class_destroy(buttons_int_fasync_drv_class);

}

module_init(buttons_int_fasync_drv_init);

module_exit(buttons_int_fasync_drv_exit);

MODULE_LICENSE("GPL");