include/workqueue.h

Go to the documentation of this file.

#ifndef WORKQUEUE_H_INCLUDED
#define WORKQUEUE_H_INCLUDED

#include <types.h>
#include <slist.h>
#include <util.h>
#include <interrupt.h>

struct workqueue_task;

typedef void (*workqueue_func_t)(struct workqueue_task *task);

struct workqueue_task {
        workqueue_func_t        worker; 
        struct slist_node       node;   
};

struct workqueue
{
        struct slist            task_list;      
};


#ifdef __cplusplus
extern "C" {
#endif

extern struct workqueue main_workqueue;

static inline void workqueue_init(struct workqueue *queue)
{
        /* Sanity check on parameters. */
        assert(queue);

        /* Initialize to an empty state, ready for data. */
        slist_init(&queue->task_list);
}

static inline void workqueue_task_set_work_func(struct workqueue_task *task,
                workqueue_func_t worker_func)
{
        task->worker = worker_func;
}

static inline void workqueue_task_init(struct workqueue_task *task,
                workqueue_func_t worker_func)
{
        /* Flag the item as ready for use by clearing next pointer */
        task->node.next = NULL;

        workqueue_task_set_work_func(task, worker_func);
}

static inline bool workqueue_is_empty(struct workqueue *queue)
{
        /* Sanity check on parameters. */
        assert(queue);

        return slist_is_empty(&queue->task_list);
}

static inline bool workqueue_task_is_queued(struct workqueue_task *task)
{
        return task->node.next != NULL;
}

extern bool workqueue_add_task(struct workqueue *queue,
                struct workqueue_task *task);

static inline struct workqueue_task *workqueue_pop_task(
                struct workqueue *queue)
{
        struct workqueue_task   *task = NULL;

        /* Sanity check on parameters. */
        assert(queue);

        assert(!cpu_irq_is_enabled());

        if (!workqueue_is_empty(queue)) {
                task = slist_pop_head(&queue->task_list,
                                struct workqueue_task, node);
                /* Flag the item as ready for use by clearing next pointer */
                task->node.next = NULL;
        }

        return task;
}

static inline void workqueue_run_task(struct workqueue_task *task)
{
        task->worker(task);
}


struct nested_workqueue {
        struct workqueue        wq;
        struct workqueue_task   *current;
};

static inline void nested_workqueue_init(struct nested_workqueue *wq)
{
        wq->current = NULL;
        workqueue_init(&wq->wq);
}

extern bool nested_workqueue_add_task(struct nested_workqueue *wq,
                struct workqueue_task *task);
extern void nested_workqueue_next_task(struct nested_workqueue *wq);


#ifdef __cplusplus
} /* extern "C" */
#endif


#endif /* WORKQUEUE_H_INCLUDED */

---