dfd_srv.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_DFD_SRV_H__
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_DFD_SRV_H__
 
#include <zephyr/bluetooth/mesh/access.h>
#include <zephyr/bluetooth/mesh/dfd.h>
#include <zephyr/bluetooth/mesh/blob_srv.h>
#include <zephyr/bluetooth/mesh/blob_cli.h>
#include <zephyr/bluetooth/mesh/dfu_cli.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef CONFIG_BT_MESH_DFD_SRV_TARGETS_MAX
#define CONFIG_BT_MESH_DFD_SRV_TARGETS_MAX 0
#endif
 
#ifndef CONFIG_BT_MESH_DFD_SRV_SLOT_MAX_SIZE
#define CONFIG_BT_MESH_DFD_SRV_SLOT_MAX_SIZE 0
#endif
 
#ifndef CONFIG_BT_MESH_DFD_SRV_SLOT_SPACE
#define CONFIG_BT_MESH_DFD_SRV_SLOT_SPACE 0
#endif
 
struct bt_mesh_dfd_srv;
 
#ifdef CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD
#define BT_MESH_DFD_SRV_OOB_INIT(_cb, _oob_schemes, _oob_schemes_count)        \
        {                                                                      \
                .cb = _cb,                                                     \
                .dfu = BT_MESH_DFU_CLI_INIT(&_bt_mesh_dfd_srv_dfu_cb),         \
                .upload = {                                                    \
                        .blob = { .cb = &_bt_mesh_dfd_srv_blob_cb },           \
                },                                                             \
                .oob_schemes = {                                               \
                        .schemes = _oob_schemes,                               \
                        .count = _oob_schemes_count,                           \
                },                                                             \
        }
#endif /* CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD */

#define BT_MESH_DFD_SRV_INIT(_cb)                                              \
        {                                                                      \
                .cb = _cb,                                                     \
                .dfu = BT_MESH_DFU_CLI_INIT(&_bt_mesh_dfd_srv_dfu_cb),         \
                .upload = {                                                    \
                        .blob = { .cb = &_bt_mesh_dfd_srv_blob_cb },           \
                },                                                             \
        }

#define BT_MESH_MODEL_DFD_SRV(_srv)                                            \
        BT_MESH_MODEL_DFU_CLI(&(_srv)->dfu),                                   \
        BT_MESH_MODEL_BLOB_SRV(&(_srv)->upload.blob),                          \
        BT_MESH_MODEL_CB(BT_MESH_MODEL_ID_DFD_SRV, _bt_mesh_dfd_srv_op, NULL,  \
                         _srv, &_bt_mesh_dfd_srv_cb)

struct bt_mesh_dfd_srv_cb {

        int (*recv)(struct bt_mesh_dfd_srv *srv,
                    const struct bt_mesh_dfu_slot *slot,
                    const struct bt_mesh_blob_io **io);
 
#ifdef CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD
        int (*start_oob_upload)(struct bt_mesh_dfd_srv *srv,
                                const struct bt_mesh_dfu_slot *slot,
                                const char *uri, uint8_t uri_len,
                                const uint8_t *fwid, uint16_t fwid_len);

        void (*cancel_oob_upload)(struct bt_mesh_dfd_srv *srv,
                                  const struct bt_mesh_dfu_slot *slot);

        uint8_t (*oob_progress_get)(struct bt_mesh_dfd_srv *srv,
                                    const struct bt_mesh_dfu_slot *slot);
#endif /* CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD */

        void (*del)(struct bt_mesh_dfd_srv *srv,
                    const struct bt_mesh_dfu_slot *slot);

        int (*send)(struct bt_mesh_dfd_srv *srv,
                    const struct bt_mesh_dfu_slot *slot,
                    const struct bt_mesh_blob_io **io);

        void (*phase)(struct bt_mesh_dfd_srv *srv, enum bt_mesh_dfd_phase phase);
};

struct bt_mesh_dfd_srv {
        const struct bt_mesh_dfd_srv_cb *cb;
        const struct bt_mesh_model *mod;
        struct bt_mesh_dfu_cli dfu;
        struct bt_mesh_dfu_target targets[CONFIG_BT_MESH_DFD_SRV_TARGETS_MAX];
        struct bt_mesh_blob_target_pull pull_ctxs[CONFIG_BT_MESH_DFD_SRV_TARGETS_MAX];
        const struct bt_mesh_blob_io *io;
        uint16_t target_cnt;
        uint16_t slot_idx;
        bool apply;
        enum bt_mesh_dfd_phase phase;
        struct bt_mesh_blob_cli_inputs inputs;
 
        struct {
                enum bt_mesh_dfd_upload_phase phase;
                struct bt_mesh_dfu_slot *slot;
                const struct flash_area *area;
                struct bt_mesh_blob_srv blob;
#ifdef CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD
                bool is_oob;
                bool is_pending_oob_check;
                struct {
                        uint8_t uri_len;
                        uint8_t uri[CONFIG_BT_MESH_DFU_URI_MAXLEN];
                        uint16_t current_fwid_len;
                        uint8_t current_fwid[CONFIG_BT_MESH_DFU_FWID_MAXLEN];
                        struct bt_mesh_msg_ctx ctx;
                } oob;
#endif /* CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD */
        } upload;
 
#ifdef CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD
        struct {
                const uint8_t *schemes;
                const uint8_t count;
        } oob_schemes;
#endif /* CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD */
};
 
#ifdef CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD
int bt_mesh_dfd_srv_oob_check_complete(struct bt_mesh_dfd_srv *srv,
                                       const struct bt_mesh_dfu_slot *slot, int status,
                                       uint8_t *fwid, size_t fwid_len);

int bt_mesh_dfd_srv_oob_store_complete(struct bt_mesh_dfd_srv *srv,
                                       const struct bt_mesh_dfu_slot *slot, bool success,
                                       size_t size, const uint8_t *metadata, size_t metadata_len);
#endif /* CONFIG_BT_MESH_DFD_SRV_OOB_UPLOAD */

extern const struct bt_mesh_model_op _bt_mesh_dfd_srv_op[];
extern const struct bt_mesh_model_cb _bt_mesh_dfd_srv_cb;
extern const struct bt_mesh_dfu_cli_cb _bt_mesh_dfd_srv_dfu_cb;
extern const struct bt_mesh_blob_srv_cb _bt_mesh_dfd_srv_blob_cb;
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_DFD_SRV_H__ */