ble5.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef ti_drivers_RCL_commands_ble5_h__include
#define ti_drivers_RCL_commands_ble5_h__include
 
typedef struct RCL_FL_ENTRY_t     RCL_FL_Entry;
typedef struct RCL_FILTER_LIST_t  RCL_FilterList;
typedef struct RCL_ADDR_TYPE_t    RCL_AddrType;
 
typedef struct RCL_CMD_BLE5_ADV          RCL_CmdBle5Advertiser;
typedef struct RCL_CMD_BLE5_INITIATOR_t  RCL_CmdBle5Initiator;
typedef struct RCL_CMD_BLE5_SCANNER_t    RCL_CmdBle5Scanner;
typedef struct RCL_CMD_BLE5_CONNECTION_t RCL_CmdBle5Connection;
typedef struct RCL_CMD_BLE5_DTM_TX       RCL_CmdBle5DtmTx;
typedef struct RCL_CMD_BLE5_GENERIC_RX_t RCL_CmdBle5GenericRx;
typedef struct RCL_CMD_BLE5_GENERIC_TX_t RCL_CmdBle5GenericTx;
typedef struct RCL_CMD_BLE5_TX_TEST_t    RCL_CmdBle5TxTest;
 
typedef struct RCL_CTX_ADVERTISER_t      RCL_CtxAdvertiser;
typedef struct RCL_CTX_SCAN_INIT_t       RCL_CtxScanInit;
typedef struct RCL_CTX_CONNECTION_t      RCL_CtxConnection;
typedef struct RCL_CTX_GENERIC_RX_t      RCL_CtxGenericRx;
typedef struct RCL_CTX_GENERIC_TX_t      RCL_CtxGenericTx;
 
typedef struct RCL_STATS_ADV_SCAN_INIT_t RCL_StatsAdvScanInit;
typedef struct RCL_STATS_CONNECTION_t    RCL_StatsConnection;
typedef struct RCL_STATS_GENERIC_RX_t    RCL_StatsGenericRx;
 
typedef uint8_t RCL_Ble5Channel;
 
typedef enum {
    RCL_Ble5_RxPhy1Mbps = 0,
    RCL_Ble5_RxPhy2Mbps = 1,
    RCL_Ble5_RxPhyCodedS8 = 2,
    RCL_Ble5_RxPhyCodedS2 = 3,
} RCL_Ble5_RxPhy;
 
typedef union {
    struct {
        RCL_Ble5_RxPhy phy  :2;     
        uint8_t crcError    :1;     
        uint8_t ignored     :1;     
        uint8_t ignoredRpa  :1;     
        uint8_t reserved    :3;
    };
    uint8_t value;
} RCL_Ble5_RxPktStatus;
 
/* Invalid packet status */
#define RCL_BLE5_RX_PKT_STATUS_INVALID 0xFF
 
/* Do inlcudes after typedefs, as the types are needed in ti/drivers/rcl/handlers/ble5.h */
#include <ti/drivers/rcl/RCL_Command.h>
#include <ti/drivers/rcl/handlers/ble5.h>
#include <ti/drivers/utils/List.h>
 
#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(driverlib/pbe_ble5_ram_regs.h)
 
/* Command IDs for BLE commands */
#define RCL_CMDID_BLE5_ADVERTISER 0x1001U
#define RCL_CMDID_BLE5_INITIATOR  0x1002U
#define RCL_CMDID_BLE5_SCANNER    0x1003U
#define RCL_CMDID_BLE5_CONNECTION 0x1004U
#define RCL_CMDID_BLE5_DTM_TX     0x1005U
#define RCL_CMDID_BLE5_GENERIC_RX 0x1006U
#define RCL_CMDID_BLE5_GENERIC_TX 0x1007U
#define RCL_CMDID_BLE5_TX_TEST    0x1008U
 
#define BLE_CUSTOM_FREQ_BM        0x80U
 
struct RCL_FL_ENTRY_t {
    union
    {
        struct
        {
            uint16_t enabled      : 1; 
            uint16_t addType      : 1; 
            uint16_t duplicateIgn : 1; 
            uint16_t privIgn      : 1; 
            uint16_t reserved     : 12;
        } ctl;
        uint16_t ctlWord;
    };
    uint16_t address[3];               
};
 
struct RCL_FILTER_LIST_t {
    uint32_t     numEntries;
    RCL_FL_Entry entries[16];
};
 
struct RCL_ADDR_TYPE_t {
    uint8_t peer :1;     
    uint8_t own :1;      
    uint8_t reserved: 6; 
};
 
struct RCL_CMD_BLE5_ADV {
    RCL_Command  common;
    uint8_t chanMap;              
    uint8_t order;                
    RCL_Command_TxPower txPower;  
    uint8_t highDuty;             
    uint32_t connectPktTime;      
    RCL_CtxAdvertiser *ctx;       
    RCL_StatsAdvScanInit *stats;  
};
 
#define RCL_CmdBle5Advertiser_Default()                         \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_ADVERTISER,    \
                                  RCL_Handler_BLE5_adv),        \
    .chanMap = 0x7,                                             \
    .order = 0,                                                 \
    .txPower = {.dBm = 0, .fraction = 0},                       \
    .highDuty = 0,                                              \
    .ctx = NULL,                                                \
    .stats = NULL,                                              \
}
#define RCL_CmdBle5Advertiser_DefaultRuntime() (RCL_CmdBle5Advertiser) RCL_CmdBle5Advertiser_Default()
 
struct RCL_CTX_ADVERTISER_t {
    RCL_FilterList *filterListConn;     
    RCL_FilterList *filterListScan;     
    List_List txBuffers;                
    List_List rxBuffers;                
    uint16_t advA[3];                   
    uint16_t peerA[3];                  
    RCL_AddrType addrType;              
    uint8_t filterPolicy: 2;            
    uint8_t privIgnMode:1;              
    uint8_t rpaModePeer:1;              
    uint8_t acceptAllRpaConnectInd: 1;  
};
 
#define RCL_CtxAdvertiser_Default() \
{                                   \
    .filterListConn = NULL,         \
    .filterListScan = NULL,         \
    .txBuffers = { 0 },             \
    .rxBuffers = { 0 },             \
    .advA = { 0 },                  \
    .peerA = { 0 },                 \
    .addrType =  { 0 },             \
    .filterPolicy = 0,              \
    .privIgnMode = 0,               \
    .rpaModePeer = 0,               \
    .acceptAllRpaConnectInd = 0     \
}
#define RCL_CtxAdvertiser_DefaultRuntime() (RCL_CtxAdvertiser) RCL_CtxAdvertiser_Default()
 
struct RCL_CMD_BLE5_INITIATOR_t {
    RCL_Command common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    bool dynamicWinOffset;        
    uint32_t connectTime;         
    RCL_CtxScanInit *ctx;         
    RCL_StatsAdvScanInit *stats;  
};
 
#define RCL_CmdInitiator_Default()                                  \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_INITIATOR,         \
                                  RCL_Handler_BLE5_scan_init),      \
    .channel = 37,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .dynamicWinOffset = 0,                                          \
    .connectTime = 0,                                               \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdInitiator_DefaultRuntime() (RCL_CmdBle5Initiator) RCL_CmdInitiator_Default()
 
struct RCL_CMD_BLE5_SCANNER_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_Command_TxPower txPower;  
    bool activeScan;               
    RCL_CtxScanInit *ctx;          
    RCL_StatsAdvScanInit *stats;   
};
 
#define RCL_CmdScanner_Default()                                    \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_SCANNER,           \
                                  RCL_Handler_BLE5_scan_init),      \
    .channel = 37,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .activeScan = 0,                                                \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdScanner_DefaultRuntime() (RCL_CmdBle5Scanner) RCL_CmdScanner_Default()
 
struct RCL_CTX_SCAN_INIT_t {
    RCL_FilterList *filterList;     
    List_List txBuffers;            
    List_List rxBuffers;            
    uint16_t ownA[3];               
    uint16_t peerA[3];              
    RCL_AddrType addrType;          
    uint8_t filterPolicy : 1;       
    uint8_t scanExtFilterPolicy: 1; 
    uint8_t rpaModeOwn:1;           
    uint8_t rpaModePeer:1;          
    uint16_t initialBackoff;        
    uint8_t backoffUpper;           
    struct
    {
        uint8_t backOffLastFail : 1;
        uint8_t backOffLastSucceed : 1;
        uint8_t reserved  : 6;
    } backoffStatus;              
};
 
#define RCL_CtxScanInit_Default()   \
{                                   \
    .filterList = NULL,             \
    .txBuffers = { 0 },             \
    .rxBuffers = { 0 },             \
    .ownA = { 0 },                  \
    .peerA = { 0 },                 \
    .addrType =  { 0 },             \
    .filterPolicy = 0,              \
    .scanExtFilterPolicy = 0,       \
    .rpaModeOwn = 0,                \
    .rpaModePeer = 0,               \
    .initialBackoff = 1,            \
    .backoffUpper = 0,              \
    .backoffStatus = { 0 },         \
}
#define RCL_CtxScanInit_DefaultRuntime() (RCL_CtxScanInit) RCL_CtxScanInit_Default()
 
struct RCL_STATS_ADV_SCAN_INIT_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   timestampValid;        
    int8_t    lastRssi;              
    uint32_t  lastTimestamp;         
    uint16_t  nRxNok;                
    uint16_t  nRxIgnored;            
    uint16_t  nRxOk;                 
    uint8_t   nRxFifoFull;           
    uint8_t   nTx;                   
};
 
#define RCL_StatsAdvScanInit_Default()  \
{                                       \
    .config = { 0 },                    \
    .timestampValid = 0,                \
    .lastRssi = LRF_RSSI_INVALID,       \
}
#define RCL_StatsAdvScanInit_DefaultRuntime() (RCL_StatsAdvScanInit) RCL_StatsAdvScanInit_Default()
 
struct RCL_CMD_BLE5_CONNECTION_t {
    RCL_Command common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    uint16_t relRxTimeoutTime;    
    RCL_CtxConnection *ctx;       
    RCL_StatsConnection *stats;   
};
 
#define RCL_CmdBle5Connection_Default()                             \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_CONNECTION,        \
                                  RCL_Handler_BLE5_conn),           \
    .channel = 0,                                                   \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdBle5Connection_DefaultRuntime() (RCL_CmdBle5Connection) RCL_CmdBle5Connection_Default()
 
struct RCL_CTX_CONNECTION_t {
    List_List txBuffers;       
    List_List rxBuffers;       
    bool      isPeripheral;    
    uint16_t  seqStat;         
    uint32_t  accessAddress;   
    uint32_t  crcInit;         
};
 
#define _INIT_SEQSTAT (PBE_BLE5_RAM_SEQSTAT_LASTRXSN_BM | \
                       PBE_BLE5_RAM_SEQSTAT_LASTTXSN_BM | \
                       PBE_BLE5_RAM_SEQSTAT_FIRSTPKT_BM )
 
#define RCL_CtxConnection_Default() \
{                                   \
    .txBuffers = { 0 },             \
    .rxBuffers = { 0 },             \
    .isPeripheral = 0,              \
    .seqStat = _INIT_SEQSTAT,       \
    .accessAddress = 0,             \
    .crcInit = 0,                   \
}
#define RCL_CtxConnection_DefaultRuntime() (RCL_CtxConnection) RCL_CtxConnection_Default()
 
struct RCL_STATS_CONNECTION_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   anchorValid;           
    int8_t    lastRssi;              
    uint32_t  anchorPoint;           
    uint8_t   nTxDone;               
    uint8_t   nTxAck;                
    uint8_t   nTxCtlAck;             
    uint8_t   nTxCtl;                
    uint8_t   nTxRetrans;            
    uint8_t   nRxNok;                
    uint8_t   nRxIgnored;            
    uint8_t   nRxEmpty;              
    uint8_t   nRxFifoFull;           
    uint8_t   nRxOk;                 
    uint8_t   nTx;                   
    uint8_t   nRxCtl;                
    uint8_t   nRxCtlAck;             
};
 
#define RCL_StatsConnection_Default()   \
{                                       \
    .config = { 0 },                    \
    .anchorValid = 0,                   \
    .lastRssi = LRF_RSSI_INVALID,       \
}
#define RCL_StatsConnection_DefaultRuntime() (RCL_StatsConnection) RCL_StatsConnection_Default()
 
struct RCL_CMD_BLE5_DTM_TX {
    RCL_Command common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    uint8_t   pduHeader;          
    uint8_t   pduLength;          
    uint8_t   cteInfo;            
    uint16_t  periodUs;           
    uint16_t  numPackets;         
};
 
#define RCL_CmdBle5DtmTx_Default()                          \
{                                                           \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_DTM_TX,    \
                                  RCL_Handler_BLE5_dtmTx),  \
    .channel = 64,                                          \
    .txPower = {.dBm = 0, .fraction = 0},                   \
    .pduHeader = 0x00,                                      \
    .pduLength = 37,                                        \
    .cteInfo = 0x14,                                        \
    .periodUs = 625,                                        \
    .numPackets = 0,                                        \
}
#define RCL_CmdBle5DtmTx_DefaultRuntime() (RCL_CmdBle5DtmTx) RCL_CmdBle5DtmTx_Default()
 
struct RCL_CMD_BLE5_GENERIC_RX_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_CtxGenericRx *ctx;         
    RCL_StatsGenericRx *stats;     
};
 
#define RCL_CmdBle5GenericRx_Default()                              \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_GENERIC_RX,        \
                                  RCL_Handler_BLE5_genericRx),      \
    .channel = 64,                                                  \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdBle5GenericRx_DefaultRuntime() (RCL_CmdBle5GenericRx) RCL_CmdBle5GenericRx_Default()
 
struct RCL_CTX_GENERIC_RX_t {
    List_List rxBuffers;       
    uint32_t  accessAddress;   
    uint32_t  crcInit;         
    uint8_t   maxPktLen;       
    struct {
        uint8_t  repeated: 1;         
        uint8_t  disableSync: 1;      
        uint8_t  discardRxPackets: 1; 
        uint8_t  reserved: 4;         
    } config;
};
 
#define RCL_CtxGenericRx_Default()  \
{                                   \
    .rxBuffers = { 0 },             \
    .accessAddress = 0x71764129U,   \
    .crcInit = 0x555555,            \
    .config = {                     \
        .repeated = 1,              \
        .disableSync = 0,           \
        .discardRxPackets = 1,      \
        .reserved = 0,              \
    },                              \
}
#define RCL_CtxGenericRx_DefaultRuntime() (RCL_CtxGenericRx) RCL_CtxGenericRx_Default()
 
struct RCL_STATS_GENERIC_RX_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   timestampValid;        
    int8_t    lastRssi;              
    uint32_t  lastTimestamp;         
    uint16_t  nRxNok;                
    uint16_t  nRxOk;                 
    uint8_t   nRxFifoFull;           
};
 
#define RCL_StatsGenericRx_Default()    \
{                                       \
    .config =  { 0 },                   \
    .timestampValid = 0,                \
    .lastRssi = LRF_RSSI_INVALID,       \
}
#define RCL_StatsGenericRx_DefaultRuntime() (RCL_StatsGenericRx) RCL_StatsGenericRx_Default()
 
struct RCL_CMD_BLE5_GENERIC_TX_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_Command_TxPower txPower;   
    RCL_CtxGenericTx *ctx;         
};
 
#define RCL_CmdBle5GenericTx_Default()                              \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_GENERIC_TX,        \
                                  RCL_Handler_BLE5_genericTx),      \
    .channel = 64,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .ctx = NULL,                                                    \
}
#define RCL_CmdBle5GenericTx_DefaultRuntime() (RCL_CmdBle5GenericTx) RCL_CmdBle5GenericTx_Default()
 
struct RCL_CTX_GENERIC_TX_t {
    List_List txBuffers;            
    uint32_t  accessAddress;        
    uint32_t  crcInit;              
};
 
#define RCL_CtxGenericTx_Default()  \
{                                   \
    .txBuffers = { 0 },             \
    .accessAddress = 0x71764129U,   \
    .crcInit = 0x555555,            \
}
#define RCL_CtxGenericTx_DefaultRuntime() (RCL_CtxGenericTx) RCL_CtxGenericTx_Default()
 
struct RCL_CMD_BLE5_TX_TEST_t {
    RCL_Command  common;
    uint8_t      channel;           
    RCL_Command_TxPower txPower;    
    uint16_t     txWord;            
    struct {
        uint8_t  whitenMode: 2;     
        uint8_t  sendCw: 1;         
        uint8_t  reserved: 5;       
    } config;
};
 
#define RCL_CmdBle5TxTest_Default()                             \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_TX_TEST,       \
                                  RCL_Handler_Ble5_txTest),     \
    .channel = 64,                                              \
    .txPower = {.dBm = 0, .fraction = 0},                       \
    .txWord = 0,                                                \
    .config = {                                                 \
        .whitenMode = 2,                                        \
        .sendCw = 0,                                            \
        .reserved = 0,                                          \
    },                                                          \
}
#define RCL_CmdBle5TxTest_DefaultRuntime() (RCL_CmdBle5TxTest) RCL_CmdBle5TxTest_Default()
 
#define RCL_CMD_BLE5_WH_MODE_DEFAULT  0 
#define RCL_CMD_BLE5_WH_MODE_PRBS9    1 
#define RCL_CMD_BLE5_WH_MODE_PRBS15   2 
#define RCL_CMD_BLE5_WH_MODE_PRBS32   3 
#endif