feat: add lab-rv32i-freertos-mutex card

include/freertos/mutex.hpp

@@ -0,0 +1,106 @@
+#ifndef FREERTOS_CPP_MUTEX_HPP
+#define FREERTOS_CPP_MUTEX_HPP
+
+#include <type_traits>
+
+extern "C"
+{
+#include "FreeRTOS.h"
+#include "semphr.h"
+#include "task.h"
+}
+
+namespace freertos
+{
+
+struct StaticMutexStorage final
+{
+    StaticSemaphore_t control {};
+};
+
+class Mutex final
+{
+public:
+    explicit Mutex( StaticMutexStorage & storage ) noexcept
+        : handle_ { xSemaphoreCreateMutexStatic( &storage.control ) }
+    {
+    }
+
+    ~Mutex() noexcept
+    {
+        if( handle_ != nullptr )
+        {
+            vSemaphoreDelete( handle_ );
+        }
+    }
+
+    Mutex( const Mutex & ) = delete;
+    Mutex & operator=( const Mutex & ) = delete;
+    Mutex( Mutex && ) = delete;
+    Mutex & operator=( Mutex && ) = delete;
+
+    [[nodiscard]] bool valid() const noexcept { return handle_ != nullptr; }
+
+    [[nodiscard]] bool lock( TickType_t timeout ) noexcept
+    {
+        return handle_ != nullptr &&
+               xSemaphoreTake( handle_, timeout ) == pdPASS;
+    }
+
+    [[nodiscard]] bool unlock() noexcept
+    {
+        return handle_ != nullptr && xSemaphoreGive( handle_ ) == pdPASS;
+    }
+
+    [[nodiscard]] TaskHandle_t owner() const noexcept
+    {
+        return handle_ == nullptr ? nullptr :
+            xSemaphoreGetMutexHolder( handle_ );
+    }
+
+    [[nodiscard]] SemaphoreHandle_t native_handle() const noexcept
+    {
+        return handle_;
+    }
+
+private:
+    SemaphoreHandle_t handle_ {};
+};
+
+template< typename Lockable >
+class LockGuard final
+{
+public:
+    explicit LockGuard( Lockable & lockable, TickType_t timeout ) noexcept
+        : lockable_ { &lockable }, owns_ { lockable.lock( timeout ) }
+    {
+    }
+
+    ~LockGuard() noexcept
+    {
+        if( owns_ )
+        {
+            ( void ) lockable_->unlock();
+        }
+    }
+
+    LockGuard( const LockGuard & ) = delete;
+    LockGuard & operator=( const LockGuard & ) = delete;
+    LockGuard( LockGuard && ) = delete;
+    LockGuard & operator=( LockGuard && ) = delete;
+
+    [[nodiscard]] bool owns_lock() const noexcept { return owns_; }
+
+private:
+    Lockable * const lockable_;
+    const bool owns_;
+};
+
+static_assert( !std::is_copy_constructible< Mutex >::value );
+static_assert( !std::is_move_constructible< Mutex >::value );
+static_assert( !std::is_copy_constructible< LockGuard< Mutex > >::value );
+static_assert( !std::is_move_constructible< LockGuard< Mutex > >::value );
+
+} // namespace freertos
+
+#endif