ble_cs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022-2025, 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_ble_cs_h__include
#define ti_drivers_RCL_commands_ble_cs_h__include

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

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

/* Forward declaration of types */
typedef struct RCL_CMD_BLE_CS_t                           RCL_CmdBleCs;
typedef struct RCL_CMD_BLE_CS_STEP_INTERNAL_t             RCL_CmdBleCs_Step_Internal;
typedef struct RCL_CMD_BLE_CS_STEP_RESULT_INTERNAL_t      RCL_CmdBleCs_StepResult_Internal;
typedef struct RCL_CMD_BLE_CS_STEP_t                      RCL_CmdBleCs_Step;
typedef struct RCL_CMD_BLE_CS_SUBEVENT_RESULTS_t          RCL_CmdBleCs_SubeventResults;
typedef struct RCL_CMD_BLE_CS_SUBEVENT_RESULTS_CONTINUE_t RCL_CmdBleCs_SubeventResultsContinue;
typedef struct RCL_CMD_BLE_CS_S2R_t                       RCL_CmdBleCs_S2r;
typedef struct RCL_CMD_BLE_CS_STATS_t                     RCL_CmdBleCs_Stats;
typedef struct RCL_CMD_BLE_CS_IQ_SAMPLE_t                 RCL_CmdBleCs_IQSample;
typedef struct RCL_CMD_BLE_CS_DC_SAMPLE_t                 RCL_CmdBleCs_DCSample;
typedef struct RCL_CMD_BLE_CS_PRECAL_t                    RCL_CmdBleCs_Precal;
typedef struct RCL_CMD_BLE_CS_PRECAL_TABLE_t              RCL_CmdBleCs_PrecalTable;
typedef struct RCL_CMD_BLE_CS_PRECAL_ENTRY_t              RCL_CmdBleCs_PrecalEntry;

typedef struct RCL_CMD_BLE_CS_PCT_COMP_TABLE_t            RCL_CmdBleCs_PctCompTable;
typedef struct RCL_CMD_BLE_CS_PCT_COMP_ENTRY_t            RCL_CmdBleCs_PctCompEntry;

typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_TONE_t         RCL_CmdBleCs_Tone;
typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_t              RCL_CmdBleCs_Result;
typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_I0_t           RCL_CmdBleCs_ResultI0;
typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_R0_t           RCL_CmdBleCs_ResultR0;
typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_IR1_t          RCL_CmdBleCs_ResultIR1;
typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_IR2_t          RCL_CmdBleCs_ResultIR2;
typedef struct RCL_CMD_BLE_CS_STEP_RESULTS_IR3_t          RCL_CmdBleCs_ResultIR3;

typedef enum   RCL_CMD_BLE_CS_Phy_e                       RCL_CmdBleCs_Phy;
typedef enum   RCL_CMD_BLE_CS_Role_e                      RCL_CmdBleCs_Role;
typedef enum   RCL_CMD_BLE_CS_StepMode_e                  RCL_CmdBleCs_StepMode;
typedef enum   RCL_CMD_BLE_CS_PacketResult_e              RCL_CmdBleCs_PacketResult;
typedef enum   RCL_CMD_BLE_CS_Tfcs_e                      RCL_CmdBleCs_Tfcs;
typedef enum   RCL_CMD_BLE_CS_Tpm_e                       RCL_CmdBleCs_Tpm;
typedef enum   RCL_CMD_BLE_CS_Tip_e                       RCL_CmdBleCs_Tip;
typedef enum   RCL_CMD_BLE_CS_Tsw_e                       RCL_CmdBleCs_Tsw;
typedef enum   RCL_CMD_BLE_CS_AntennaConfig_e             RCL_CmdBleCs_AntennaConfig;
typedef enum   RCL_CMD_BLE_CS_Payload_e                   RCL_CmdBleCs_Payload;
typedef enum   RCL_CMD_BLE_CS_RxGain_e                    RCL_CmdBleCs_RxGain;
typedef enum   RCL_CMD_BLE_CS_ToneQuality_e               RCL_CmdBleCs_ToneQuality;
typedef enum   RCL_CMD_BLE_CS_ToneExtensionSlot_e         RCL_CmdBleCs_ToneExtensionSlot;

typedef enum   RCL_CMD_BLE_CS_ReportFormat_e              RCL_CmdBleCs_ReportFormat;
typedef enum   RCL_CMD_BLE_CS_PacketAntenna_e             RCL_CmdBleCs_PacketAntenna;
typedef enum   RCL_CMD_BLE_CS_Nadm_e                      RCL_CmdBleCs_Nadm;

/* Command IDs for generic commands */
#define RCL_CMDID_BLE_CS                        0x1101U
#define RCL_CMDID_BLE_CS_PRECAL                 0x1102U

/* Helper macros to convert between time units */
#define RCL_BLE_CS_US_TO_MCE_TIMER(x)           ((x)*48)
#define RCL_BLE_CS_US_TO_PBE_TIMER(x)           ((x)*4)
#define RCL_BLE_CS_MCE_TIMER_TO_US(x)           ((x)/48)
#define RCL_BLE_CS_PBE_TIMER_TO_US(x)           ((x)/12)
#define RCL_BLE_CS_MCE_TIMER_TO_PBE_TIMER(x)    ((x)/4)
#define RCL_BLE_CS_DELAY_PS_TO_LUT(x)           (((x)+16)/32)

/* Helper macros for constants */
#define RCL_BLE_CS_MAX_NUM_ANT                  4
#define RCL_BLE_CS_MAX_NUM_ANT_PATH             5
#define RCL_BLE_CS_MAX_PAYLOAD_SIZE             4
#define RCL_BLE_CS_NUM_CORR                     3
#define RCL_BLE_CS_NUM_STIM                     2
#define RCL_BLE_CS_MAX_S2R_LEN                  1024
#define RCL_BLE_CS_NUM_RX_GAIN_LEVEL            2
#define RCL_BLE_CS_STEP_RX_GAIN_DB              3
#define RCL_BLE_CS_NUM_PRECAL_CHANNELS          8

struct RCL_CMD_BLE_CS_IQ_SAMPLE_t {
    int16_t i;   
    int16_t q;   
};

struct RCL_CMD_BLE_CS_t {
    RCL_Command common;
    union {
        struct {
            uint16_t role:2;                         
            uint16_t phy:2;                          
            uint16_t repeatSteps:1;                  
            uint16_t chFilterEnable:1;               
            uint16_t precal:1;                       
            uint16_t reserved:1;
            uint16_t nSteps:8;                       
        };
        uint16_t val;
    } mode;

    struct {
        uint8_t select;                          
        uint8_t gpoMask;                         
        uint8_t gpoVal[RCL_BLE_CS_MAX_NUM_ANT];  
    } antennaConfig;

    struct {
        uint16_t tFcs;                           
        uint16_t tFm;                            
        uint16_t tPm;                            
        uint16_t tIp1;                           
        uint16_t tIp2;                           
        uint16_t tRxWideningR0;                  
        uint16_t tSw;                            
        uint16_t tSwAdjustA;                     
        uint16_t tSwAdjustB;                     
    } timing;

    struct {
        RCL_Command_TxPower txPower;              
        uint8_t  rxGain;                          
    } frontend;

    int16_t foffOverride;                         
    uint8_t foffOverrideEnable:1;                 
    uint8_t reportFormat;                         
    RCL_CmdBleCs_PrecalTable *precalTable;        
    RCL_CmdBleCs_StepResult_Internal *results;    
    RCL_CmdBleCs_Stats *stats;                    
    List_List           stepBuffers;              
    List_List           stepBuffersDone;          
    List_List           resultBuffers;            
    List_List           resultBuffersDone;        
    List_List           s2rBuffers;               
    List_List           s2rBuffersDone;           
};

/* Default configuration of command */
#define RCL_CmdBleCs_Default()                          \
{                                                       \
    .common = RCL_Command_Default(RCL_CMDID_BLE_CS,     \
                                  RCL_Handler_BLE_CS),  \
}
#define RCL_CmdBleCs_DefaultRuntime() (RCL_CmdBleCs) RCL_CmdBleCs_Default()

struct RCL_CMD_BLE_CS_STEP_INTERNAL_t {
    uint16_t channelIdx;                             
    uint16_t mode;                                   
    uint16_t toneExtension;                          
    uint16_t payloadLen;                             
    uint16_t foffErr;                                
    uint16_t tAdjustA;                               
    uint16_t tAdjustB;                               
    uint16_t reserved0;
    RCL_CmdBleCs_IQSample dcComp[RCL_BLE_CS_NUM_RX_GAIN_LEVEL]; 
    uint32_t payloadTx[RCL_BLE_CS_MAX_PAYLOAD_SIZE]; 
    uint32_t payloadRx[RCL_BLE_CS_MAX_PAYLOAD_SIZE]; 
    uint32_t aaTx;                                   
    uint32_t aaRx;                                   
    uint8_t  antennaPermIdx;                         
    uint8_t  antennaPacket;                          
    uint16_t antennaSequence;                        
    uint16_t tStep;                                  
    uint16_t tAntennaA;                              
    uint16_t tAntennaB;                              
    uint16_t reserved1;
};

typedef struct {
    int16_t magnMin;     
    int16_t magnMax;     
    int16_t magnAvg;     
    int16_t magnAvgdB;   
} MagnData;

struct RCL_CMD_BLE_CS_STEP_RESULT_INTERNAL_t {
    uint16_t channelIdx;                                    
    uint16_t mode;                                          
    uint16_t toneExtension;                                 
    uint16_t payloadLen;                                    
    uint16_t reserved;
    int16_t  foffMeasured;                                  
    uint16_t pktResult;                                     
    uint8_t  gain;                                          
    int8_t   pktRssi;                                       
    uint16_t rtt;                                           
    uint16_t corr[RCL_BLE_CS_NUM_CORR];                     
    RCL_CmdBleCs_IQSample dc;                               
    RCL_CmdBleCs_IQSample pct[RCL_BLE_CS_MAX_NUM_ANT_PATH]; 
    uint32_t payload[RCL_BLE_CS_MAX_PAYLOAD_SIZE];          
    MagnData magn[RCL_BLE_CS_MAX_NUM_ANT_PATH];             
    /* Echoed by PBE */
    uint8_t  antennaPermIdx;                                
    uint8_t  antennaPacket;                                 
    uint16_t reserved1;
};

typedef union {
    uint32_t word;                 
    uint8_t  byte[4];              
    RCL_CmdBleCs_IQSample iq;      
} S2RSample;

struct RCL_CMD_BLE_CS_S2R_t {
    uint8_t   idx;                 
    uint8_t   phy;                 
    uint8_t   channel;             
    uint8_t   payloadLen;          
    uint32_t  payload0;            
    uint32_t  payload1;            
    uint32_t  payload2;            
    uint32_t  payload3;            
    uint16_t  iqLength;            
    uint16_t  reserved;
    S2RSample data[];              
};

struct RCL_CMD_BLE_CS_STATS_t {
    uint16_t nStepsWritten;                             
    uint16_t nResultsRead;                              
    uint16_t nStepsDone;                                
    uint16_t nRxOk;                                     
    uint16_t nRxNok;                                    
    uint8_t  nS2RDone;                                  
    int8_t   lastRssi;                                  
    int16_t  lastFoff;                                  
    int16_t  foffComp;                                  
    uint8_t  numAntennaPath;                            
    uint8_t  rplScaler;                                 
    uint16_t reserved;
};

enum RCL_CMD_BLE_CS_Phy_e {
    RCL_CmdBleCs_Phy_1M,    
    RCL_CmdBleCs_Phy_2M,    
    RCL_CmdBleCs_Phy_2M2BT, 
    RCL_CmdBleCs_Phy_Length
};

enum RCL_CMD_BLE_CS_Role_e {
    RCL_CmdBleCs_Role_Initiator, 
    RCL_CmdBleCs_Role_Reflector, 
    RCL_CmdBleCs_Role_Length
};

enum RCL_CMD_BLE_CS_StepMode_e {
    RCL_CmdBleCs_StepMode_0,       
    RCL_CmdBleCs_StepMode_1,       
    RCL_CmdBleCs_StepMode_2,       
    RCL_CmdBleCs_StepMode_3,       
    RCL_CmdBleCs_StepMode_Length
};

enum RCL_CMD_BLE_CS_PacketResult_e {
    RCL_CmdBleCs_PacketResult_Error     = -1,   
    RCL_CmdBleCs_PacketResult_Ok        =  0,   
    RCL_CmdBleCs_PacketResult_BitError  =  1,   
    RCL_CmdBleCs_PacketResult_Lost      =  2,   
    RCL_CmdBleCs_PacketResult_Length
};

enum RCL_CMD_BLE_CS_Tfcs_e {
    RCL_CmdBleCs_Tfcs_80us,     
    RCL_CmdBleCs_Tfcs_100us,
    RCL_CmdBleCs_Tfcs_120us,
    RCL_CmdBleCs_Tfcs_150us,    
    RCL_CmdBleCs_Tfcs_Length,
};

enum RCL_CMD_BLE_CS_Tpm_e {
    RCL_CmdBleCs_Tpm_10us,
    RCL_CmdBleCs_Tpm_20us,
    RCL_CmdBleCs_Tpm_40us,      
    RCL_CmdBleCs_Tpm_Length,
};

enum RCL_CMD_BLE_CS_Tip_e {
    RCL_CmdBleCs_Tip_40us,      
    RCL_CmdBleCs_Tip_50us,
    RCL_CmdBleCs_Tip_60us,
    RCL_CmdBleCs_Tip_80us,      
    RCL_CmdBleCs_Tip_145us,     
    RCL_CmdBleCs_Tip_Length,
};

enum RCL_CMD_BLE_CS_Tsw_e {
    RCL_CmdBleCs_Tsw_0us,       
    RCL_CmdBleCs_Tsw_1us,
    RCL_CmdBleCs_Tsw_2us,
    RCL_CmdBleCs_Tsw_4us,
    RCL_CmdBleCs_Tsw_10us,      
    RCL_CmdBleCs_Tsw_Length
};

enum RCL_CMD_BLE_CS_AntennaConfig_e {
    RCL_CmdBleCs_AntennaConfig_1x1,     
    RCL_CmdBleCs_AntennaConfig_2x1,
    RCL_CmdBleCs_AntennaConfig_3x1,
    RCL_CmdBleCs_AntennaConfig_4x1,
    RCL_CmdBleCs_AntennaConfig_1x2,
    RCL_CmdBleCs_AntennaConfig_1x3,
    RCL_CmdBleCs_AntennaConfig_1x4,
    RCL_CmdBleCs_AntennaConfig_2x2,
    RCL_CmdBleCs_AntennaConfig_Length,
};

enum RCL_CMD_BLE_CS_Payload_e {
    RCL_CmdBleCs_Payload_None,
    RCL_CmdBleCs_Payload_32bit,
    RCL_CmdBleCs_Payload_64bit,
    RCL_CmdBleCs_Payload_96bit,
    RCL_CmdBleCs_Payload_128bit,
    RCL_CmdBleCs_Payload_Length
};

enum RCL_CMD_BLE_CS_RxGain_e {
    RCL_CmdBleCs_RxGain_Auto = 0,
    RCL_CmdBleCs_RxGain_Low  = 7,
    RCL_CmdBleCs_RxGain_High = 15
};

enum RCL_CMD_BLE_CS_ToneQuality_e {
    RCL_CmdBleCs_ToneQuality_High,
    RCL_CmdBleCs_ToneQuality_Medium,
    RCL_CmdBleCs_ToneQuality_Low,
    RCL_CmdBleCs_ToneQuality_Unavailable,
    RCL_CmdBleCs_ToneQuality_Length
};

enum RCL_CMD_BLE_CS_ToneExtensionSlot_e {
    RCL_CmdBleCs_ToneExtensionSlot_Disabled,
    RCL_CmdBleCs_ToneExtensionSlot_Enabled_NoToneExpected,
    RCL_CmdBleCs_ToneExtensionSlot_Enabled_ToneExpected,
    RCL_CmdBleCs_ToneExtensionSlot_Length
};

enum RCL_CMD_BLE_CS_ReportFormat_e {
    RCL_CmdBleCs_ReportFormat_HCI = 0,
    RCL_CmdBleCs_ReportFormat_Custom = 1
};

/*****************************************************
    DC precalibration
*****************************************************/

typedef void (*RCL_CmdBleCs_PrecalCallback)(RCL_CmdBleCs_PrecalTable *table, uint8_t channel, RCL_CmdBleCs_IQSample *pHigh, RCL_CmdBleCs_IQSample *pLow);

struct RCL_CMD_BLE_CS_DC_SAMPLE_t {
    int16_t  i;             
    int16_t  q;             
    int8_t   phaseStart;    
    int8_t   phaseStop;     
    uint16_t magnMin;       
    uint16_t magnMax;       
    uint16_t magnAvg;       
};

struct RCL_CMD_BLE_CS_PRECAL_ENTRY_t {
    uint8_t channel;
    uint8_t lowValid  : 1;
    uint8_t highValid : 1;
    RCL_CmdBleCs_DCSample high;
    RCL_CmdBleCs_DCSample low;
};

struct RCL_CMD_BLE_CS_PRECAL_TABLE_t {
    RCL_CmdBleCs_PrecalCallback callback;
    uint32_t timestamp;
    uint8_t  highThreshold;
    uint8_t  lowThreshold;
    uint8_t  rxGain;
    int8_t   temperature;
    uint8_t  chSpacing;
    uint8_t  numEntries : 7;
    uint8_t  valid      : 1;
    RCL_CmdBleCs_PrecalEntry entries[];
};

/* Default callback implemented in the driver */
void RCL_Handler_BLE_CS_PrecalDefaultCallback(RCL_CmdBleCs_PrecalTable *table, uint8_t channel, RCL_CmdBleCs_IQSample *pHigh, RCL_CmdBleCs_IQSample *pLow);

/* Default configuration of DC precalibration */
#define RCL_CmdBleCs_PrecalTable_Default()                     \
{                                                              \
    .callback      = RCL_Handler_BLE_CS_PrecalDefaultCallback, \
    .timestamp     = 0,                                        \
    .highThreshold = 50,                                       \
    .lowThreshold  = 10,                                       \
    .rxGain        = 0xF7,                                     \
    .temperature   = 0,                                        \
    .chSpacing     = 10,                                       \
    .numEntries    = 8,                                        \
    .valid         = 0,                                        \
    .entries       = {{.channel =  5},                         \
                      {.channel = 15},                         \
                      {.channel = 25},                         \
                      {.channel = 35},                         \
                      {.channel = 45},                         \
                      {.channel = 55},                         \
                      {.channel = 65},                         \
                      {.channel = 75}},                        \
}

struct RCL_CMD_BLE_CS_PRECAL_t {
    RCL_Command               common;
    RCL_CmdBleCs_PrecalTable *table;
};

/* Default configuration of DC precalibration command */
#define RCL_CmdBleCs_Precal_Default(pTable)                    \
{                                                              \
    .common = RCL_Command_Default(RCL_CMDID_BLE_CS_PRECAL,     \
                                  RCL_Handler_BLE_CS_Precal),  \
    .table  = pTable                                           \
}
#define RCL_CmdBleCs_Precal_DefaultRuntime(pTable) (RCL_CmdBleCs_Precal) RCL_CmdBleCs_Precal_Default(pTable)

/*****************************************************
    PCT compensation for antenna/front-end delay
*****************************************************/

struct RCL_CMD_BLE_CS_PCT_COMP_ENTRY_t {
    uint8_t phaseDelay;                 
    uint8_t magnCoeff;                  
};

struct RCL_CMD_BLE_CS_PCT_COMP_TABLE_t {
    uint8_t firstChannelIdx;            
    uint8_t chSpacing          : 7;     
    uint8_t enPhaseComp        : 1;     
    uint8_t enMagnComp         : 1;     
    uint8_t numEntries         : 7;     
    RCL_CmdBleCs_PctCompEntry entries[];
};


/* Adjust RCL_BLE_CS_PHASE_DELAY_PS for linear PCT phase compensation due to antenna/front-end design,
 * or adjust RCL_CmdBleCs_PctCompTable bleCsPctCompTable, using a calibrated instrument */
#ifndef RCL_BLE_CS_PHASE_DELAY_PS
#ifdef DeviceFamily_CC27XX
    /* Example: LP-EM-CC2745R10-Q1 Launchpad development kit, SMA port */
    #define RCL_BLE_CS_PHASE_DELAY_PS  (1100UL)
#else
    /* Example: LP-EM-CC2340R5 Launchpad development kit, SMA port */
    #define RCL_BLE_CS_PHASE_DELAY_PS  (1500UL)
#endif
#endif

/* Default PCT compensation table: Only phase comp. Channels: 2402, 2402+n*8, ..., 2402+(11-1)*8 = 2482MHz */
#define RCL_CmdBleCs_PctCompTable_Default()                                                     \
{                                                                                               \
    .firstChannelIdx = 0,                                                                       \
    .chSpacing       = 8,                                                                       \
    .enPhaseComp     = 1,                                                                       \
    .enMagnComp      = 0,                                                                       \
    .numEntries      = 11,                                                                      \
    .entries         = {{.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)},  \
                        {.phaseDelay = RCL_BLE_CS_DELAY_PS_TO_LUT(RCL_BLE_CS_PHASE_DELAY_PS)}}, \
}


/*****************************************************
    HCI interface
*****************************************************/

/* Special values for categorical parameters */
enum RCL_CMD_BLE_CS_PacketAntenna_e {
    RCL_CmdBleCs_PacketAntenna_1 = 1, 
    RCL_CmdBleCs_PacketAntenna_2 = 2,
    RCL_CmdBleCs_PacketAntenna_3 = 3,
    RCL_CmdBleCs_PacketAntenna_4 = 4,
};

enum RCL_CMD_BLE_CS_Nadm_e {
    RCL_CmdBleCs_Nadm_ExtremelyUnlikely,
    RCL_CmdBleCs_Nadm_VeryUnlikely,
    RCL_CmdBleCs_Nadm_Unlikely,
    RCL_CmdBleCs_Nadm_Possible,
    RCL_CmdBleCs_Nadm_Likely,
    RCL_CmdBleCs_Nadm_VeryLikely,
    RCL_CmdBleCs_Nadm_ExtremelyLikely,
    RCL_CmdBleCs_Nadm_Unknown = 0xFF 
};

/* Special values for linear parameters */
#define RCL_CMD_BLE_CS_FREQCOMP_NA  0xC000
#define RCL_CMD_BLE_CS_TOAD_NA      0x8000
#define RCL_CMD_BLE_CS_RSSI_NA      0x7F

/* Opcodes */
#define RCL_CMD_BLE_CS_SUBEVENT_RESULTS_OPCODE           0x31
#define RCL_CMD_BLE_CS_SUBEVENT_RESULTS_CONTINUE_OPCODE  0x32

struct RCL_CMD_BLE_CS_STEP_t {
    uint32_t channelIdx : 7;                         
    uint32_t mode : 2;                               
    uint32_t antennaPacket: 3;                       
    uint32_t antennaPermIdx : 5;                     
    uint32_t toneExtension : 2;                      
    uint32_t payloadLen : 3;                         
    uint32_t reserved : 10;
    uint32_t aaTx;                                   
    uint32_t aaRx;                                   
    uint32_t payloadTx[RCL_BLE_CS_MAX_PAYLOAD_SIZE]; 
    uint32_t payloadRx[RCL_BLE_CS_MAX_PAYLOAD_SIZE]; 
};

struct RCL_CMD_BLE_CS_SUBEVENT_RESULTS_t {
    uint8_t  subeventCode;
    uint16_t connectionHandle;
    uint8_t  configID;
    uint16_t startAclConnectionEvent;
    uint16_t procedureCounter;
    int16_t  frequencyCompensation;
    int8_t   referencePowerLevel;
    uint8_t  procedureDoneStatus;
    uint8_t  subeventDoneStatus;
    uint8_t  abortReason;
    uint8_t  numAntennaPath;
    uint8_t  numStepsReported;
    uint8_t  data[];
} __attribute__ ((packed));

struct RCL_CMD_BLE_CS_SUBEVENT_RESULTS_CONTINUE_t {
    uint8_t  subeventCode;
    uint16_t connectionHandle;
    uint8_t  configID;
    uint8_t  procedureDoneStatus;
    uint8_t  subeventDoneStatus;
    uint8_t  abortReason;
    uint8_t  numAntennaPath;
    uint8_t  numStepsReported;
    uint8_t  data[];
} __attribute__ ((packed));

struct RCL_CMD_BLE_CS_STEP_RESULTS_TONE_t {
    uint32_t i       : 12;
    uint32_t q       : 12;
    uint32_t quality : 8;
};

struct RCL_CMD_BLE_CS_STEP_RESULTS_t {
    /* Common */
    uint8_t mode;
    uint8_t channel;
    uint8_t dataLength;
    uint8_t data[];
} __attribute__((packed));

struct RCL_CMD_BLE_CS_STEP_RESULTS_I0_t {
    /* Common */
    uint8_t mode;
    uint8_t channel;
    uint8_t dataLength;
    /* Packet */
    uint8_t packetAAQuality;
    int8_t  packetRssi;
    uint8_t packetAntenna;
    /* Frequency */
    int16_t measuredFreqOffset;
};

struct RCL_CMD_BLE_CS_STEP_RESULTS_R0_t {
    /* Common */
    uint8_t mode;
    uint8_t channel;
    uint8_t dataLength;
    /* Packet */
    uint8_t packetAAQuality;
    int8_t  packetRssi;
    uint8_t packetAntenna;
};

struct RCL_CMD_BLE_CS_STEP_RESULTS_IR1_t {
    /* Common */
    uint8_t mode;
    uint8_t channel;
    uint8_t dataLength;
    /* Packet */
    uint8_t packetAAQuality;
    uint8_t nadm;
    int8_t  packetRssi;
    int16_t packetToF;
    uint8_t packetAntenna;
};

struct RCL_CMD_BLE_CS_STEP_RESULTS_IR2_t {
    /* Common */
    uint8_t mode;
    uint8_t channel;
    uint8_t dataLength;
    /* Tones */
    uint8_t antennaPermutationIndex;
    RCL_CmdBleCs_Tone tones[];
};

struct RCL_CMD_BLE_CS_STEP_RESULTS_IR3_t {
    /* Common */
    uint8_t mode;
    uint8_t channel;
    uint8_t dataLength;
    /* Packet */
    uint8_t packetAAQuality;
    uint8_t nadm;
    int8_t  packetRssi;
    int16_t packetToF;
    uint8_t packetAntenna;
    /* Tones */
    uint8_t antennaPermutationIndex;
    RCL_CmdBleCs_Tone tones[];
};

#endif