client.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_RPC_CLIENT_H_
#define INFUSE_SDK_INCLUDE_INFUSE_RPC_CLIENT_H_
 
#include <zephyr/net_buf.h>
 
#include <infuse/epacket/interface.h>
#include <infuse/epacket/packet.h>
#include <infuse/rpc/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef void (*rpc_client_rsp_fn)(const struct net_buf *buf, void *user_data);
 
/* Context associated with a single in-flight command */
struct rpc_client_cmd_ctx {
        /* Command timeout timer */
        struct k_timer timeout;
        /* Allow the next transmission */
        struct k_sem tx_tokens;
        /* Timeout for the response */
        k_timeout_t rsp_timeout;
        /* Callback to run on completion */
        rpc_client_rsp_fn cb;
        /* Arbitrary user data for callback */
        void *user_data;
        /* RPC request ID */
        uint32_t request_id;
        /* RPC command ID */
        uint16_t command_id;
        /* Number of TX tokens to give on DATA_ACK */
        uint16_t tx_tokens_on_ack;
        /* Result of TX queuing */
        int16_t tx_result;
};
 
/* RPC client context */
struct rpc_client_ctx {
        const struct device *interface;
        union epacket_interface_address address;
        struct epacket_interface_cb interface_cb;
        struct rpc_client_cmd_ctx cmd_ctx[CONFIG_INFUSE_RPC_CLIENT_MAX_IN_FLIGHT];
        struct k_sem cmd_ctx_sem;
        uint32_t request_id;
};
 
void rpc_client_init(struct rpc_client_ctx *ctx, const struct device *dev,
                     union epacket_interface_address address);
 
static inline uint32_t rpc_client_last_request_id(const struct rpc_client_ctx *ctx)
{
        return ctx->request_id;
}
 
int rpc_client_update_response_timeout(struct rpc_client_ctx *ctx, uint32_t request_id,
                                       k_timeout_t timeout);
 
int rpc_client_command_queue(struct rpc_client_ctx *ctx, enum rpc_builtin_id cmd, void *req_params,
                             size_t req_params_len, rpc_client_rsp_fn cb, void *user_data,
                             k_timeout_t ctx_timeout, k_timeout_t response_timeout);
 
int rpc_client_ack_wait(struct rpc_client_ctx *ctx, uint32_t request_id, k_timeout_t timeout);
 
typedef int (*rpc_client_data_loader)(void *user_data, uint32_t offset, void *data,
                                      size_t data_len);
 
int rpc_client_data_queue(struct rpc_client_ctx *ctx, uint32_t request_id, uint32_t offset,
                          const void *data, size_t data_len);
 
struct rpc_client_auto_load_params {
        /* Callback to load more data */
        rpc_client_data_loader loader;
        /* Total length of data to send */
        uint32_t total_len;
        /* Duration to wait for each DATA_ACK */
        k_timeout_t ack_wait;
        /* Specified DATA_ACK period */
        uint8_t ack_period;
        /* Maximum number of pending DATA_ACK packets */
        uint8_t pipelining;
        /* User data pointer for @a loader */
        void *user_data;
};
 
int rpc_client_data_queue_auto_load(struct rpc_client_ctx *ctx, uint32_t request_id,
                                    uint32_t offset, void *buffer, size_t buffer_len,
                                    const struct rpc_client_auto_load_params *loader_params);
 
int rpc_client_command_sync(struct rpc_client_ctx *ctx, enum rpc_builtin_id cmd, void *req_params,
                            size_t req_params_len, k_timeout_t ctx_timeout,
                            k_timeout_t response_timeout, struct net_buf **rsp);
 
void rpc_client_cleanup(struct rpc_client_ctx *ctx);
 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_RPC_CLIENT_H_ */