bm_spi_mngr.h

/*
 * Copyright (c) 2026 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BM_SPI_MNGR_H__
#define BM_SPI_MNGR_H__
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include <nrfx_spim.h>
#include <zephyr/sys/ring_buffer.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BM_SPI_MNGR_TRANSFER(_tx_data, _tx_length, _rx_data, _rx_length)                           \
        {                                                                                          \
                .tx_data = (const uint8_t *)(_tx_data),                                            \
                .tx_length = (uint8_t)(_tx_length),                                                \
                .rx_data = (uint8_t *)(_rx_data),                                                  \
                .rx_length = (uint8_t)(_rx_length),                                                \
        }
 
typedef void (*bm_spi_mngr_callback_end_t)(int result, void *user_data);
 
typedef void (*bm_spi_mngr_callback_begin_t)(void *user_data);
 
struct bm_spi_mngr_transfer {
        const uint8_t *tx_data;
        uint8_t tx_length;
        uint8_t *rx_data;
        uint8_t rx_length;
};
 
struct bm_spi_mngr_transaction {
        bm_spi_mngr_callback_begin_t begin_callback;
        bm_spi_mngr_callback_end_t end_callback;
        void *user_data;
        const struct bm_spi_mngr_transfer *transfers;
        uint8_t number_of_transfers;
        const nrfx_spim_config_t *required_spim_cfg;
};
 
struct bm_spi_mngr {
        struct {
                const struct bm_spi_mngr_transaction *volatile current_transaction;
                nrfx_spim_config_t default_configuration;
                const nrfx_spim_config_t *current_configuration;
                uint8_t volatile current_transfer_idx;
        } cb;
        struct {
                size_t size;
                struct ring_buf ring_buf;
                uint8_t *byte_storage;
        } queue;
        nrfx_spim_t *spim;
};
 
#define BM_SPI_MNGR_DEF(_name, _queue_size, _spim_inst)                                            \
        static uint8_t _name##_queue_bytes[(_queue_size) *                                         \
                                           sizeof(const struct bm_spi_mngr_transaction *)];        \
        static nrfx_spim_t _name##_spim = NRFX_SPIM_INSTANCE(_spim_inst);                          \
        static struct bm_spi_mngr _name = {                                                        \
                .queue = {                                                                         \
                        .size = (_queue_size),                                                     \
                        .byte_storage = _name##_queue_bytes,                                       \
                },                                                                                 \
                .spim = &_name##_spim,                                                             \
        }
 
int bm_spi_mngr_init(struct bm_spi_mngr *mgr, const nrfx_spim_config_t *default_spim_cfg);
 
int bm_spi_mngr_uninit(struct bm_spi_mngr *mgr);
 
int bm_spi_mngr_schedule(struct bm_spi_mngr *mgr,
                         const struct bm_spi_mngr_transaction *transaction);
 
bool bm_spi_mngr_is_idle(const struct bm_spi_mngr *mgr);
 
#ifdef __cplusplus
}
#endif
 
#endif /* BM_SPI_MNGR_H__ */