ble_gq.h

/*
 * Copyright (c) 2018-2025 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BLE_GQ_H__
#define BLE_GQ_H__
 
#include <stddef.h>
#include <stdint.h>
 
#include <bm/softdevice_handler/nrf_sdh_ble.h>
 
#include <zephyr/kernel.h>
#include <zephyr/sys/slist.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BLE_GQ_DEF(_name)                                                                          \
        BLE_GQ_CUSTOM_DEF(_name, CONFIG_BLE_GQ_MAX_CONNECTIONS, CONFIG_BLE_GQ_HEAP_SIZE,           \
                          (CONFIG_BLE_GQ_MAX_CONNECTIONS * CONFIG_BLE_GQ_QUEUE_SIZE))
 
#define BLE_GQ_CUSTOM_DEF(_name, _max_conns, _heap_size, _max_req_blocks)                          \
        static uint16_t CONCAT(_name, _conn_handles_arr)[] = {                                     \
                LISTIFY(_max_conns, BLE_GQ_CONN_HANDLE_INIT, (,)),                                 \
        };                                                                                         \
        BUILD_ASSERT(ARRAY_SIZE(CONCAT(_name, _conn_handles_arr)) == (_max_conns));                \
        static uint16_t CONCAT(_name, _purge_arr)[] = {                                            \
                LISTIFY(_max_conns, BLE_GQ_PURGE_ARRAY_INIT, (,), (_max_conns)),                   \
        };                                                                                         \
        BUILD_ASSERT(ARRAY_SIZE(CONCAT(_name, _purge_arr)) == (_max_conns));                       \
        static sys_slist_t CONCAT(_name, _req_queues)[] = {                                        \
                LISTIFY(_max_conns, BLE_GQ_REQ_QUEUE_INIT, (,), _name),                            \
        };                                                                                         \
        BUILD_ASSERT(ARRAY_SIZE(CONCAT(_name, _req_queues)) == (_max_conns));                      \
        K_MEM_SLAB_DEFINE_STATIC(_name##_req_blocks, sizeof(struct ble_gq_req), (_max_req_blocks), \
                                 sizeof(void *));                                                  \
        static K_HEAP_DEFINE(_name##_heap, (_heap_size));                                          \
        static const struct ble_gq _name = {                                                       \
                .max_conns = (_max_conns),                                                         \
                .conn_handles = CONCAT(_name, _conn_handles_arr),                                  \
                .purge_list = CONCAT(_name, _purge_arr),                                           \
                .req_queue = (sys_slist_t *)&CONCAT(_name, _req_queues),                           \
                .req_blocks = &CONCAT(_name, _req_blocks),                                         \
                .data_pool = &CONCAT(_name, _heap),                                                \
        };                                                                                         \
        NRF_SDH_BLE_OBSERVER(CONCAT(_name, _obs), ble_gq_on_ble_evt, (void *)&_name, HIGH)
 
#define BLE_GQ_CONN_HANDLE_INIT(i, _) BLE_CONN_HANDLE_INVALID
 
#define BLE_GQ_PURGE_ARRAY_INIT(i, _max_conns) (_max_conns)
 
#define BLE_GQ_REQ_QUEUE_INIT(i, _name) SYS_SLIST_STATIC_INIT(&((_name)[i]))
 
enum ble_gq_req_type {
        BLE_GQ_REQ_GATTC_READ,
        BLE_GQ_REQ_GATTC_WRITE,
        BLE_GQ_REQ_SRV_DISCOVERY,
        BLE_GQ_REQ_CHAR_DISCOVERY,
        BLE_GQ_REQ_DESC_DISCOVERY,
        BLE_GQ_REQ_GATTS_HVX,
        BLE_GQ_REQ_NUM,
};
 
enum ble_gq_evt_type {
        BLE_GQ_EVT_ERROR,
};
 
struct ble_gq_evt {
        enum ble_gq_evt_type evt_type;
        uint16_t conn_handle;
        union {
                struct {
                        uint32_t reason;
                } error;
        };
};
 
/* Forward declaration */
struct ble_gq_req;
 
typedef void (*ble_gq_evt_handler_t)(const struct ble_gq_req *req, struct ble_gq_evt *evt);
 
struct ble_gq_req {
        sys_snode_t node;
        enum ble_gq_req_type type;
        uint8_t *data;
        ble_gq_evt_handler_t evt_handler;
        void *ctx;
        union {
                struct {
                        uint16_t handle;
                        uint16_t offset;
                } gattc_read;
                ble_gattc_write_params_t gattc_write;
                struct {
                        uint16_t start_handle;
                        ble_uuid_t srvc_uuid;
                } gattc_srv_disc;
                ble_gattc_handle_range_t gattc_char_disc;
                ble_gattc_handle_range_t gattc_desc_disc;
                ble_gatts_hvx_params_t gatts_hvx;
        };
};
 
struct ble_gq {
        const uint16_t max_conns;
        uint16_t *const conn_handles;
        uint16_t *const purge_list;
        sys_slist_t *const req_queue;
        struct k_mem_slab *const req_blocks;
        struct k_heap *const data_pool;
};
 
uint32_t ble_gq_item_add(const struct ble_gq *gatt_queue, struct ble_gq_req *req,
                         uint16_t conn_handle);
 
uint32_t ble_gq_conn_handle_register(const struct ble_gq *gatt_queue, uint16_t conn_handle);
 
void ble_gq_on_ble_evt(const ble_evt_t *ble_evt, void *ble_gq);
 
#ifdef __cplusplus
}
#endif
 
#endif /* BLE_GQ_H__ */