sync.h

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#ifndef OVE_SYNC_H
#define OVE_SYNC_H
 
#include "ove/types.h"
#include "ove_config.h"
#include "ove/storage.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef CONFIG_OVE_SYNC
 
/* =========================================================================
 * Mutex — _init / _deinit (static storage)
 * ========================================================================= */
 
int  ove_mutex_init(ove_mutex_t *mtx, ove_mutex_storage_t *storage);
 
void ove_mutex_deinit(ove_mutex_t mtx);
 
/* =========================================================================
 * Semaphore — _init / _deinit (static storage)
 * ========================================================================= */
 
int  ove_sem_init(ove_sem_t *sem, ove_sem_storage_t *storage,
          unsigned int initial, unsigned int max);
 
void ove_sem_deinit(ove_sem_t sem);
 
/* =========================================================================
 * Binary event — _init / _deinit (static storage)
 * ========================================================================= */
 
int  ove_event_init(ove_event_t *evt, ove_event_storage_t *storage);
 
void ove_event_deinit(ove_event_t evt);
 
/* =========================================================================
 * Recursive mutex — _init (static storage)
 * ========================================================================= */
 
int  ove_recursive_mutex_init(ove_mutex_t *mtx,
                  ove_mutex_storage_t *storage);
 
/* =========================================================================
 * Condition variable — _init / _deinit (static storage)
 * ========================================================================= */
 
int  ove_condvar_init(ove_condvar_t *cv,
              ove_condvar_storage_t *storage);
 
void ove_condvar_deinit(ove_condvar_t cv);
 
/* =========================================================================
 * Heap-gated _create / _destroy variants
 * ========================================================================= */
 
#ifdef OVE_HEAP_SYNC
 
int  ove_mutex_create(ove_mutex_t *mtx);
 
void ove_mutex_destroy(ove_mutex_t mtx);
 
int  ove_sem_create(ove_sem_t *sem, unsigned int initial,
            unsigned int max);
 
void ove_sem_destroy(ove_sem_t sem);
 
int  ove_event_create(ove_event_t *evt);
 
void ove_event_destroy(ove_event_t evt);
 
int  ove_recursive_mutex_create(ove_mutex_t *mtx);
 
void ove_recursive_mutex_destroy(ove_mutex_t mtx);
 
int  ove_condvar_create(ove_condvar_t *cv);
 
void ove_condvar_destroy(ove_condvar_t cv);
 
#elif !defined(__ZIG_CIMPORT__) /* !OVE_HEAP_SYNC — zero-heap mode */
 
/* Unified _create/_destroy macros — auto-generate static storage per call site.
 * Each call site produces exactly one kernel object.  Do not call in a loop
 * to create multiple independent objects; use _init() with separate storage. */
#define ove_mutex_create(phandle) \
    ({ static ove_mutex_storage_t _ove_stor_; \
       ove_mutex_init((phandle), &_ove_stor_); })
#define ove_mutex_destroy(mtx) ove_mutex_deinit(mtx)
 
#define ove_sem_create(psem, initial, max) \
    ({ static ove_sem_storage_t _ove_stor_; \
       ove_sem_init((psem), &_ove_stor_, (initial), (max)); })
#define ove_sem_destroy(sem) ove_sem_deinit(sem)
 
#define ove_event_create(pevt) \
    ({ static ove_event_storage_t _ove_stor_; \
       ove_event_init((pevt), &_ove_stor_); })
#define ove_event_destroy(evt) ove_event_deinit(evt)
 
#define ove_recursive_mutex_create(phandle) \
    ({ static ove_mutex_storage_t _ove_stor_; \
       ove_recursive_mutex_init((phandle), &_ove_stor_); })
#define ove_recursive_mutex_destroy(mtx) ove_mutex_deinit(mtx)
 
#define ove_condvar_create(pcv) \
    ({ static ove_condvar_storage_t _ove_stor_; \
       ove_condvar_init((pcv), &_ove_stor_); })
#define ove_condvar_destroy(cv) ove_condvar_deinit(cv)
 
#endif /* OVE_HEAP_SYNC */
 
/* =========================================================================
 * Operations — always available (when CONFIG_OVE_SYNC is set)
 * ========================================================================= */
 
int  ove_mutex_lock(ove_mutex_t mtx, uint32_t timeout_ms);
 
void ove_mutex_unlock(ove_mutex_t mtx);
 
int  ove_sem_take(ove_sem_t sem, uint32_t timeout_ms);
 
void ove_sem_give(ove_sem_t sem);
 
int  ove_event_wait(ove_event_t evt, uint32_t timeout_ms);
 
void ove_event_signal(ove_event_t evt);
 
void ove_event_signal_from_isr(ove_event_t evt);
 
int  ove_recursive_mutex_lock(ove_mutex_t mtx, uint32_t timeout_ms);
 
void ove_recursive_mutex_unlock(ove_mutex_t mtx);
 
int  ove_condvar_wait(ove_condvar_t cv, ove_mutex_t mtx,
              uint32_t timeout_ms);
 
void ove_condvar_signal(ove_condvar_t cv);
 
void ove_condvar_broadcast(ove_condvar_t cv);
 
#else /* !CONFIG_OVE_SYNC */
 
static inline int  ove_mutex_create(ove_mutex_t *m) { (void)m; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_mutex_destroy(ove_mutex_t m) { (void)m; }
static inline int  ove_mutex_lock(ove_mutex_t m, uint32_t t) { (void)m; (void)t; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_mutex_unlock(ove_mutex_t m) { (void)m; }
static inline int  ove_sem_create(ove_sem_t *s, unsigned int i, unsigned int x) { (void)s; (void)i; (void)x; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_sem_destroy(ove_sem_t s) { (void)s; }
static inline int  ove_sem_take(ove_sem_t s, uint32_t t) { (void)s; (void)t; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_sem_give(ove_sem_t s) { (void)s; }
static inline int  ove_event_create(ove_event_t *e) { (void)e; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_event_destroy(ove_event_t e) { (void)e; }
static inline int  ove_event_wait(ove_event_t e, uint32_t t) { (void)e; (void)t; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_event_signal(ove_event_t e) { (void)e; }
static inline void ove_event_signal_from_isr(ove_event_t e) { (void)e; }
static inline int  ove_recursive_mutex_create(ove_mutex_t *m) { (void)m; return OVE_ERR_NOT_SUPPORTED; }
static inline int  ove_recursive_mutex_lock(ove_mutex_t m, uint32_t t) { (void)m; (void)t; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_recursive_mutex_unlock(ove_mutex_t m) { (void)m; }
static inline void ove_recursive_mutex_destroy(ove_mutex_t m) { (void)m; }
static inline int  ove_condvar_create(ove_condvar_t *c) { (void)c; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_condvar_destroy(ove_condvar_t c) { (void)c; }
static inline int  ove_condvar_wait(ove_condvar_t c, ove_mutex_t m, uint32_t t) { (void)c; (void)m; (void)t; return OVE_ERR_NOT_SUPPORTED; }
static inline void ove_condvar_signal(ove_condvar_t c) { (void)c; }
static inline void ove_condvar_broadcast(ove_condvar_t c) { (void)c; }
 
#endif /* CONFIG_OVE_SYNC */
 
#ifdef __cplusplus
}
#endif
 
#endif /* OVE_SYNC_H */