nrf_rpc_cbor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef _NRF_RPC_CBOR_H_
#define _NRF_RPC_CBOR_H_
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
#include <zcbor_common.h>
#include <zcbor_decode.h>
#include <zcbor_encode.h>
 
#include <nrf_rpc.h>
 
/* Max ZCBOR states: 2 means that no backups are available but we can use constant state
 * to enable stop_on_error.
 */
#define NRF_RPC_ZCBOR_STATES    (2 + CONFIG_NRF_RPC_ZCBOR_BACKUPS)
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct nrf_rpc_cbor_ctx;
 
typedef void (*nrf_rpc_cbor_handler_t)(const struct nrf_rpc_group *group,
                                       struct nrf_rpc_cbor_ctx *ctx, void *handler_data);
 
/* Structure used internally to define TinCBOR command or event decoder. */
struct _nrf_rpc_cbor_decoder {
        nrf_rpc_cbor_handler_t handler;
        void *handler_data;
};
 
struct nrf_rpc_cbor_ctx {
        zcbor_state_t zs[NRF_RPC_ZCBOR_STATES];
        union {
                uint8_t *out_packet;
                const uint8_t *in_packet;
        };
};
 
#define NRF_RPC_CBOR_CMD_DECODER(_group, _name, _cmd, _handler, _data)         \
        static const                                                           \
        struct _nrf_rpc_cbor_decoder NRF_RPC_CONCAT(_name, _cbor_data) = {     \
                .handler = _handler,                                           \
                .handler_data = _data,                                         \
        };                                                                     \
        NRF_RPC_CMD_DECODER(_group, _name, _cmd, _nrf_rpc_cbor_proxy_handler,  \
                            (void *)&NRF_RPC_CONCAT(_name, _cbor_data))
 
#define NRF_RPC_CBOR_EVT_DECODER(_group, _name, _evt, _handler, _data)         \
        static const                                                           \
        struct _nrf_rpc_cbor_decoder NRF_RPC_CONCAT(_name, _cbor_data) = {     \
                .handler = _handler,                                           \
                .handler_data = _data,                                         \
        };                                                                     \
        NRF_RPC_EVT_DECODER(_group, _name, _evt, _nrf_rpc_cbor_proxy_handler,  \
                            (void *)&NRF_RPC_CONCAT(_name, _cbor_data))
 
#define NRF_RPC_CBOR_ALLOC(_group, _ctx, _len)                                           \
        do {                                                                             \
                nrf_rpc_alloc_tx_buf(_group, &((_ctx).out_packet), (_len) + 1);          \
                _nrf_rpc_cbor_prepare((struct nrf_rpc_cbor_ctx *)(&(_ctx)), (_len) + 1); \
        } while (0)
 
#define NRF_RPC_CBOR_DISCARD(_group, _ctx)            \
        nrf_rpc_free_tx_buf(_group, (_ctx).out_packet)
 
bool nrf_rpc_cbor_is_alloc(struct nrf_rpc_cbor_ctx *ctx);
 
int nrf_rpc_cbor_cmd(const struct nrf_rpc_group *group, uint8_t cmd,
                     struct nrf_rpc_cbor_ctx *ctx,
                     nrf_rpc_cbor_handler_t handler, void *handler_data);
 
int nrf_rpc_cbor_cmd_rsp(const struct nrf_rpc_group *group, uint8_t cmd,
                         struct nrf_rpc_cbor_ctx *ctx);
 
void nrf_rpc_cbor_cmd_no_err(const struct nrf_rpc_group *group, uint8_t cmd,
                             struct nrf_rpc_cbor_ctx *ctx,
                             nrf_rpc_cbor_handler_t handler,
                             void *handler_data);
 
void nrf_rpc_cbor_cmd_no_err_impl(const struct nrf_rpc_group *group, uint8_t cmd,
                             struct nrf_rpc_cbor_ctx *ctx,
                             nrf_rpc_cbor_handler_t handler,
                             void *handler_data, const char *file, int line, const char *func);
 
#ifdef CONFIG_NRF_RPC_DETAILED_ERROR_REPORTING
#define nrf_rpc_cbor_cmd_no_err(_group, _cmd, _ctx, _handler, _handler_data) \
        nrf_rpc_cbor_cmd_no_err_impl(_group, _cmd, _ctx, _handler, _handler_data, __FILE__, __LINE__, __func__)
#endif
 
void nrf_rpc_cbor_cmd_rsp_no_err(const struct nrf_rpc_group *group,
                                 uint8_t cmd, struct nrf_rpc_cbor_ctx *ctx);
 
void nrf_rpc_cbor_cmd_rsp_no_err_impl(const struct nrf_rpc_group *group,
                                 uint8_t cmd, struct nrf_rpc_cbor_ctx *ctx,
                                 const char *file, int line, const char *func);
 
#ifdef CONFIG_NRF_RPC_DETAILED_ERROR_REPORTING
#define nrf_rpc_cbor_cmd_rsp_no_err(_group, _cmd, _ctx) \
        nrf_rpc_cbor_cmd_rsp_no_err_impl(_group, _cmd, _ctx, __FILE__, __LINE__, __func__)
#endif
 
int nrf_rpc_cbor_evt(const struct nrf_rpc_group *group, uint8_t evt,
                     struct nrf_rpc_cbor_ctx *ctx);
 
void nrf_rpc_cbor_evt_no_err(const struct nrf_rpc_group *group, uint8_t evt,
                             struct nrf_rpc_cbor_ctx *ctx);
 
void nrf_rpc_cbor_evt_no_err_impl(const struct nrf_rpc_group *group, uint8_t evt,
                             struct nrf_rpc_cbor_ctx *ctx,
                             const char *file, int line, const char *func);
 
#ifdef CONFIG_NRF_RPC_DETAILED_ERROR_REPORTING
#define nrf_rpc_cbor_evt_no_err(_group, _evt, _ctx) \
        nrf_rpc_cbor_evt_no_err_impl(_group, _evt, _ctx, __FILE__, __LINE__, __func__)
#endif
 
int nrf_rpc_cbor_rsp(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx);
 
void nrf_rpc_cbor_rsp_no_err(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx);
 
void nrf_rpc_cbor_rsp_no_err_impl(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx,
                             const char *file, int line, const char *func);
 
#ifdef CONFIG_NRF_RPC_DETAILED_ERROR_REPORTING
#define nrf_rpc_cbor_rsp_no_err(_group, _ctx) \
        nrf_rpc_cbor_rsp_no_err_impl(_group, _ctx, __FILE__, __LINE__, __func__)
#endif
 
void nrf_rpc_cbor_decoding_done(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx);
 
/* Functions used internally by the macros, not intended to be used directly. */
void _nrf_rpc_cbor_prepare(struct nrf_rpc_cbor_ctx *ctx, size_t len);
void _nrf_rpc_cbor_proxy_handler(const struct nrf_rpc_group *group, const uint8_t *packet,
                                 size_t len, void *handler_data);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _NRF_RPC_CBOR_H_ */