Linux驱动开发-内核共享工作队列
描述
【摘要】 在工作队列里，我们把推后执行的任务叫做工作（work），描述它的数据结构为work_struct，这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue_struct，而工作线程就是负责执行工作队列中的工作。系统有默认的工作者线程,自己也可以创建自己的工作者线程。
1. 内核工作队列
工作队列常见的使用形式是配合中断使用，在中断的服务函数里无法调用会导致休眠的相关函数代码，有了工作队列机制以后，可以将需要执行的逻辑代码放在工作队列里执行，只需要在中断服务函数里触发即可，工作队列是允许被重新调度、睡眠。
在工作队列里，我们把推后执行的任务叫做工作（work），描述它的数据结构为work_struct，这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue_struct，而工作线程就是负责执行工作队列中的工作。系统有默认的工作者线程,自己也可以创建自己的工作者线程。
2. 相关函数、结构介绍
2.1 工作结构
定义文件:
Workqueue.h (linux-3.5\include\Linux)
原型:
struct work_struct {
atomic_long_t data;
struct list_head entry;
work_func_t func; /* 工作函数指针 */
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
在工作结构体里，只需要关心一个成员函数：work_func_t func;
这个成员函数是一个函数指针，指向工作函数的指针；内核使用这个结构来描述一个工作，一个工作简单理解就是对应于一个函数，可以通过内核调度函数来调用work_struct中func指针所指向的函数。
2.2 工作函数介绍
定义文件 Workqueue.h (linux-3.5\include\linux)
函数原型 typedef void (*work_func_t)(struct work_struct *work);
功能 这是指向工作函数地址的函数指针，编写一个工作的函数。
参数 struct work_struct ＊work，这个参数，指向struct work_struct结构变量本身。
示例:
struct work_struct work;
INIT_WORK(&work, work_func);
初始化一个work结构，work_func工作函数的参数就是指向work结构。
2.3 初始化宏
1）初始化一个work结构：
INIT_WORK(_work, _func)
_work: struct work_struct work结构指针。
_func：用来填充work_struct work结构的fun成员，就是工作函数指针。
2）共享工作队列调度宏：
schedule_work(_work)
它也是一个宏，作用是调度一个工作_work。
_work：要调度工作的结构指针;
示例：
schedule_work(&work)
2.4 使用共享工作队列的步骤
1）定义一个工作结构变量
struct work_struct work;
2）初始化工作结构（重点func成员）。
先编写一个工作函数：
void work_func(struct work_struct * dat)
{
printk(“%p:”,dat);
……
}
初始化work：
INIT_WORK(&work, work_func);
3）在适当的地方调度工作
如果工作用于中断底部代码，则在中断顶部调度。
schedule_work(&work);
不是马上执行，而是等待CPU空闲才执行work_func。
3. 案例代码
3.1 共享工作队列-按键驱动
下面这份代码是在一个按键驱动代码，在按键中断服务函数里调度共享队列，最终在工作函数里完成按键值的检测打印。工作队列采用的是共享工作队列。
#include
#include
#include
#include
#include
#include
#include
#include
#include
static struct work_struct work;
static struct m_key_info *key_info_p=NULL;
/*存放按键的信息*/
struct m_key_info
{
int gpio;
char name[50];
int val;
int irq;
};
struct m_key_info key_info[]=
{
{EXYNOS4_GPX3(2),"key_irq_1",0x01},
{EXYNOS4_GPX3(3),"key_irq_2",0x02},
{EXYNOS4_GPX3(4),"key_irq_3",0x03},
{EXYNOS4_GPX3(5),"key_irq_4",0x04},
};
/*
工作函数
*/
static void key_work_func(struct work_struct *work)
{
msleep(50);
//udelay(n);
//mdelay(n);
//msleep(unsigned int msecs);
if(gpio_get_value(key_info_p->gpio)==0) //判断按键是否按下
{
printk("按键值:%#x\n",key_info_p->val);
}
else
{
printk("按键值:%#x\n",key_info_p->val|0x80);
}
}
/*
中断服务函数
*/
static irqreturn_t key_irq_handler(int irq, void *dev)
{
key_info_p=(struct m_key_info*)dev;
/*调度工作----工作结构体添加到系统共享工作队列里*/
schedule_work(&work);
return IRQ_HANDLED;
}
static int __init tiny4412_interrupt_drv_init(void)
{
/*初始化工作*/
INIT_WORK(&work,key_work_func);
int i;
for(i=0;i
3.2 自定义工作队列-按键驱动
工作队列除了可以使用内核共享队列以外，也可以自己创建队列，下面这份代码就演示如何自己创建队列，并完成初始化、调用。代码原型还是一份按键驱动代码，与上面代码相比，加了字符设备节点注册，替换系统共享工作队列为自定义的工作队列。
#include
#include
#include /*杂项设备相关结构体*/
#include /*文件操作集合头文件*/
#include /*使用copy_to_user和copy_from_user*/
#include /*使用IO端口映射*/
#include
#include /*设备*/
#include /*标准字符设备--分配设备号*/
#include /*ioctl操作*/
#include /*注册中断相关*/
#include /*中断边沿类型定义*/
#include /*中断IO口定义*/
#include /*内核定时器相关*/
#include /*等待队列相关*/
#include /*等待队列相关*/
#include /*POLL机制相关*/
#include /*自旋锁相关*/
#include /*自旋锁相关*/
#include /*原子操作相关*/
#include /*原子操作相关*/
#include /*延时函数*/
#include
#include /*信号相关头文件*/
#include /*工作队列相关*/
/*----------------------------------------------------
创建自己的工作队列creator_workqueue测试
-----------------------------------------------------*/
/*定义ioctl的命令*/
#define Cmd_LEDON _IO('L',1) //无方向 --开灯
#define Cmd_LEDOFF _IO('L',0) //无方向 ---关灯
/*定义设备号注册相关*/
static dev_t keydev; //存放设备号
static struct cdev *keyCdev; //定义cdev结构体指针
static struct class *cls; //定义类结构体指针
/*定义按键中断相关*/
static unsigned int irq_buff[4]; /*存放中断编号*/
static int key_value=0; /*存放按键按下的键值*/
/*定时器相关*/
struct timer_list my_timer;
/*全局标志*/
static int poll_flag=0;
struct mutex ; /* 互斥锁 */
/*等待队列相关*/
static DECLARE_WAIT_QUEUE_HEAD(wait);/*初始化等待队列头*/
static int condition=0; /*唤醒队列的条件-为假休眠-为真唤醒*/
/*异步通知助手相关*/
static struct fasync_struct *myfasync;
/*信号量*/
static DEFINE_SEMAPHORE(name_sem);
/*内核工作队列相关结构体*/
static struct work_struct my_work;
/*延时工作队列相关结构体*/
static struct delayed_work my_delay_work;
/*创建自己的工作队列相关*/
struct workqueue_struct *my_work_queue;
struct Buttons_data
{
char key_name[10]; /*按键的名字*/
char key; /*按键值*/
int GPIO; /*GPIO口编号*/
};
/*工作队列的处理函数*/
static void my_work_func(struct work_struct *work)
{
static int count=0;
printk("\n\n用户创建的系统共享工作队列调度成功%d 次\n\n",count++);
}
/*结构体整体赋值*/
static struct Buttons_data Key_interrupt[4]=
{
{"key1",0x01,EXYNOS4_GPX3(2)},
{"key2",0x02,EXYNOS4_GPX3(3)},
{"key3",0x03,EXYNOS4_GPX3(4)},
{"key4",0x04,EXYNOS4_GPX3(5)},
};
/*按键中断服务函数*/
static irqreturn_t irq_handler_function(int irq,void * dat)
{
struct Buttons_data *p =(struct Buttons_data *)dat; /*强制转换*/
if(!gpio_get_value(p->GPIO))
{
key_value=p->key; /*获取按下按键值*/
}
else
{
key_value=p->key|0x80; /*获取松开按键值*/
}
mod_timer(&my_timer,jiffies+1); /*修改超时时间*/
return IRQ_HANDLED;
}
/*定时器中断服务函数*/
static void timer_function(unsigned long data)
{
printk("按键值读取成功!!0x%x--->!\n",key_value);
/*添加延时工作到系统工作队列中等待执行*/
// schedule_delayed_work(&my_delay_work,HZ*5);
//queue_work(my_work_queue,&my_work); /*调度共享工作队列*/
queue_delayed_work_on(-1,my_work_queue,&my_delay_work,HZ*5);
}
static int key_open(struct inode *my_inode, struct file *my_file)
{
unsigned char i;
for(i=0;i<4;i++)
{
//获取中断编号
irq_buff[i]=gpio_to_irq(EXYNOS4_GPX3(2+i));
request_irq(irq_buff[i],irq_handler_function,IRQ_TYPE_EDGE_BOTH,Key_interrupt[i].key_name,&Key_interrupt[i]);
}
/*定时器相关*/
my_timer.expires=0;/*1秒钟*/
my_timer.function=timer_function;/*定时器中断处理函数*/
my_timer.data=888; /*传递给定时器中断服务函数的参数-用于共享定时器*/
init_timer(&my_timer); /*初始化定时器*/
add_timer(&my_timer); /*启动定时器*/
printk("open ok !\n");
return 0;
}
static ssize_t key_read(struct file *my_file, char __user *buf, size_t my_conut, loff_t * my_loff)
{
int error=0;
error=copy_to_user(buf,&key_value,my_conut); /*向应用层拷贝按键值*/
key_value=0;
if(!error)
{
return 0; /*没有读取成功*/
}
else
{
return my_conut; /*返回成功读取的字节数*/
}
}
static ssize_t key_write(struct file *my_file, const char __user *buf, size_t my_conut, loff_t *my_loff)
{
int error;
printk("write ok !\n");
return 1;
}
static long key_unlocked_ioctl(struct file *my_file, unsigned int cmd, unsigned long argv)
{
int dat;
/*只有传递地址的时候才需要转换-----*/
void __user *argv1=(void __user*)argv; //强制转换地址
printk("argv1=%ld\n",*(unsigned long*)argv1); //取出数据
argv=(unsigned long*)argv; /*转为指针形式*/
switch(cmd)
{
case Cmd_LEDON:
dat=100;
copy_to_user(argv,&dat,4);
printk("LEDON_----->OK\n");
break;
case Cmd_LEDOFF:
dat=200;
copy_to_user(argv,&dat,4);
printk("LEDOFF_----->OK\n");
break;
}
return 0;
}
/*poll--*/
unsigned int my_poll(struct file *my_file, struct poll_table_struct * p)
{
/*唤醒休眠的进程*/
poll_wait(my_file,&wait,p);/*添加等待队列--不是立即休眠*/
printk("<1>""8888\n");
if(condition==1)
{
printk("drive----poll ----ok!\n");
condition=0; /*清除标志*/
return POLLIN; /*返回事件*/
}
return 0; /*返回事件*/
}
/*异步通知助手*/
int key_fasync(int fd, struct file *my_file,int on) //异步通知
{
int error;
printk("驱动层收到的文件描述符:%d\n",fd);
error=fasync_helper(fd,my_file,on,&myfasync);
printk("驱动层异步通知结构体文件描述符:%d\n",myfasync->fa_fd);
return error;
}
static int key_release(struct inode *my_inode, struct file *my_file)
{
int i;
//释放中断
for(i=0;i<4;i++)
{
free_irq(irq_buff[i],&Key_interrupt[i]);
}
return 0;
}
/*定义一个文件操作集合结构体*/
static struct file_operations ops_key={
.owner = THIS_MODULE,
.read=key_read, /*读函数-被应用层read函数调用*/
.write=key_write, /*写函数-被应用层write函数调用*/
.open=key_open, /*打开函数-被应用层open函数调用*/
.release=key_release, /*释放函数*/
.unlocked_ioctl=key_unlocked_ioctl, /*ioctl操作*/
.poll=my_poll, /*poll机制*/
.fasync=key_fasync, /*异步通知助手*/
};
static int __init key_init1(void)
{
/*动态分配一个设备号*/
alloc_chrdev_region(&keydev,0,1,"mykey"); //我们可以读取/proc/devices文件以获得Linux内核分配给设备的主设备号和设备名字
/*动态分配cdev结构体,返个cdev结构;如果执行失败,将返回NULL。*/
keyCdev = cdev_alloc();
/*初始化Cdev结构体*/
cdev_init(keyCdev,&ops_key);
/*注册Cdev结构体*/
cdev_add(keyCdev,keydev,1);
/*创建类*/
cls=class_create(THIS_MODULE,"my_key");
/*在类下面创建设备*/
device_create(cls,NULL,keydev,NULL,"my_delaywork");// /dev/
/*创建自己的工作队列*/
my_work_queue =create_workqueue("my_workqueue");
/*初始化延时工作队列*/
INIT_DELAYED_WORK(&my_delay_work,my_work_func);
/*初始化无延时的工作队列*/
// INIT_WORK(&my_work,my_work_func);
printk("<1>""key drive init OK!!-->__FILE__=%s __LINE__=%d\n",__FILE__,__LINE__);
return 0;
}
//KERN_EMERG
static void __exit key_exit(void)
{
device_destroy(cls,keydev); //注销设备节点
class_destroy(cls); //注销分配的类
cdev_del(keyCdev); //注销CDEV结构体
unregister_chrdev_region(keydev,1); //注销设备
kfree(keyCdev); //释放结构体
printk("<1>""key drive exit OK!! -->__FILE__=%s __LINE__=%d\n",__FILE__,__LINE__);
}
//EXPORT_SYMBOL(key_init);
module_init(key_init1); /*驱动入口*/
module_exit(key_exit); /*驱动出口*/
MODULE_LICENSE("GPL");
(key_info)>(key_info)/sizeof(key_info[0]);i++)>
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。
举报投诉
评论(0)
发评论
-
jf_41003878
2022-11-11
0 回复 举报能帮我看看我的cc2530大作业的嘛 收起回复
-
jf_41003878
2022-11-11
0 回复 举报哥 收起回复
-
芯灵思SinlinxA33开发板Linux内核workqueue(附实测代码)2019-02-18 0
-
内核工作队列workqueue简单使用2019-06-11 0
-
如何使用RT-Thread系统中的工作队列 ( workqueue )呢2022-06-22 0
-
Android的Linux内核与驱动程序开发教程2011-09-05 2913
-
linux kernel工作队列及源码解析2017-10-27 877
-
《Linux设备驱动开发详解》第4章、Linux内核模块2017-10-27 1081
-
linux kernel工作队列及源码详细讲解2017-11-30 613
-
基于Linux 软中断机制以及tasklet、工作队列机制分析2018-01-15 3905
-
你知道linux的工作队列？2019-04-26 1115
-
你了解过Linux内核的的tasklet机制和工作队列？2019-05-14 2725
-
干货：Linux内核中等待队列的四个用法2020-06-20 2850
-
利用Linux开发板为TLV320ADC5120开发Linux内核驱动的方法2022-10-28 512
-
Liteos-a内核工作队列的实现原理分析及经验总结——芯海科技PPG芯片CS1262接入OpenHarmony实战2022-04-26 2133
-
Linux 6.9-rc1发布，加入定时器、工作队列及AMD P-State优化2024-03-25 454
-
linux驱动程序如何加载进内核2024-08-30 474
全部0条评论
快来发表一下你的评论吧 !
