smf.h

Go to the documentation of this file.

/*
 * Copyright 2021 The Chromium OS Authors
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_SMF_H_
#define ZEPHYR_INCLUDE_SMF_H_
 
#include <zephyr/sys/util.h>


/* clang-format off */
#define SMF_CREATE_STATE(_entry, _run, _exit, _parent, _initial)           \
{                                                                          \
        .entry   = _entry,                                                 \
        .run     = _run,                                                   \
        .exit    = _exit,                                                  \
        IF_ENABLED(CONFIG_SMF_ANCESTOR_SUPPORT, (.parent = _parent,))      \
        IF_ENABLED(CONFIG_SMF_INITIAL_TRANSITION, (.initial = _initial,))  \
}
/* clang-format on */

#define SMF_CTX(o) ((struct smf_ctx *)o)
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <zephyr/kernel.h>

enum smf_state_result {
        SMF_EVENT_HANDLED,
        SMF_EVENT_PROPAGATE,
};

enum smf_action_type {
        SMF_ACTION_ENTRY, 
        SMF_ACTION_RUN,   
        SMF_ACTION_EXIT,  
};

#define SMF_ERR_NULL_TRANSITION    1 
#define SMF_ERR_TRANSITION_IN_EXIT 2 
 
#if defined(CONFIG_SMF_INSTRUMENTATION) || defined(__DOXYGEN__)
/* Forward declarations for hook typedefs */
struct smf_ctx;
struct smf_state;

typedef void (*smf_transition_hook)(struct smf_ctx *ctx, const struct smf_state *source,
                                    const struct smf_state *dest);

typedef void (*smf_action_hook)(struct smf_ctx *ctx, const struct smf_state *state,
                                enum smf_action_type action_type);

typedef void (*smf_error_hook)(struct smf_ctx *ctx, int error_code);

struct smf_hooks {
        smf_transition_hook on_transition; 
        smf_action_hook on_action;         
        smf_error_hook on_error;           
};
#endif /* CONFIG_SMF_INSTRUMENTATION */

typedef void (*state_method)(void *obj);

typedef enum smf_state_result (*state_execution)(void *obj);

struct smf_state {
        const state_method entry;

        const state_execution run;

        const state_method exit;
#ifdef CONFIG_SMF_ANCESTOR_SUPPORT
        const struct smf_state *parent;
 
#ifdef CONFIG_SMF_INITIAL_TRANSITION
        const struct smf_state *initial;
#endif /* CONFIG_SMF_INITIAL_TRANSITION */
#endif /* CONFIG_SMF_ANCESTOR_SUPPORT */
};

struct smf_ctx {
        const struct smf_state *current;
        const struct smf_state *previous;
 
#ifdef CONFIG_SMF_ANCESTOR_SUPPORT
        const struct smf_state *executing;
#endif /* CONFIG_SMF_ANCESTOR_SUPPORT */
        int32_t terminate_val;
        uint32_t internal;
 
#ifdef CONFIG_SMF_INSTRUMENTATION
        const struct smf_hooks *hooks;
#endif /* CONFIG_SMF_INSTRUMENTATION */
};

void smf_set_initial(struct smf_ctx *ctx, const struct smf_state *init_state);

void smf_set_state(struct smf_ctx *ctx, const struct smf_state *new_state);

void smf_set_terminate(struct smf_ctx *ctx, int32_t val);
 
#ifdef CONFIG_SMF_INSTRUMENTATION
void smf_set_hooks(struct smf_ctx *ctx, const struct smf_hooks *hooks);
#endif /* CONFIG_SMF_INSTRUMENTATION */

int32_t smf_run_state(struct smf_ctx *ctx);

static inline const struct smf_state *smf_get_current_leaf_state(const struct smf_ctx *const ctx)
{
        return ctx->current;
}

static inline const struct smf_state *
smf_get_current_executing_state(const struct smf_ctx *const ctx)
{
#ifdef CONFIG_SMF_ANCESTOR_SUPPORT
        return ctx->executing;
#else
        return ctx->current;
#endif /* CONFIG_SMF_ANCESTOR_SUPPORT */
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_SMF_H_ */