module_state_event.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2021 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef _MODULE_STATE_EVENT_H_
#define _MODULE_STATE_EVENT_H_
 
#include <zephyr/sys/atomic.h>
#include <app_event_manager.h>
#include <app_event_manager_profiler_tracer.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define MODULE_ID_LIST_SECTION_PREFIX module_id_list
 
#define MODULE_ID_PTR_VAR(mname) _CONCAT(__module_, mname)
#define MODULE_ID_LIST_SECTION_NAME   STRINGIFY(MODULE_ID_LIST_SECTION_PREFIX)
#define MODULE_ID_PTR_VAR_EXTERN_DEC(mname) \
        extern const void * const MODULE_ID_PTR_VAR(mname)
 
extern const void * const __start_module_id_list[];
extern const void * const __stop_module_id_list[];
 
 
static inline size_t module_count(void)
{
        return (__stop_module_id_list - __start_module_id_list);
}
 
static inline const void *module_id_get(size_t idx)
{
        __ASSERT_NO_MSG(idx < module_count());
 
        return (__start_module_id_list + idx);
}
 
static inline size_t module_idx_get(const void *module_id)
{
        return ((const size_t *)module_id - (const size_t *)__start_module_id_list);
}
 
static inline const char *module_name_get(const void *id)
{
        __ASSERT_NO_MSG(id);
 
        return *((const char **)id);
}
 
#define MODULE_IDX(mname) ({                                        \
                MODULE_ID_PTR_VAR_EXTERN_DEC(mname);                \
                &MODULE_ID_PTR_VAR(mname) - __start_module_id_list; \
        })
 
struct module_flags {
        ATOMIC_DEFINE(f, CONFIG_CAF_MODULES_FLAGS_COUNT);
};
 
static inline bool module_check_id_valid(size_t module_idx)
{
        return (module_idx < module_count());
}
 
static inline bool module_flags_check_zero(const struct module_flags *mf)
{
        const atomic_t *target = mf->f;
 
        for (size_t n = ATOMIC_BITMAP_SIZE(CONFIG_CAF_MODULES_FLAGS_COUNT); n > 0; --n) {
                if (atomic_get(target++) != 0) {
                        return false;
                }
        }
        return true;
}
 
static inline bool module_flags_test_bit(const struct module_flags *mf, size_t module_idx)
{
        return atomic_test_bit(mf->f, module_idx);
}
 
static inline void module_flags_clear_bit(struct module_flags *mf, size_t module_idx)
{
        atomic_clear_bit(mf->f, module_idx);
}
 
static inline void module_flags_set_bit(struct module_flags *mf, size_t module_idx)
{
        atomic_set_bit(mf->f, module_idx);
}
 
static inline void module_flags_set_bit_to(struct module_flags *mf, size_t module_idx, bool val)
{
        atomic_set_bit_to(mf->f, module_idx, val);
}
 
enum module_state {
        MODULE_STATE_READY,
 
        MODULE_STATE_OFF,
 
        MODULE_STATE_STANDBY,
 
        MODULE_STATE_SUSPENDED,
 
        MODULE_STATE_ERROR,
 
        MODULE_STATE_COUNT,
 
        APP_EM_ENFORCE_ENUM_SIZE(MODULE_STATE)
};
 
struct module_state_event {
        struct app_event_header header;
 
        const void *module_id;
 
        enum module_state state;
};
 
APP_EVENT_TYPE_DECLARE(module_state_event);
 
 
static inline bool check_state(const struct module_state_event *event,
                const void *module_id, enum module_state state)
{
        if ((event->module_id == module_id) && (event->state == state)) {
                return true;
        }
        return false;
}
 
 
#define MODULE_ID(mname) ({                                  \
                        MODULE_ID_PTR_VAR_EXTERN_DEC(mname); \
                        &MODULE_ID_PTR_VAR(mname);           \
                })
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* _MODULE_STATE_EVENT_H_ */
 
/* Declare elements required in the module C file,
 * even if the file was already included before.
 */
#if defined(MODULE) && !defined(MODULE_NAME)
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define MODULE_NAME STRINGIFY(MODULE)
 
MODULE_ID_PTR_VAR_EXTERN_DEC(MODULE);
const void * const MODULE_ID_PTR_VAR(MODULE)
        __used __attribute__((__section__(MODULE_ID_LIST_SECTION_NAME)))
        = MODULE_NAME;
 
 
static inline void module_set_state(enum module_state state)
{
        __ASSERT_NO_MSG(state < MODULE_STATE_COUNT);
 
        struct module_state_event *event = new_module_state_event();
 
        event->module_id = MODULE_ID(MODULE);
        event->state = state;
        APP_EVENT_SUBMIT(event);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* defined(MODULE) && !defined(MODULE_NAME) */