工作队列的使用例子

 

工作队列（work queue ）是另外一种将工作推后执行的形式.
Linux 2.6内核使用了不少工作队列来处理任务，他在使用上和 tasklet最大的不同是工作队列的函数可以使用休眠，而tasklet的函数是不允许使用休眠的。
工作队列的使用又分两种情况，一种是利用系统共享的工作队列来添加自己的工作，这种情况处理函数不能消耗太多时间，这样会影响共享队列中其他任务的处理；另外一种是创建自己的工作队列并添加工作。
工作、工作队列和工作者线程
我们把推后执行的任务叫做工作（work），描述它的数据结构为work_struct，这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue_struct，而工作线程就是负责执行工作队列中的工作。系统默认的工作者线程为events,自己也可以创建自己的工作者线程。

 

 

（一）利用系统共享的工作队列添加工作：
第一步：声明或编写一个工作处理函数
void my_func();

第二步：创建一个工作结构体变量，并将处理函数和参数的入口地址赋给这个工作结构体变量
DECLARE_WORK(my_work,my_func,&data); //编译时创建名为my_work的结构体变量并把函数入口地址和参数地址赋给它；

如果不想要在编译时就用DECLARE_WORK()创建并初始化工作结构体变量，也可以在程序运行时再用INIT_WORK()创建
struct work_struct my_work; //创建一个名为my_work的结构体变量，创建后才能使用INIT_WORK()
INIT_WORK(&my_work,my_func,&data); //初始化已经创建的my_work，其实就是往这个结构体变量中添加处理函数的入口地址和data的地址，通常在驱动的open函数中完成

第三步：将工作结构体变量添加入系统的共享工作队列
schedule_work(&my_work); //添加入队列的工作完成后会自动从队列中删除
my_work马上就会被调度，一旦其所在的处理器上的工作者线程被唤醒，它就会被执行。
或
有时候并不希望工作马上就被执行，而是希望它经过一段延迟以后再执行。在这种情况下，可以调度它在指定的时间执行：
schedule_delayed_work(&my_work,tick); //延时tick个滴答后再提交工作
这时，&my_work指向的work_struct直到delay指定的时钟节拍用完以后才会执行。

(二)创建自己的工作队列来添加工作
第一步：声明工作处理函数和一个指向工作队列的指针
void my_func();
struct workqueue_struct *p_queue;

第二步：创建自己的工作队列和工作结构体变量（通常在open函数中完成）
p_queue=create_workqueue("my_queue"); //创建一个名为my_queue的工作队列并把工作队列的入口地址赋给声明的指针（它有一个专用的线程在系统的每一个处理器上）

或

p_queue=create_singlethread_workqueue("my_queue"); //创建单个工作者线程

struct work_struct my_work;
INIT_WORK(&my_work,my_func,&data); //创建一个工作结构体变量并初始化，和第一种情况的方法一样

第三步：将工作添加入自己创建的工作队列等待执行
queue_work(p_queue,＆my_work);
//作用与schedule_work()类似，不同的是将工作添加入p_queue指针指向的工作队列而不是系统共享的工作队列

第四步：删除自己的工作队列
destroy_workqueue(p_queue); //一般是在close函数中删除
 
(三）工作队列应用例子1
 1，定义工作结构体类型和一个指向工作队列的指针
struct akm8976_data {
 struct input_dev *input_dev;
 struct work_struct work;
};//定义结构类型
static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
 init_waitqueue_head(&data_ready_wq);
 
 2，声明或编写一个工作处理函数
static void akm_work_func(struct work_struct *work)
{
 if (AKECS_GetData() < 0)
  printk(KERN_ERR "AKM8976 akm_work_func: Get data failed/n");
 enable_irq(this_client->irq);
}
//处理函数的实现，唤醒工作队列
 
3，初始化已经创建的工作结构体变量akm->work
static int akm8976_probe(
 struct i2c_client *client, const struct i2c_device_id *id)
{;
 struct akm8976_data *akm;   //定义结构变量akm
;
 INIT_WORK(&akm->work, akm_work_func);  //初始化已经创建的工作结构体变量akm->work，其实就是往这个结构体变量中添加处理函数的入口
                                                                        //为akm_work_func
;
}
 

 4，将工作data->work添加入自己创建的工作队列等待系统默认的工作者线程events执行
 
static irqreturn_t akm8976_interrupt(int irq, void *dev_id)
{
 struct akm8976_data *data = dev_id;
 disable_irq(this_client->irq);
 schedule_work(&data->work);
 return IRQ_HANDLED;
}
 
//硬件中断处理函数，schedule_work(&data->work); //data->work马上就会被调度，一旦其所在的处理器上的工作者线程被唤醒，它就会被执行。（系统默认的工作者线程events执行工作队列中的工作data->work）
 
 
 
(四）工作队列应用例子2
 1，定义工作结构体类型
struct ds1374 {
 struct i2c_client *client;
 struct rtc_device *rtc;
 struct work_struct work;
 /* The mutex protects alarm operations, and prevents a race
  * between the enable_irq() in the workqueue and the free_irq()
  * in the remove function.
  */
 struct mutex mutex;
 int exiting;
};定义结构类型
 
 2，声明或编写一个工作处理函数
static void ds1374_work(struct work_struct *work)
{
 struct ds1374 *ds1374 = container_of(work, struct ds1374, work);
 struct i2c_client *client = ds1374->client;
 int stat, control;
 mutex_lock(&ds1374->mutex);
 stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
 if (stat < 0)
  return;
 if (stat & DS1374_REG_SR_AF) {
  stat &= ~DS1374_REG_SR_AF;
  i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);
  control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
  if (control < 0)
   goto out;
  control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
  i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
  /* rtc_update_irq() assumes that it is called
   * from IRQ-disabled context.
   */
  local_irq_disable();
  rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF);
  local_irq_enable();
 }
out:
 if (!ds1374->exiting)
  enable_irq(client->irq);
 mutex_unlock(&ds1374->mutex);
}
//处理函数的实现，
3，初始化已经创建的工作结构体变量akm->work
static int ds1374_probe(struct i2c_client *client,
   const struct i2c_device_id *id)
{
;
 INIT_WORK(&ds1374->work, ds1374_work);
}
 INIT_WORK(&akm->work, akm_work_func);  //初始化已经创建的工作结构体变量ds1374->work，其实就是往这个结构体变量中添加处理函数的入口
                                                                        //为ds1374_work
;
}
 

 4，将工作data->work添加入自己创建的工作队列等待系统默认的工作者线程events执行
 
static irqreturn_t ds1374_irq(int irq, void *dev_id)
{
 struct i2c_client *client = dev_id;
 struct ds1374 *ds1374 = i2c_get_clientdata(client);
 disable_irq_nosync(irq);
 schedule_work(&ds1374->work);
 return IRQ_HANDLED;
}
 
//硬件中断处理函数，schedule_work(&ds1374->work); //ds1374->work马上就会被调度，一旦其所在的处理器上的工作者线程被唤醒，它就会被执行。（系统默认的工作者线程events执行工作队列中的工作ds1374->work）
 
 （五）工作队列例子3（自己的工作队列）
synaptics_tm1400_i2c_rmi.c
5.1，定义工作结构体类型和一个指向工作队列的指针
static struct workqueue_struct *synaptics_wq;//指向工作队列的指针
struct synaptics_ts_data {
 uint16_t addr;
 struct i2c_client *client;
 struct input_dev *input_dev;
 int use_irq;
 struct hrtimer timer;
 struct work_struct  work;
 uint16_t max[2];
 int snap_state[2][2];
 int snap_down_on[2];
 int snap_down_off[2];
 int snap_up_on[2];
 int snap_up_off[2];
 int snap_down[2];
 int snap_up[2];
 uint32_t flags;
 int (*power)(int on);
 struct early_suspend early_suspend;
};
5.2 ，编写一个工作处理函数
 static void synaptics_ts_work_func(struct work_struct *work)
{
；
}
 5.3,创建自己的工作队列
static int __devinit synaptics_ts_init(void)
{
 synaptics_wq = create_singlethread_workqueue("synaptics_wq");
 if (!synaptics_wq)
  return -ENOMEM;
 return i2c_add_driver(&synaptics_ts_driver);
}
 
 5.4,创建自己的工作结构体变量
static int synaptics_ts_probe(
 struct i2c_client *client, const struct i2c_device_id *id)
{
;
 INIT_WORK(&ts->work, synaptics_ts_work_func);
;
}
 
 
5.5 将工作添加入自己创建的工作队列等待执行
//作用与schedule_work()类似，不同的是将工作添加入p_queue指针指向的工作队列而不是系统共享的工作队列
 static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
{
 struct synaptics_ts_data *ts = dev_id;
 /* printk("synaptics_ts_irq_handler/n"); */
 disable_irq(ts->client->irq);
 queue_work(synaptics_wq, &ts->work);
 return IRQ_HANDLED;
}

5.6 删除自己的工作队列
static void __exit synaptics_ts_exit(void)
{
 i2c_del_driver(&synaptics_ts_driver);
 if (synaptics_wq)
  destroy_workqueue(synaptics_wq);
}