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>

typedef void (*workqueue_callback_t)(void *data);

struct workqueue_item
{
        workqueue_callback_t callback;  
        void *data;                    
        struct slist_node node;        
};

struct workqueue
{
        struct slist list;             
};


#ifdef __cplusplus
extern "C" {
#endif


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->list);
}

static inline void workqueue_init_item(
                struct workqueue_item *item,
                workqueue_callback_t callback,
                void *data)
{
        /* Flag the item as ready for use by clearing next pointer */
        item->node.next = NULL;

        item->callback = callback;
        item->data = data;
}

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

        return slist_is_empty(&queue->list);
}

static inline bool workqueue_item_is_queued(struct workqueue_item *item)
{
        return item->node.next != NULL;
}

static inline void workqueue_add_item(
                struct workqueue *queue,
                struct workqueue_item *item)
{
        unsigned long iflags;

        /* Sanity check on parameters. */
        assert(queue);
        assert(item);
        /* We will run this later, so check that it is valid */
        assert(item->callback);
        /* If the next pointer is set, the item is in use */
        assert(item->node.next == NULL);

        iflags = cpu_irq_save();
        slist_insert_tail(&queue->list, &item->node);
        cpu_irq_restore(iflags);
}

static inline void workqueue_add_item_safe(
                struct workqueue *queue,
                struct workqueue_item *item)
{
        unsigned long iflags;

        /* Sanity check on parameters. */
        assert(queue);
        assert(item);
        /* We will run this later, so check that it is valid */
        assert(item->callback);

        iflags = cpu_irq_save();
        if (!workqueue_item_is_queued(item))
                slist_insert_tail(&queue->list, &item->node);
        cpu_irq_restore(iflags);
}

static inline struct workqueue_item *workqueue_remove_item(
                struct workqueue *queue)
{
        struct workqueue_item *item;
        unsigned long iflags;

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

        iflags = cpu_irq_save();
        if (!workqueue_is_empty(queue)) {
                item = slist_pop_head(&queue->list, struct workqueue_item, node);
                /* Flag the item as ready for use by clearing next pointer */
                item->node.next = NULL;
        } else {
                item = NULL;
        }
        cpu_irq_restore(iflags);

        return item;
}

inline static void workqueue_move_item(
                struct workqueue *source,
                struct workqueue *dest)
{
        /* Sanity check on parameters. */
        assert(source);
        assert(dest);

        /* Move work between queues. */
        workqueue_add_item(dest, workqueue_remove_item(source));
}

inline static void *workqueue_get_data(struct workqueue_item *item)
{
        assert(item);

        return item->data;
}


inline static void workqueue_do_one_item(struct workqueue *queue)
{
        struct workqueue_item *item;

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

        /* Get work and dispatch */
        item = workqueue_remove_item(queue);
        if (item)
                item->callback(workqueue_get_data(item));
}


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


#endif /* WORKQUEUE_H_INCLUDED */

---