generic.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-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_generic_h__include
#define ti_drivers_RCL_commands_generic_h__include

#include <ti/drivers/rcl/RCL_Command.h>
#include <ti/drivers/rcl/RCL_Buffer.h>
#include <ti/drivers/rcl/handlers/generic.h>

#include <ti/drivers/utils/List.h>

#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(inc/pbe_generic_ram_regs.h)
#include DeviceFamily_constructPath(inc/pbe_generic_regdef_regs.h)

typedef struct RCL_CMD_GENERIC_FS_t            RCL_CmdGenericFs;
typedef struct RCL_CMD_GENERIC_FS_OFF_t        RCL_CmdGenericFsOff;
typedef struct RCL_CMD_GENERIC_TX_t            RCL_CmdGenericTx;
typedef struct RCL_CMD_GENERIC_TX_REPEAT_t     RCL_CmdGenericTxRepeat;
typedef struct RCL_CMD_GENERIC_TX_TEST_t       RCL_CmdGenericTxTest;
typedef struct RCL_CMD_GENERIC_RX_t            RCL_CmdGenericRx;
typedef struct RCL_CMD_GENERIC_PBE_OPERATION_t RCL_CmdGenericPbeOperation;
typedef struct RCL_STATS_GENERIC_t             RCL_StatsGeneric;
typedef struct RCL_CMD_NESB_PTX_t              RCL_CmdNesbPtx;
typedef struct RCL_CMD_NESB_PRX_t              RCL_CmdNesbPrx;
typedef struct RCL_STATS_NESB_t                RCL_StatsNesb;
typedef struct RCL_CONFIG_ADDRESS_t            RCL_ConfigAddress;

/* Command IDs for generic commands */
#define RCL_CMDID_GENERIC_FS            0x0001U
#define RCL_CMDID_GENERIC_FS_OFF        0x0002U
#define RCL_CMDID_GENERIC_TX            0x0003U
#define RCL_CMDID_GENERIC_TX_REPEAT     0x0004U
#define RCL_CMDID_GENERIC_TX_TEST       0x0005U
#define RCL_CMDID_GENERIC_RX            0x0006U
#define RCL_CMDID_GENERIC_PBE_OPERATION 0x0007U
#define RCL_CMDID_NESB_PTX              0x0008U
#define RCL_CMDID_NESB_PRX              0x0009U


typedef enum RCL_FsType_e {
    RCL_FsType_Rx,               
    RCL_FsType_Tx,               
} RCL_FsType;

struct RCL_CMD_GENERIC_FS_t {
    RCL_Command     common;
    uint32_t        rfFrequency; 
    RCL_FsType      fsType;      
};

#define RCL_CmdGenericFs_Default()                          \
{                                                           \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_FS,     \
                                  RCL_Handler_Generic_Fs),  \
    .rfFrequency = 2440000000U,                             \
    .fsType = RCL_FsType_Rx,                                \
}
#define RCL_CmdGenericFs_DefaultRuntime() (RCL_CmdGenericFs) RCL_CmdGenericFs_Default()

struct RCL_CMD_GENERIC_FS_OFF_t {
    RCL_Command     common;
};

#define RCL_CmdGenericFsOff_Default()                           \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_FS_OFF,     \
                                  RCL_Handler_Generic_FsOff),   \
}
#define RCL_CmdGenericFsOff_DefaultRuntime() (RCL_CmdGenericFsOff) RCL_CmdGenericFsOff_Default()


struct RCL_CMD_GENERIC_TX_t {
    RCL_Command     common;
    uint32_t        rfFrequency; 
    List_List       txBuffers;   
    uint32_t        syncWord;    
    RCL_Command_TxPower txPower; 
    struct {
        uint8_t     fsOff: 1;    
        uint8_t     reserved: 7; 
    } config;
};
#define RCL_CmdGenericTx_Default()                          \
{                                                           \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_TX,     \
                                  RCL_Handler_Generic_Tx),  \
    .rfFrequency = 2440000000U,                             \
    .txBuffers = { 0 },                                     \
    .syncWord = 0x930B51DE,                                 \
    .txPower = {.dBm = 0, .fraction = 0},                   \
    .config = {                                             \
        .fsOff = 1,                                         \
        .reserved = 0,                                      \
    },                                                      \
}
#define RCL_CmdGenericTx_DefaultRuntime() (RCL_CmdGenericTx) RCL_CmdGenericTx_Default()

struct RCL_CMD_GENERIC_TX_REPEAT_t {
    RCL_Command          common;
    uint32_t             rfFrequency; 
    RCL_Buffer_DataEntry *txEntry;    
    uint32_t             syncWord;    
    uint32_t             timePeriod;  
    uint16_t             numPackets;  
    RCL_Command_TxPower  txPower;     
    struct {
        uint8_t          fsOff: 1;    
        uint8_t          fsRecal: 1;  
        uint8_t          reserved: 6; 
    } config;
};
#define RCL_CmdGenericTxRepeat_Default()                        \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_TX_REPEAT,  \
                                  RCL_Handler_Generic_TxRepeat),\
    .rfFrequency = 2440000000U,                                 \
    .txEntry = NULL,                                            \
    .syncWord = 0x930B51DE,                                     \
    .timePeriod = 0,                                            \
    .numPackets = 0,                                            \
    .config = {                                                 \
        .fsOff = 1,                                             \
        .fsRecal = 0,                                           \
        .reserved = 0,                                          \
    },                                                          \
}
#define RCL_CmdGenericTxRepeat_DefaultRuntime() (RCL_CmdGenericTxRepeat) RCL_CmdGenericTxRepeat_Default()

struct RCL_CMD_GENERIC_TX_TEST_t {
    RCL_Command     common;
    uint32_t        rfFrequency;   
    RCL_Command_TxPower txPower;   
    struct {
        uint32_t     txWord: 16;   
        uint32_t     whitenMode: 2;
        uint32_t     sendCw: 1;    
        uint32_t     fsOff: 1;     
        uint32_t     reserved: 12; 
    } config;
};
#define RCL_CmdGenericTxTest_Default()                          \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_TX_TEST,    \
                                  RCL_Handler_Generic_TxTest),  \
    .rfFrequency = 2440000000U,                                 \
    .txPower = {.dBm = 0, .fraction = 0},                       \
    .config = {                                                 \
        .txWord = 0,                                            \
        .whitenMode = 2,                                        \
        .sendCw = 0,                                            \
        .fsOff = 1,                                             \
        .reserved = 0,                                          \
    },                                                          \
}
#define RCL_CmdGenericTxTest_DefaultRuntime() (RCL_CmdGenericTxTest) RCL_CmdGenericTxTest_Default()

#define RCL_CMD_GENERIC_WH_MODE_NONE     0 
#define RCL_CMD_GENERIC_WH_MODE_DEFAULT  1 
#define RCL_CMD_GENERIC_WH_MODE_PRBS15   2 
#define RCL_CMD_GENERIC_WH_MODE_PRBS32   3 
struct RCL_CMD_GENERIC_RX_t {
    RCL_Command     common;
    uint32_t        rfFrequency;         
    List_List       rxBuffers;           
    RCL_StatsGeneric *stats;             
    uint32_t        syncWordA;           
    uint32_t        syncWordB;           
    uint16_t        maxPktLen;           
    struct {
        uint8_t     repeated: 1;         
        uint8_t     disableSyncA: 1;     
        uint8_t     disableSyncB: 1;     
        uint8_t     discardRxPackets: 1; 
        uint8_t     fsOff: 1;            
        uint8_t     reserved: 3;         
    } config;
};
#define RCL_CmdGenericRx_Default()                          \
{                                                           \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_RX,     \
                                  RCL_Handler_Generic_Rx),  \
    .rfFrequency = 2440000000U,                             \
    .rxBuffers = {0},                                       \
    .stats = NULL,                                          \
    .syncWordA = 0x930B51DE,                                \
    .syncWordB = 0x12345678,                                \
    .maxPktLen = 255,                                       \
    .config = {                                             \
        .repeated = 1,                                      \
        .disableSyncA = 0,                                  \
        .disableSyncB = 1,                                  \
        .discardRxPackets = 0,                              \
        .fsOff = 1,                                         \
        .reserved = 0,                                      \
    },                                                      \
}
#define RCL_CmdGenericRx_DefaultRuntime() (RCL_CmdGenericRx) RCL_CmdGenericRx_Default()

struct RCL_STATS_GENERIC_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   timestampValid;        
    int8_t    lastRssi;              
    uint32_t  lastTimestamp;         
    uint32_t  nRxNok;                
    uint32_t  nRxOk;                 
};

#define RCL_StatsGeneric_Default()  \
{                                   \
    .config = { 0 },                \
    .timestampValid = 0,            \
    .lastRssi = LRF_RSSI_INVALID,   \
}
#define RCL_StatsGeneric_DefaultRuntime() (RCL_StatsGeneric) RCL_StatsGeneric_Default()

struct RCL_CMD_GENERIC_PBE_OPERATION_t {
    RCL_Command     common;
    uint16_t        pbeOperation;     
};

#define RCL_CmdGenericPbeOperation_Default()                        \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_GENERIC_PBE_OPERATION,  \
                                  RCL_Handler_Generic_PbeOperation),\
    .pbeOperation =  PBE_GENERIC_REGDEF_API_OP_PING,                \
}
#define RCL_CmdGenericPbeOperation_DefaultRuntime() (RCL_CmdGenericPbeOperation) RCL_CmdGenericPbeOperation_Default()

struct RCL_CMD_NESB_PTX_t {
    RCL_Command     common;
    uint32_t        rfFrequency;            
    List_List       txBuffers;              
    List_List       rxBuffers;              
    RCL_StatsNesb   *stats;                
    uint32_t        syncWord;               
    RCL_Command_TxPower txPower;            
    uint8_t         seqNo;                  
    uint8_t         maxRetrans;             
    uint32_t        retransDelay;           
    struct {
        uint8_t     fsOff: 1;               
        uint8_t     autoRetransmitMode: 2;  
        uint8_t     hdrConf: 1;             
        uint8_t     reserved: 4;            
    } config;
};
#define RCL_CmdNesbPtx_Default()                                   \
{                                                                  \
    .common = RCL_Command_Default(RCL_CMDID_NESB_PTX,              \
                                  RCL_Handler_Nesb_Ptx),           \
    .rfFrequency = 2440000000U,                                    \
    .txBuffers = { 0 },                                            \
    .rxBuffers = { 0 },                                            \
    .stats = NULL,                                                 \
    .syncWord = 0x930B51DE,                                        \
    .txPower = {.dBm = 0, .fraction = 0},                          \
    .seqNo = 0,                                                    \
    .maxRetrans = 5,                                               \
    .retransDelay = 100000,                                        \
    .config = {                                                    \
        .fsOff = 1,                                                \
        .autoRetransmitMode = 3,                                   \
        .hdrConf = 1,                                              \
        .reserved = 0,                                             \
    }                                                              \
}
#define RCL_CmdNesbPtx_DefaultRuntime() (RCL_CmdNesbPtx) RCL_CmdNesbPtx_Default()

struct RCL_CONFIG_ADDRESS_t {
    uint32_t    address;                
    uint16_t    crcVal;                 
    uint8_t     maxPktLen;              
    uint8_t     autoAckMode: 2;         
    uint8_t     varLen: 1;              
    uint8_t     seqValid: 1;            
    uint8_t     seq: 2;                 
    uint8_t     reserved: 2;            
};

#define RCL_ConfigAddress_Default(_addr)       \
{                                              \
    .address = _addr,                          \
    .crcVal = 0,                               \
    .maxPktLen = 255,                          \
    .autoAckMode = 3,                          \
    .varLen = 1,                               \
    .seqValid = 0,                             \
    .seq = 1,                                  \
    .reserved = 0,                             \
}
#define RCL_ConfigAddress_DefaultRuntime(_addr) (RCL_ConfigAddress) RCL_ConfigAddress_Default(_addr)


struct RCL_CMD_NESB_PRX_t {
    RCL_Command     common;
    uint32_t        rfFrequency;            
    List_List       rxBuffers;              
    RCL_StatsNesb   *stats;                
    uint32_t        syncWordA;              
    uint32_t        syncWordB;              
    RCL_Command_TxPower txPower;            
    uint8_t         addrLen;                
    struct {
        uint8_t     disableSyncA: 1;        
        uint8_t     disableSyncB: 1;        
        uint8_t     discardRxPackets: 1;    
        uint8_t     fsOff: 1;               
        uint8_t     repeatOk: 1;            
        uint8_t     repeatNok: 1;           
        uint8_t     reserved: 2;            
    } config;
    union {
        RCL_ConfigAddress syncWord[2];
        struct {
            RCL_ConfigAddress syncWordACfg;
            RCL_ConfigAddress syncWordBCfg;
        };
    };
};
#define RCL_CmdNesbPrx_Default()                                   \
{                                                                  \
    .common = RCL_Command_Default(RCL_CMDID_NESB_PRX,              \
                                  RCL_Handler_Nesb_Prx),           \
    .rfFrequency = 2440000000U,                                    \
    .rxBuffers = {0},                                              \
    .stats = NULL,                                                 \
    .syncWordA = 0x930B51DE,                                       \
    .syncWordB = 0x570451AE,                                       \
    .txPower = {.dBm = 0, .fraction = 0},                          \
    .addrLen = 4,                                                  \
    .config = {                                                    \
        .disableSyncA = 0,                                         \
        .disableSyncB = 1,                                         \
        .discardRxPackets = 0,                                     \
        .fsOff = 1,                                                \
        .repeatOk = 1,                                             \
        .repeatNok = 0,                                            \
        .reserved = 0,                                             \
    },                                                             \
    .syncWord[0] = RCL_ConfigAddress_Default(0xEFFEABBA),          \
    .syncWord[1] = RCL_ConfigAddress_Default(0xEFFEABBC)           \
}
#define RCL_CmdNesbPrx_DefaultRuntime() (RCL_CmdNesbPrx) RCL_CmdNesbPrx_Default()

struct RCL_STATS_NESB_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   timestampValid;        
    int8_t    lastRssi;              
    uint32_t  lastTimestamp;         
    uint32_t  nTx;                   
    uint32_t  nRxNok;                
    uint32_t  nRxOk;                 
    uint32_t  nRxIgnored;            
    uint32_t  nRxAddrMismatch;       
    uint32_t  nRxBufFull;            
};

#define RCL_StatsNesb_Default()  \
{                                   \
    .config = { 0 },                \
    .timestampValid = 0,            \
    .lastRssi = -128,               \
}
#define RCL_StatsNesb_DefaultRuntime() (RCL_StatsNesb) RCL_StatsNesb_Default()


#endif