dfu_cli.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_MESH_DFU_CLI_H__
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_DFU_CLI_H__
 
#include <zephyr/bluetooth/mesh/access.h>
#include <zephyr/bluetooth/mesh/blob_cli.h>
#include <zephyr/bluetooth/mesh/dfu.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct bt_mesh_dfu_cli;
 
#define BT_MESH_DFU_CLI_INIT(_handlers)                                        \
        {                                                                      \
                .cb = _handlers,                                               \
                .blob = { .cb = &_bt_mesh_dfu_cli_blob_handlers },             \
        }
 
#define BT_MESH_MODEL_DFU_CLI(_cli)                                            \
        BT_MESH_MODEL_BLOB_CLI(&(_cli)->blob),                                 \
        BT_MESH_MODEL_CB(BT_MESH_MODEL_ID_DFU_CLI, _bt_mesh_dfu_cli_op, NULL,  \
                         _cli, &_bt_mesh_dfu_cli_cb)
 
struct bt_mesh_dfu_target {
        struct bt_mesh_blob_target blob;
        uint8_t img_idx;
        uint8_t effect;
        uint8_t status;
        uint8_t phase;
};
 
struct bt_mesh_dfu_metadata_status {
        uint8_t idx;
        enum bt_mesh_dfu_status status;
        enum bt_mesh_dfu_effect effect;
};
 
struct bt_mesh_dfu_target_status {
        enum bt_mesh_dfu_status status;
        enum bt_mesh_dfu_phase phase;
        enum bt_mesh_dfu_effect effect;
        uint64_t blob_id;
        uint8_t img_idx;
        uint8_t ttl;
 
        uint16_t timeout_base;
};
 
typedef enum bt_mesh_dfu_iter (*bt_mesh_dfu_img_cb_t)(
        struct bt_mesh_dfu_cli *cli, struct bt_mesh_msg_ctx *ctx, uint8_t idx,
        uint8_t total, const struct bt_mesh_dfu_img *img, void *cb_data);
 
struct bt_mesh_dfu_cli_cb {
        void (*suspended)(struct bt_mesh_dfu_cli *cli);
 
        void (*ended)(struct bt_mesh_dfu_cli *cli,
                      enum bt_mesh_dfu_status reason);
 
        void (*applied)(struct bt_mesh_dfu_cli *cli);
 
        void (*confirmed)(struct bt_mesh_dfu_cli *cli);
 
        void (*lost_target)(struct bt_mesh_dfu_cli *cli,
                            struct bt_mesh_dfu_target *target);
};
 
struct bt_mesh_dfu_cli {
        const struct bt_mesh_dfu_cli_cb *cb;
        struct bt_mesh_blob_cli blob;
 
        /* runtime state */
 
        uint32_t op;
        const struct bt_mesh_model *mod;
 
        struct {
                const struct bt_mesh_dfu_slot *slot;
                const struct bt_mesh_blob_io *io;
                struct bt_mesh_blob_xfer blob;
                uint8_t state;
                uint8_t flags;
        } xfer;
 
        struct {
                uint8_t ttl;
                uint8_t type;
                uint8_t img_cnt;
                uint16_t addr;
                struct k_sem sem;
                void *params;
                bt_mesh_dfu_img_cb_t img_cb;
        } req;
};
 
struct bt_mesh_dfu_cli_xfer_blob_params {
        /* Logarithmic representation of the block size. */
        uint8_t block_size_log;
        uint16_t chunk_size;
};
 
struct bt_mesh_dfu_cli_xfer {
        uint64_t blob_id;
        const struct bt_mesh_dfu_slot *slot;
        enum bt_mesh_blob_xfer_mode mode;
        const struct bt_mesh_dfu_cli_xfer_blob_params *blob_params;
};
 
int bt_mesh_dfu_cli_send(struct bt_mesh_dfu_cli *cli,
                         const struct bt_mesh_blob_cli_inputs *inputs,
                         const struct bt_mesh_blob_io *io,
                         const struct bt_mesh_dfu_cli_xfer *xfer);
 
int bt_mesh_dfu_cli_suspend(struct bt_mesh_dfu_cli *cli);
 
int bt_mesh_dfu_cli_resume(struct bt_mesh_dfu_cli *cli);
 
int bt_mesh_dfu_cli_cancel(struct bt_mesh_dfu_cli *cli,
                           struct bt_mesh_msg_ctx *ctx);
 
int bt_mesh_dfu_cli_apply(struct bt_mesh_dfu_cli *cli);
 
int bt_mesh_dfu_cli_confirm(struct bt_mesh_dfu_cli *cli);
 
uint8_t bt_mesh_dfu_cli_progress(struct bt_mesh_dfu_cli *cli);
 
bool bt_mesh_dfu_cli_is_busy(struct bt_mesh_dfu_cli *cli);
 
int bt_mesh_dfu_cli_imgs_get(struct bt_mesh_dfu_cli *cli,
                             struct bt_mesh_msg_ctx *ctx,
                             bt_mesh_dfu_img_cb_t cb, void *cb_data,
                             uint8_t max_count);
 
int bt_mesh_dfu_cli_metadata_check(struct bt_mesh_dfu_cli *cli,
                                   struct bt_mesh_msg_ctx *ctx, uint8_t img_idx,
                                   const struct bt_mesh_dfu_slot *slot,
                                   struct bt_mesh_dfu_metadata_status *rsp);
 
int bt_mesh_dfu_cli_status_get(struct bt_mesh_dfu_cli *cli,
                               struct bt_mesh_msg_ctx *ctx,
                               struct bt_mesh_dfu_target_status *rsp);
 
int32_t bt_mesh_dfu_cli_timeout_get(void);
 
void bt_mesh_dfu_cli_timeout_set(int32_t timeout);
 
extern const struct bt_mesh_blob_cli_cb _bt_mesh_dfu_cli_blob_handlers;
extern const struct bt_mesh_model_cb _bt_mesh_dfu_cli_cb;
extern const struct bt_mesh_model_op _bt_mesh_dfu_cli_op[];
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_DFU_CLI_H__ */