linux驱动开发--中断：工作者队列实现中断底半部

p 1、工作队列 /p p 工作队列(work queue)是linux kernel中将工作推后执行的一种机制；这种机制和tasklet不同之处在于工作队列是把推后的工作交由一个内核线程去执行，因此工作队列的优势就在于它允许重新调度甚至睡眠。 br /p p 工作队列数据类型定义，在 linux/workqueue.h 中 br /p pre code

1、工作队列

工作队列(work queue)是linux kernel中将工作推后执行的一种机制；这种机制和tasklet不同之处在于工作队列是把推后的工作交由一个内核线程去执行，因此工作队列的优势就在于它允许重新调度甚至睡眠。

工作队列数据类型定义，在 linux/workqueue.h 中

struct work_struct{

atomic_long_t data;//记录工作状态和指向工作者线程的指针

struct list_head entry;//工作数据链成员

work_func_t func;//工作处理函数，由用户实现

}

typedef void (*work_func_t)(struct work_struct *work);//工作函数原型

struct delayed_work{//处理延迟执行的工作的结构体

struct work_struct work;//工作结构体

struct timer_list timer;//推后执行的定时器

}

工作队列操作：
初始化工作
INIT_WORK(struct work_struct *work, work_func_t func);初始化工作队列并制定工作队列处理函数
INIT_DELAYED_WORK(struct delayed_work *work, work_func_t func);初始化延迟工作队列并制定工作队列处理函数
调度工作
int schedule_work(struct work_struct *work);调度工作，即把工作处理函数提交给缺省的工作队列和工作者线程
int schedule_delayed_work(struct delayed_work *work, unsigned long delay);调度延迟工作，即把工作处理函数提交给缺省的工作队列和工作者线程，并制定延迟时间（同内核定时器延迟处理）
刷新工作队列
void flush_schedule_work(void);刷新缺省工作队列，此函数会一直等待，知道队列中的所有工作都被执行完成
取消延迟工作
int cancel_delayed_work(struct delay_work *work);取消缺省工作队列中处于等待状态的延迟工作
取消工作
int cancel_work_sync(struct work_struct *work);取消缺省工作队列中处于等待状态的工作，如果工作处理函数已经开始执行，该函数会阻塞直到工作处理函数完成
工作者线程
工作者线程本质上是一个普通的内核线程，在默认情况下，每个cpu均有一个类型为“events“的工作者线程，当调用schedule_work时，这个工作者线程会被唤醒去执行工作链表上的所有工作。

创建工作队列
struct workqueue_struct *create_workqueue(const char *name);创建新的工作队列和相应的工作者线程，name用于该内核线程的命名
调度工作
int queue_work(struct workqueue_struct *wq, struct work_struct *work);调度工作，类似于schedule_work()函数；将制定工作work提交给指定工作队列wq
调度延迟工作
int queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay);调度工作，类似于schedule_work()函数,将指定延迟工作work提交给指定工作队列wq,并指定延迟时间(同内核定时器延迟处理)
刷新工作队列
void flush_workqueue(struct workqueue_struct *wq);刷新指定工作队列wq,此函数会一直等待，直到队列中所有工作都被执行完成
销毁工作队列
void destroy_workqueue(struct workqueue_struct *wq);销毁指定工作队列wq

/**

*Copyright (c) 2013.TianYuan

*All rights reserved.

*文件名称: irq.c

*文件标识: 工作者队列实现，登记底半部

*make menuconfig--- device drivers 

*input keyboards ---s3c gpio keypad supports

#cat /proc/interrupts : 32(中断号) :intertupt_demo

*当前版本：1.0

*作者：wuyq 

*取代版本：xxx

*原作者：xxx

*完成日期：2014-03-05

#include linux/init.h 

#include linux/module.h 

#include linux/fs.h 

#include linux/cdev.h 

#include linux/device.h 

#include linux/slab.h 

#include asm/uaccess.h 

#include asm/gpio.h 

#include plat/gpio-cfg.h 

#include linux/spinlock_types.h 

#include linux/sched.h 

#include linux/poll.h 

#include linux/interrupt.h 


 pcdevp = container_of(inode- i_cdev, struct cdd_cdev, cdev);

 printk("led = %d\n", pcdevp- led);

 /*获取信号量*/

 //down获取信号量不成功，会导致进程睡眠（第3个进程的时候）

 //down( pcdevp- sem_open);

 if(down_interruptible( pcdevp- sem_open) 0){

 return -1;

 filp- private_data = pcdevp;

 //申请gpio管脚

 gpio_request(led_gpio_table[0], "GPC1_3");

 gpio_request(led_gpio_table[1], "GPC1_4");

 return 0;

int cdd_read(struct file *filp, char __user *buf, size_t count, loff_t *offset)

 int ret = 0;

 u32 pos = *offset;

 u32 cnt = count;

 struct cdd_cdev *cdevp = filp- private_data;

#if 0

 //定义并初始化一个等待队列

 DECLARE_WAITQUEUE(wq, current);

 //将等待队列添加到wqh指向的链表

 add_wait_queue( pcdevp- wqh, wq);

 //判断设备有没有数据供用户空间读,假设led不为0，表示有数据供用户空间读取

 if(pcdevp- led == 0){

 printk("no data for reading! sleep...\n");

 //设置当前线程为睡眠状态

 set_current_state(TASK_INTERRUPTIBLE);

 schedule();//内核调度cpu的算法

 printk("have data for reading!\n");

 //从指定的链表中删除等待队列

 remove_wait_queue( pcdevp- wqh, wq);

#endif

 wait_event_interruptible(pcdevp- wqh, pcdevp- led != 0); 

 //printk("enter cdd_read!\n");

 if(cnt (cdevp- data_len-pos) ){

 cnt = cdevp- data_len - pos;

 ret = copy_to_user(buf, cdevp- kbuf+pos, cnt);

 //printk("kernel kbuf content:%s\n", cdevp- kbuf);

 *offset += cnt;

 pcdevp- led = 0;

 return ret;

int cdd_write(struct file *filp, const char __user *buf, size_t count, loff_t *offset)

 int ret = 0;

 struct cdd_cdev *cdevp = filp- private_data;

 u32 pos = *offset;

 u32 cnt = count;

 //printk("enter cdd_write!\n");

 if(cnt (BUF_SIZE - pos) ){

 cnt = BUF_SIZE - pos;

 ret = copy_from_user(cdevp- kbuf+pos, buf, cnt);

 *offset += cnt;

 if(*offset cdevp- data_len){

 cdevp- data_len = *offset;

 pcdevp- led = 1;

 //唤醒等待队列头中的一个等待队列

 wake_up_interruptible( pcdevp- wqh);


int cdd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data)

 //printk("enter cdd_ioctl!\n");

 switch(cmd){

 case 1://点亮灯

 //设置管脚为输出功能

 //参数：1.要设置的管脚编号2.默认的输出值 0低电平1高电平

 gpio_direction_output(led_gpio_table[data], 0);

 //禁止内部上拉

 s3c_gpio_setpull(led_gpio_table[data], SEC_GPIO_PULL_NONE);

 //设置输出值

 gpio_set_value(led_gpio_table[data], 1);

 break;

 case 0://熄灭灯

 //设置管脚为输出功能

 //参数：1.要设置的管脚编号2.默认的输出值 0低电平1高电平

 gpio_direction_output(led_gpio_table[data], 0);

 //禁止内部上拉

 s3c_gpio_setpull(led_gpio_table[data], SEC_GPIO_PULL_NONE);

 //设置输出值

 gpio_set_value(led_gpio_table[data], 0);

 break;

 default:

 return -EINVAL;


 dev = MKDEV(CDD_MAJOR, CDD_MINOR);//生成设备号

 //注册设备号;1、要注册的起始设备号2、连续注册的设备号个数3、名字

 ret = register_chrdev_region(dev, CDD_COUNT, "cdd_demo");

 }else{

 // 动态分配设备号

 ret = alloc_chrdev_region( dev, cdd_minor, CDD_COUNT, "cdd_demo02");

 if(ret 0){

 printk("register_chrdev_region failed!\n");

 goto failure_register_chrdev;

 //获取主设备号

 cdd_major = MAJOR(dev);

 printk("cdd_major = %d\n", cdd_major);

 cdd_cdevp = kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT, GFP_KERNEL);

 if(IS_ERR(cdd_cdevp)){

 printk("kzalloc failed!\n");

 goto failure_kzalloc;

 /*创建设备类*/

 dev_class = class_create(THIS_MODULE, "cdd_class");

 if(IS_ERR(dev_class)){

 printk("class_create failed!\n");

 goto failure_dev_class;

 for(i=0; i CDD_COUNT; i++){

 /*初始化cdev*/

 cdev_init( (cdd_cdevp[i].cdev), cdd_fops);

 /*添加cdev到内核*/

 cdev_add( (cdd_cdevp[i].cdev), dev+i, 1);

 /* “/dev/xxx” */

 device_create(dev_class, NULL, dev+i, NULL, "cdd%d", i);

 cdd_cdevp[i].led = i;

 //初始化等待队列头

 init_waitqueue_head( cdd_cdevp[i].wqh);

 //初始化work

 INIT_WORK( cdd_work, cdd_work_func);

 //注册中断

 request_irq(IRQ_EINT0, cdd_isr, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "interrupt_demo", NULL);

 return 0;

failure_dev_class:

 kfree(cdd_cdevp);

failure_kzalloc:

 unregister_chrdev_region(dev, CDD_COUNT);

failure_register_chrdev:

 return ret;

void __exit cdd_exit(void)

/*逆序消除*/

 int i = 0;

 flush_work( cdd_work);

 free_irq(IRQ_EINT0, NULL);

 for(; i CDD_COUNT; i++){

 device_destroy(dev_class, dev+i);

 cdev_del( (cdd_cdevp[i].cdev));

 //cdev_del( ((cdd_cdevp+i)- cdev));

 class_destroy(dev_class);

 kfree(cdd_cdevp);

 unregister_chrdev_region(dev, CDD_COUNT);

module_init(cdd_init);

module_exit(cdd_exit);