BlockOrWakeUp.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_BLOCKORWAKEUP_HXX_
#define _FREERTOS_DRIVERS_COMMON_BLOCKORWAKEUP_HXX_
 
#include "os/OS.hxx"
#include "executor/Notifiable.hxx"
 
template <class Critical> class BlockOrWakeUp : protected Critical
{
public:
    template <class T>
    BlockOrWakeUp(const T &t)
        : Critical(t)
        , notifiable_(nullptr)
    {
    }
 
    class LockHolder;
    class CriticalHolder;
    friend class LockHolder;
    friend class CriticalHolder;
 
    struct CriticalHolder
    {
        ~CriticalHolder()
        {
            if (parent_)
                parent_->unlock();
        }
 
        CriticalHolder(CriticalHolder &&o)
            : parent_(o.parent_)
        {
            o.parent_ = nullptr;
        }
 
    private:
        friend class LockHolder;
        CriticalHolder(BlockOrWakeUp<Critical> *parent)
            : parent_(parent)
        {
            parent_->lock();
        }
 
        BlockOrWakeUp<Critical> *parent_;
    };
 
    struct LockHolder
    {
        LockHolder(BlockOrWakeUp<Critical> *parent)
            : parent_(parent)
        {
            parent_->single_lock();
        }
 
        LockHolder(LockHolder &&o)
            : parent_(o.parent_)
        {
            o.parent_ = nullptr;
        }
 
        ~LockHolder()
        {
            if (parent_)
            {
                parent_->single_unlock();
            }
        }
 
        CriticalHolder critical() __attribute__((warn_unused_result))
        {
            auto h = CriticalHolder(parent_);
            return h;
        }
 
        void wait_for_notification()
        {
            parent_->single_unlock();
            parent_->s_.wait();
            parent_->single_lock();
        }
 
        void notify_next()
        {
            parent_->s_.post();
            Notifiable* n = nullptr;
            if (parent_->notifiable_) {
                n = parent_->notifiable_;
                parent_->notifiable_ = nullptr;
            }
            parent_->single_unlock();
            parent_ = nullptr;
            if (n) n->notify();
        }
 
    private:
        DISALLOW_COPY_AND_ASSIGN(LockHolder);
 
        BlockOrWakeUp<Critical> *parent_;
    };
 
    LockHolder holder() __attribute__((warn_unused_result)) {
        return LockHolder(this);
    }
 
    void notify_from_isr()
    {
        int woken = 0;
        s_.post_from_isr(&woken);
        if (notifiable_) {
            notifiable_->notify_from_isr();
            notifiable_ = nullptr;
        }
        os_isr_exit_yield_test(true);
    }
 
    Notifiable* register_notifiable(Notifiable *n)
    {
        Notifiable *r = notifiable_;
        notifiable_ = n;
        return r;
    }
 
private:
    void single_lock()
    {
        m_.lock();
    }
    void single_unlock()
    {
        m_.unlock();
    }
 
    OSMutex m_;
    OSSem s_;
    Notifiable *notifiable_;
};
 
#endif // _FREERTOS_DRIVERS_COMMON_BLOCKORWAKEUP_HXX_