blob_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_BLOB_CLI_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_BLOB_CLI_H_
 
#include <sys/types.h>
 
#include <zephyr/bluetooth/mesh/access.h>
#include <zephyr/bluetooth/mesh/blob.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
struct bt_mesh_blob_cli;

#define BT_MESH_MODEL_BLOB_CLI(_cli)                                           \
        BT_MESH_MODEL_CB(BT_MESH_MODEL_ID_BLOB_CLI, _bt_mesh_blob_cli_op,      \
                         NULL, _cli, &_bt_mesh_blob_cli_cb)

struct bt_mesh_blob_target_pull {
        int64_t block_report_timestamp;

        uint8_t missing[DIV_ROUND_UP(CONFIG_BT_MESH_BLOB_CHUNK_COUNT_MAX, 8)];
};

struct bt_mesh_blob_target {
        sys_snode_t n;

        uint16_t addr;

        struct bt_mesh_blob_target_pull *pull;

        uint8_t status;
 
        uint8_t procedure_complete:1, /* Procedure has been completed. */
                acked:1,              /* Message has been acknowledged. Not used when sending. */
                timedout:1,           /* Target node didn't respond after specified timeout. */
                skip:1;               /* Skip Target node from broadcast. */
};

struct bt_mesh_blob_xfer_info {
        enum bt_mesh_blob_status status;

        enum bt_mesh_blob_xfer_mode mode;

        enum bt_mesh_blob_xfer_phase phase;

        uint64_t id;

        uint32_t size;

        uint8_t block_size_log;

        uint16_t mtu_size;

        const uint8_t *missing_blocks;
};

struct bt_mesh_blob_cli_inputs {
        sys_slist_t targets;

        uint16_t app_idx;

        uint16_t group;

        uint8_t ttl;

        uint16_t timeout_base;
};

struct bt_mesh_blob_cli_caps {
        size_t max_size;

        uint8_t min_block_size_log;

        uint8_t max_block_size_log;

        uint16_t max_chunks;

        uint16_t max_chunk_size;

        uint16_t mtu_size;

        enum bt_mesh_blob_xfer_mode modes;
};

enum bt_mesh_blob_cli_state {
        BT_MESH_BLOB_CLI_STATE_NONE,
        BT_MESH_BLOB_CLI_STATE_CAPS_GET,
        BT_MESH_BLOB_CLI_STATE_START,
        BT_MESH_BLOB_CLI_STATE_BLOCK_START,
        BT_MESH_BLOB_CLI_STATE_BLOCK_SEND,
        BT_MESH_BLOB_CLI_STATE_BLOCK_CHECK,
        BT_MESH_BLOB_CLI_STATE_XFER_CHECK,
        BT_MESH_BLOB_CLI_STATE_CANCEL,
        BT_MESH_BLOB_CLI_STATE_SUSPENDED,
        BT_MESH_BLOB_CLI_STATE_XFER_PROGRESS_GET,
};

struct bt_mesh_blob_cli_cb {
        void (*caps)(struct bt_mesh_blob_cli *cli,
                     const struct bt_mesh_blob_cli_caps *caps);

        void (*lost_target)(struct bt_mesh_blob_cli *cli,
                            struct bt_mesh_blob_target *target,
                            enum bt_mesh_blob_status reason);

        void (*suspended)(struct bt_mesh_blob_cli *cli);

        void (*end)(struct bt_mesh_blob_cli *cli,
                    const struct bt_mesh_blob_xfer *xfer, bool success);

        void (*xfer_progress)(struct bt_mesh_blob_cli *cli,
                              struct bt_mesh_blob_target *target,
                              const struct bt_mesh_blob_xfer_info *info);

        void (*xfer_progress_complete)(struct bt_mesh_blob_cli *cli);
};

struct blob_cli_broadcast_ctx {
        void (*send)(struct bt_mesh_blob_cli *cli, uint16_t dst);
        void (*send_complete)(struct bt_mesh_blob_cli *cli, uint16_t dst);
        void (*next)(struct bt_mesh_blob_cli *cli);
        bool acked;
        bool force_unicast;
        bool optional;
        bool is_inited;
        /* Defines a time in ms by which the broadcast API postpones sending the message to a next
         * target or completing the broadcast.
         */
        uint32_t post_send_delay_ms;
};

struct bt_mesh_blob_cli {
        const struct bt_mesh_blob_cli_cb *cb;
 
        /* Runtime state */
        const struct bt_mesh_model *mod;
 
        struct {
                struct bt_mesh_blob_target *target;
                struct blob_cli_broadcast_ctx ctx;
                struct k_work_delayable retry;
                /* Represents Client Timeout timer in a timestamp. Used in Pull mode only. */
                int64_t cli_timestamp;
                struct k_work_delayable complete;
                uint16_t pending;
                uint8_t retries;
                uint8_t sending : 1,
                        cancelled : 1;
        } tx;
 
        const struct bt_mesh_blob_io *io;
        const struct bt_mesh_blob_cli_inputs *inputs;
        const struct bt_mesh_blob_xfer *xfer;
        uint32_t chunk_interval_ms;
        uint16_t block_count;
        uint16_t chunk_idx;
        uint16_t mtu_size;
        enum bt_mesh_blob_cli_state state;
        struct bt_mesh_blob_block block;
        struct bt_mesh_blob_cli_caps caps;
};

int bt_mesh_blob_cli_caps_get(struct bt_mesh_blob_cli *cli,
                              const struct bt_mesh_blob_cli_inputs *inputs);

int bt_mesh_blob_cli_send(struct bt_mesh_blob_cli *cli,
                          const struct bt_mesh_blob_cli_inputs *inputs,
                          const struct bt_mesh_blob_xfer *xfer,
                          const struct bt_mesh_blob_io *io);

int bt_mesh_blob_cli_suspend(struct bt_mesh_blob_cli *cli);

int bt_mesh_blob_cli_resume(struct bt_mesh_blob_cli *cli);

void bt_mesh_blob_cli_cancel(struct bt_mesh_blob_cli *cli);

int bt_mesh_blob_cli_xfer_progress_get(struct bt_mesh_blob_cli *cli,
                                       const struct bt_mesh_blob_cli_inputs *inputs);

uint8_t bt_mesh_blob_cli_xfer_progress_active_get(struct bt_mesh_blob_cli *cli);

bool bt_mesh_blob_cli_is_busy(struct bt_mesh_blob_cli *cli);

void bt_mesh_blob_cli_set_chunk_interval_ms(struct bt_mesh_blob_cli *cli, uint32_t interval_ms);

extern const struct bt_mesh_model_op _bt_mesh_blob_cli_op[];
extern const struct bt_mesh_model_cb _bt_mesh_blob_cli_cb;

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_BLOB_CLI_H_ */