524 lines
18 KiB
C
524 lines
18 KiB
C
#ifndef _RWIP_H_
|
|
#define _RWIP_H_
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @addtogroup ROOT
|
|
* @brief Entry points of the RW IP stacks/modules
|
|
*
|
|
* This module contains the primitives that allow an application accessing and running the
|
|
* RW IP protocol stacks / modules.
|
|
*
|
|
* @{
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
****************************************************************************************
|
|
*/
|
|
#include "rwip_config.h" // stack configuration
|
|
|
|
#include <stdint.h> // standard integer definitions
|
|
#include <stdbool.h> // standard boolean definitions
|
|
|
|
|
|
/*
|
|
* DEFINES
|
|
****************************************************************************************
|
|
*/
|
|
/// Maximum value of a Bluetooth clock (in 312.5us half slots)
|
|
#define RWIP_MAX_CLOCK_TIME ((1L<<32) - 1)
|
|
/// Maximum value of a 10ms Bluetooth clock
|
|
#define RWIP_MAX_10MS_TIME ((1L<<25) - 1)
|
|
/// retrieve 10ms time according to clock time
|
|
#define RWIP_CLOCK_TO_10MS_TIME(clock) ((clock) >> 5)
|
|
/// retrieve clock time according to 10ms time
|
|
#define RWIP_10MS_TIME_TO_CLOCK(time) ((time) << 5)
|
|
/// Invalid target time
|
|
#define RWIP_INVALID_TARGET_TIME (0xFFFFFFFFL)
|
|
|
|
|
|
/// result of sleep state.
|
|
enum rwip_sleep_state
|
|
{
|
|
/// Some activity pending, can not enter in sleep state
|
|
RWIP_ACTIVE = 0,
|
|
/// CPU can be put in sleep state
|
|
RWIP_CPU_SLEEP,
|
|
/// IP could enter in deep sleep
|
|
RWIP_DEEP_SLEEP,
|
|
};
|
|
|
|
|
|
/// Definition of the bits preventing the system from sleeping
|
|
enum prevent_sleep
|
|
{
|
|
/// Flag indicating that the wake up process is ongoing
|
|
RW_WAKE_UP_ONGOING = 0x0001,
|
|
/// Flag indicating that an TX transfer is ongoing on Transport Layer
|
|
RW_TL_TX_ONGOING = 0x0002,
|
|
/// Flag indicating that an RX transfer is ongoing on Transport Layer
|
|
RW_TL_RX_ONGOING = 0x0004,
|
|
/// Flag indicating HCI timeout is ongoing
|
|
RW_AHI_TIMEOUT = 0x0008,
|
|
/// Flag indicating that an encryption is ongoing
|
|
RW_CRYPT_ONGOING = 0x0010,
|
|
/// Flag indicating that controller shall not sleep due to not CSB LPO_Allowed
|
|
RW_CSB_NOT_LPO_ALLOWED = 0x0040,
|
|
/// Flag indicating the MWS/WLAN Event Generator is in operation
|
|
RW_MWS_WLAN_EVENT_GENERATOR_ACTIVE = 0x0080,
|
|
/// Flag to indicate that platform does not support deep sleep
|
|
RW_PLF_DEEP_SLEEP_DISABLED = 0x0100,
|
|
};
|
|
|
|
/// Parameters - Possible Returned Status
|
|
enum PARAM_STATUS
|
|
{
|
|
/// PARAM status OK
|
|
PARAM_OK,
|
|
/// generic PARAM status KO
|
|
PARAM_FAIL,
|
|
/// PARAM ID unrecognized
|
|
PARAM_ID_NOT_DEFINED,
|
|
/// No space for PARAM
|
|
PARAM_NO_SPACE_AVAILABLE,
|
|
/// Length violation
|
|
PARAM_LENGTH_OUT_OF_RANGE,
|
|
/// PARAM parameter locked
|
|
PARAM_PARAM_LOCKED,
|
|
/// PARAM corrupted
|
|
PARAM_CORRUPT
|
|
};
|
|
|
|
/**
|
|
* External interface type types.
|
|
*/
|
|
enum rwip_eif_types
|
|
{
|
|
/// Host Controller Interface - Controller part
|
|
RWIP_EIF_HCIC,
|
|
|
|
/// Host Controller Interface - Host part
|
|
RWIP_EIF_HCIH,
|
|
|
|
/// Application Host interface
|
|
RWIP_EIF_AHI,
|
|
};
|
|
|
|
|
|
/// Enumeration of External Interface status codes
|
|
enum rwip_eif_status
|
|
{
|
|
/// EIF status OK
|
|
RWIP_EIF_STATUS_OK,
|
|
/// EIF status KO
|
|
RWIP_EIF_STATUS_ERROR,
|
|
|
|
#if (BLE_EMB_PRESENT == 0)
|
|
/// External interface detached
|
|
RWIP_EIF_STATUS_DETACHED,
|
|
/// External interface attached
|
|
RWIP_EIF_STATUS_ATTACHED,
|
|
#endif // (BLE_EMB_PRESENT == 0)
|
|
};
|
|
|
|
/// Enumeration of RF modulations
|
|
enum rwip_rf_mod
|
|
{
|
|
MOD_GFSK = 0x01,
|
|
MOD_DQPSK = 0x02,
|
|
MOD_8DPSK = 0x03,
|
|
};
|
|
|
|
/*
|
|
* TYPE DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Time information
|
|
typedef struct
|
|
{
|
|
/// Time in 312.5 us step.
|
|
uint32_t time;
|
|
/// number of half us before getting next tick
|
|
uint32_t next_tick;
|
|
} rwip_time_t;
|
|
|
|
|
|
|
|
/// API functions of the RF driver that are used by the BLE or BT software
|
|
struct rwip_rf_api
|
|
{
|
|
/// Function called upon HCI reset command reception
|
|
void (*reset)(void);
|
|
/// Function called to enable/disable force AGC mechanism (true: en / false : dis)
|
|
void (*force_agc_enable)(bool);
|
|
/// Function called when TX power has to be decreased for a specific link id
|
|
bool (*txpwr_dec)(uint8_t);
|
|
/// Function called when TX power has to be increased for a specific link id
|
|
bool (*txpwr_inc)(uint8_t);
|
|
/// Function called when TX power has to be set to max for a specific link id
|
|
void (*txpwr_max_set)(uint8_t);
|
|
/// Function called to convert a TX power CS power field into the corresponding value in dBm
|
|
uint8_t (*txpwr_dbm_get)(uint8_t, uint8_t);
|
|
/// Function called to convert a power in dBm into a control structure tx power field
|
|
uint8_t (*txpwr_cs_get)(int8_t, bool);
|
|
/// Function called to convert the RSSI read from the control structure into a real RSSI
|
|
int8_t (*rssi_convert)(uint8_t);
|
|
/// Function used to read a RF register
|
|
uint32_t (*reg_rd)(uint16_t);
|
|
/// Function used to write a RF register
|
|
void (*reg_wr)(uint16_t, uint32_t);
|
|
/// Function called to put the RF in deep sleep mode
|
|
void (*sleep)(void);
|
|
/// Index of minimum TX power
|
|
uint8_t txpwr_min;
|
|
/// Index of maximum TX power
|
|
uint8_t txpwr_max;
|
|
/// RSSI high threshold ('real' signed value in dBm)
|
|
int8_t rssi_high_thr;
|
|
/// RSSI low threshold ('real' signed value in dBm)
|
|
int8_t rssi_low_thr;
|
|
/// interferer threshold ('real' signed value in dBm)
|
|
int8_t rssi_interf_thr;
|
|
/// RF wakeup delay (in slots)
|
|
uint8_t wakeup_delay;
|
|
};
|
|
|
|
/// API functions of the parameters that are used by the BLE or BT software
|
|
struct rwip_param_api
|
|
{
|
|
/**
|
|
* Get a parameter value
|
|
* @param[in] param_id Parameter identifier
|
|
* @param[in/out] lengthPtr Pointer to the length of the parameter (input: contain max length, output contain the effective param length)
|
|
* @param[out] buf Pointer to the buffer be filled with the parameter value
|
|
* @return status 0: success | >0 : error
|
|
*/
|
|
uint8_t (*get) (uint8_t param_id, uint8_t * lengthPtr, uint8_t *buf);
|
|
|
|
/**
|
|
* Set a parameter value
|
|
* @param[in] param_id Parameter identifier
|
|
* @param[in/out] length Length of the parameter
|
|
* @param[out] buf Pointer to the buffer containing the parameter value
|
|
* @return status 0: success | >0 : error
|
|
*/
|
|
uint8_t (*set) (uint8_t param_id, uint8_t length, uint8_t *buf);
|
|
|
|
/**
|
|
* Delete a parameter
|
|
* @param[in] param_id Parameter identifier
|
|
* @return status 0: success | >0 : error
|
|
*/
|
|
uint8_t (*del) (uint8_t param_id);
|
|
};
|
|
|
|
/// Internal API for priority
|
|
struct rwip_prio
|
|
{
|
|
///value
|
|
uint8_t value;
|
|
///Increment
|
|
uint8_t increment;
|
|
};
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Function called when packet transmission/reception is finished.
|
|
|
|
* @param[in] dummy Dummy data pointer returned to callback when operation is over.
|
|
* @param[in] status Ok if action correctly performed, else reason status code.
|
|
*****************************************************************************************
|
|
*/
|
|
typedef void (*rwip_eif_callback) (void*, uint8_t);
|
|
|
|
/**
|
|
* Transport layer communication interface.
|
|
*/
|
|
struct rwip_eif_api
|
|
{
|
|
/**
|
|
*************************************************************************************
|
|
* @brief Starts a data reception.
|
|
*
|
|
* @param[out] bufptr Pointer to the RX buffer
|
|
* @param[in] size Size of the expected reception
|
|
* @param[in] callback Pointer to the function called back when transfer finished
|
|
* @param[in] dummy Dummy data pointer returned to callback when reception is finished
|
|
*************************************************************************************
|
|
*/
|
|
void (*read) (uint8_t *bufptr, uint32_t size, rwip_eif_callback callback, void* dummy);
|
|
|
|
/**
|
|
*************************************************************************************
|
|
* @brief Starts a data transmission.
|
|
*
|
|
* @param[in] bufptr Pointer to the TX buffer
|
|
* @param[in] size Size of the transmission
|
|
* @param[in] callback Pointer to the function called back when transfer finished
|
|
* @param[in] dummy Dummy data pointer returned to callback when transmission is finished
|
|
*************************************************************************************
|
|
*/
|
|
void (*write)(uint8_t *bufptr, uint32_t size, rwip_eif_callback callback, void* dummy);
|
|
|
|
/**
|
|
*************************************************************************************
|
|
* @brief Enable Interface flow.
|
|
*************************************************************************************
|
|
*/
|
|
void (*flow_on)(void);
|
|
|
|
/**
|
|
*************************************************************************************
|
|
* @brief Disable Interface flow.
|
|
*
|
|
* @return True if flow has been disabled, False else.
|
|
*************************************************************************************
|
|
*/
|
|
bool (*flow_off)(void);
|
|
};
|
|
|
|
/*
|
|
* VARIABLE DECLARATION
|
|
*****************************************************************************************
|
|
*/
|
|
|
|
/// API for RF driver
|
|
extern struct rwip_rf_api rwip_rf;
|
|
/// API for parameters
|
|
extern struct rwip_param_api rwip_param;
|
|
#if (BLE_EMB_PRESENT || BT_EMB_PRESENT)
|
|
/// API for dual mode priority
|
|
extern const struct rwip_prio rwip_priority[RWIP_PRIO_IDX_MAX];
|
|
#endif //#if (BLE_EMB_PRESENT || BT_EMB_PRESENT)
|
|
|
|
#if (BT_EMB_PRESENT || BLE_EMB_PRESENT)
|
|
#if (RW_WLAN_COEX)
|
|
/// API for COEX configuration
|
|
extern const uint8_t rwip_coex_cfg[RWIP_COEX_CFG_MAX];
|
|
#endif //(RW_WLAN_COEX)
|
|
#endif //(BT_EMB_PRESENT || BLE_EMB_PRESENT)
|
|
|
|
/*
|
|
* MACROS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Get Event status flag
|
|
#if (BT_EMB_PRESENT || BLE_EMB_PRESENT)
|
|
#if (RW_WLAN_COEX)
|
|
#define RWIP_COEX_GET(coex_cfg_idx, bit_field) \
|
|
(uint8_t)(((rwip_coex_cfg[RWIP_COEX_ ## coex_cfg_idx ##_IDX]) >> RWIP_ ## bit_field ## _POS ) & RWIP_COEX_BIT_MASK)
|
|
#else //(RW_WLAN_COEX)
|
|
#define RWIP_COEX_GET(coex_cfg_idx, bit_field) 0
|
|
#endif //(RW_WLAN_COEX)
|
|
#endif //(BT_EMB_PRESENT || BLE_EMB_PRESENT)
|
|
|
|
/*
|
|
* FUNCTION DECLARATION
|
|
*****************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Initializes the RW BT SW.
|
|
*
|
|
****************************************************************************************
|
|
*/
|
|
void rwip_init(uint32_t error);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Reset the RW BT SW.
|
|
*
|
|
****************************************************************************************
|
|
*/
|
|
void rwip_reset(void);
|
|
|
|
|
|
|
|
#if (BT_EMB_PRESENT)
|
|
|
|
#if PCA_SUPPORT
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Check if clock dragging limitation
|
|
*
|
|
* @return true if clock dragging must be used
|
|
****************************************************************************************
|
|
*/
|
|
bool rwip_pca_clock_dragging_only(void);
|
|
#endif //PCA_SUPPORT
|
|
#endif // (BT_EMB_PRESENT)
|
|
|
|
#if (BT_EMB_PRESENT || BLE_EMB_PRESENT)
|
|
#if (RW_MWS_COEX)
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Enable/Disable the MWS coexistence interface.
|
|
*
|
|
* @param[in] CoexSetting Coexistence value
|
|
*
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_mwscoex_set(bool state);
|
|
#endif //RW_MWS_COEX
|
|
|
|
#if (RW_WLAN_COEX)
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Enable/Disable the Wireless LAN coexistence interface.
|
|
*
|
|
* @param[in] CoexSetting Coexistence value
|
|
*
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_wlcoex_set(bool state);
|
|
#endif //RW_WLAN_COEX
|
|
#endif //(BT_EMB_PRESENT || BLE_EMB_PRESENT)
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Function to implement in platform in order to retrieve expected external
|
|
* interface such as UART for Host Control Interface.
|
|
*
|
|
* @param[in] type external interface type (@see rwip_eif_types)
|
|
*
|
|
* @return External interface api structure
|
|
****************************************************************************************
|
|
*/
|
|
extern const struct rwip_eif_api* rwip_eif_get(uint8_t type);
|
|
|
|
#if RW_DEBUG
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Raises an assertion message to the control interface (if present)
|
|
*
|
|
* @param[in] file File name
|
|
* @param[in] line Line number
|
|
* @param[in] param0 Parameter 0 (custom value given by the assert instruction)
|
|
* @param[in] param1 Parameter 1 (custom value given by the assert instruction)
|
|
****************************************************************************************
|
|
*/
|
|
void rwip_assert_err(const char * file, int line, int param0, int param1);
|
|
#endif //RW_DEBUG
|
|
|
|
|
|
/* **************************************************************************************
|
|
* Driver functions
|
|
* **************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Retrieved sampled current time in half slot and next tick time in half us.
|
|
*
|
|
* @note Shall be called within a critical section
|
|
*
|
|
* @return current time sampled (@see rwip_time_t)
|
|
****************************************************************************************
|
|
*/
|
|
rwip_time_t rwip_time_get(void);
|
|
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Set the a 10 ms target timer
|
|
*
|
|
* @note if target is RWIP_INVALID_TARGET_TIME, not timer are programmed
|
|
*
|
|
* @param[in] target 10ms Timer target value
|
|
****************************************************************************************
|
|
*/
|
|
void rwip_timer_10ms_set(uint32_t target);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Set the a half slot target timer
|
|
*
|
|
* @note if target is RWIP_INVALID_TARGET_TIME, not timer are programmed
|
|
*
|
|
* @param[in] target Half Slot Timer target value
|
|
****************************************************************************************
|
|
*/
|
|
void rwip_timer_hs_set(uint32_t target);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Gives FW/HW versions of RW-BT stack.
|
|
*
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_version(uint8_t* fw_version, uint8_t* hw_version);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Start AES encryption
|
|
*
|
|
* The exchange memory must be filled before calling this function.
|
|
* This function expect to be called from a BLE Module
|
|
*
|
|
* @param[in] key AES Encryption key must be 16 bytes
|
|
* @param[in] data_em_ptr Exchange memory data pointer of data to encrypt
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_aes_encrypt(uint8_t *key, uint16_t data_em_ptr);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Request a Software interrupt to be triggered
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_sw_int_req(void);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Schedule all pending events.
|
|
*
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_schedule(void);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Invoke the sleep function.
|
|
*
|
|
* @return sleep status (@see enum rwip_sleep_state)
|
|
****************************************************************************************
|
|
*/
|
|
//uint8_t rwip_sleep(void);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handle the common core interrupts.
|
|
*
|
|
* @param[in] current IRQ status
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_isr(uint32_t irq_stat);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Set a bit in the prevent sleep bit field, in order to prevent the system from
|
|
* going to sleep
|
|
*
|
|
* @param[in] prv_slp_bit Bit to be set in the prevent sleep bit field
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_prevent_sleep_set(uint16_t prv_slp_bit);
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Clears a bit in the prevent sleep bit field, in order to allow the system
|
|
* going to sleep
|
|
*
|
|
* @param[in] prv_slp_bit Bit to be cleared in the prevent sleep bit field
|
|
****************************************************************************************
|
|
*/
|
|
//void rwip_prevent_sleep_clear(uint16_t prv_slp_bit);
|
|
|
|
///@} ROOT
|
|
|
|
#endif // _RWIP_H_
|