/**************************************************************************************************
*******
**************************************************************************************************/


#ifndef LL_DEF_H_
#define LL_DEF_H_

#include "types.h"
#include "comdef.h"
#include "bcomdef.h"
#include "ll_buf.h"

#if (MAX_NUM_LL_CONN_ROM_LIMT > 1)
#define   MULTI_ROLE
#endif

#define     MAX_NUM_LL_PRD_ADV_SYNC        2                     // for periodic adv listener

#define LL_INVALID_CONNECTION_ID                 0xFF


#define LL_PKT_PREAMBLE_LEN                      1
#define LL_PKT_SYNCH_LEN                         4
#define LL_PKT_LLID_LEN                          1
#define LL_PKT_HDR_LEN                           2
#define LL_PKT_MIC_LEN                           4
#define LL_PKT_CRC_LEN                           3

#define LL_DATA_PDU_HDR_LLID_RESERVED            0
#define LL_DATA_PDU_HDR_LLID_DATA_PKT_NEXT       1
#define LL_DATA_PDU_HDR_LLID_DATA_PKT_FIRST      2
#define LL_DATA_PDU_HDR_LLID_CONTROL_PKT         3


///adv header shift and mask
#define PDU_TYPE_SHIFT                           0
#define PDU_TYPE_MASK                            0xf
#define CHSEL_SHIFT								 5
#define CHSEL_MASK								 0x20
#define TX_ADD_SHIFT                             6
#define TX_ADD_MASK                              0x40
#define RX_ADD_SHIFT                             7
#define RX_ADD_MASK                              0x80
#define LENGTH_SHIFT                             8
#define LENGTH_MASK                              0xFf00

// macro for bit operations
#define SET_BITS(p,f,l,m)  p=(f<<l) | (p & (~m))
#define GET_BITS(p,l,m)     (p&m)>>l

// Receive Flow Control
#define LL_RX_FLOW_CONTROL_DISABLED              0
#define LL_RX_FLOW_CONTROL_ENABLED               1

//LL packet type
#define	ADV_IND                                  0               //Connectable Undirected Event 
#define	ADV_DIRECT_IND                           1               //Connectable  Directed Event
#define	ADV_NONCONN_IND                          2               //Non-connectable Undirected Event 
#define	ADV_SCAN_REQ                             3
#define	ADV_AUX_SCAN_REQ                         3
#define	ADV_SCAN_RSP                             4
#define	ADV_CONN_REQ                             5
#define	ADV_AUX_CONN_REQ                         5
#define	ADV_SCAN_IND                             6	             //Scannable Undirected Event
#define	ADV_EXT_TYPE                             7
#define	ADV_AUX_CONN_RSP                         8

// LL state defines
#define LL_STATE_IDLE                            0x00
#define LL_STATE_ADV_UNDIRECTED                  0x01
#define LL_STATE_ADV_DIRECTED                    0x02
#define LL_STATE_ADV_SCAN                        0x03
#define LL_STATE_ADV_NONCONN                     0x04
#define LL_STATE_SCAN                            0x05
#define LL_STATE_INIT                            0x06
#define LL_STATE_CONN_SLAVE                      0x07
#define LL_STATE_CONN_MASTER                     0x08
#define LL_STATE_DIRECT_TEST_MODE_TX             0x09
#define LL_STATE_DIRECT_TEST_MODE_RX             0x0A
#define LL_STATE_MODEM_TEST_TX                   0x0B
#define LL_STATE_MODEM_TEST_RX                   0x0C
#define LL_STATE_MODEM_TEST_TX_FREQ_HOPPING      0x0D

#define LL_STATE_ADV_EXT                         0x0E
#define LL_STATE_ADV_PERIODIC                    0x0F

/*
** LL Buffers Supported
*/
#define LL_MAX_NUM_DATA_BUFFERS                        12
#define LL_MAX_NUM_CMD_BUFFERS                         1

/*
** LL API Parameters
*/

// LL Parameter Limits
#define LL_ADV_CONN_INTERVAL_MIN                       32        // 20ms in 625us
#define LL_ADV_CONN_INTERVAL_MAX                       16384     // 10.24s in 625us
#define LL_ADV_NONCONN_INTERVAL_MIN                    160       // 100ms in 625us
#define LL_ADV_NONCONN_INTERVAL_MAX                    16384     // 10.24s in 625us
// temporary macro define : align to version 5.1 non-conn intv 20ms
// affect function LL_SetAdvControl
#define LL_ADV_V51_NONCONN_INTERVAL_MIN                32
#define LL_ADV_DELAY_MIN                               0         // in ms
#define LL_ADV_DELAY_MAX                               10        // in ms
#define LL_SCAN_INTERVAL_MIN                           4         // 2.5ms in 625us
#define LL_SCAN_INTERVAL_MAX                           16384     // 10.24s in 625us
#define LL_SCAN_WINDOW_MIN                             4         // 2.5ms in 625us
#define LL_SCAN_WINDOW_MAX                             16384     // 10.24s in 625us
#define LL_CONN_INTERVAL_MIN                           6         // 7.5ms in 1.25ms
#define LL_CONN_INTERVAL_MAX                           3200      // 4s in 1.25ms
#define LL_CONN_TIMEOUT_MIN                            10        // 100ms in 10ms
#define LL_CONN_TIMEOUT_MAX                            3200      // 32s in 10ms
#define LL_SLAVE_LATENCY_MIN                           0
#define LL_SLAVE_LATENCY_MAX                           499
#define LL_HOP_LENGTH_MIN                              5
#define LL_HOP_LENGTH_MAX                              16
#define LL_INSTANT_NUMBER_MIN                          6

#define LL_ADV_INTERVAL_DEFAULT       160      // 100ms in 625us ticks
#define LL_SCAN_INTERVAL_DEFAULT      640      // 400ms in 625us ticks
// LL Advertiser Channels
#define LL_ADV_CHAN_37                                 1
#define LL_ADV_CHAN_38                                 2
#define LL_ADV_CHAN_39                                 4
#define LL_ADV_CHAN_ALL                                (LL_ADV_CHAN_37 | LL_ADV_CHAN_38 | LL_ADV_CHAN_39)

#define LL_MAX_NUM_DATA_CHAN                           37   // 0 - 36

// Advertiser Synchronization Word
#define ADV_SYNCH_WORD                           0x8E89BED6  // Adv channel sync
#define ADV_CRC_INIT_VALUE                       0x00555555  // not needed; handled by NR hardware automatically

// Packet Lengths
#define LL_DEVICE_ADDR_LEN                             6
#define LL_MAX_ADV_DATA_LEN                            31
#define LL_MAX_ADV_PAYLOAD_LEN                         (LL_DEVICE_ADDR_LEN + LL_MAX_ADV_DATA_LEN)
#define LL_MAX_SCAN_DATA_LEN                           31
#define LL_MAX_SCAN_PAYLOAD_LEN                        (LL_DEVICE_ADDR_LEN + LL_MAX_SCAN_DATA_LEN)
#define LL_MAX_LINK_DATA_LEN                           27  // ZQ 20181030 for DLE feature
                                                           //replaced by g_llPduLen.local.MaxTxOctets

//  =============== add in A2 for simultaneous slave and adv/scan
#define LL_SEC_STATE_IDLE             0x00
#define LL_SEC_STATE_SCAN             0x01
#define LL_SEC_STATE_ADV              0x02
#define LL_SEC_STATE_SCAN_PENDING     0x03
#define LL_SEC_STATE_ADV_PENDING      0x04
#define LL_SEC_STATE_IDLE_PENDING     0x05
#define LL_SEC_STATE_INIT             0x06
#define LL_SEC_STATE_INIT_PENDING     0x07

// =============  for multi-role
#define LL_ROLE_SLAVE                         0x01
#define LL_ROLE_MASTER                        0x02
#define LL_ROLE_INVALID                       0xFF

#define LL_INVALID_TIME                       0xFFFFFFFF

#define LL_TASK_MASTER_DURATION               3000
#define LL_TASK_SLAVE_DURATION                2700


enum 
{
    LL_SCH_PRIO_LOW = 0,
    LL_SCH_PRIO_MED,
    LL_SCH_PRIO_HIGH,
    LL_SCH_PRIO_IMMED,
    LL_SCH_PRIO_LAST
};


//  ===== A2 End

// 2020-01-15 CTE Macro define 
#define LL_CTE_MAX_ANTENNA_LEN					8
#define LL_CTE_MAX_ANT_ID						(LL_CTE_MAX_ANTENNA_LEN - 1)
#define LL_CTE_MAX_PATTERN_LEN					16
#define LL_CTE_MIN_SUPP_LEN						0x2
#define LL_CTE_MAX_SUPP_LEN						0x14		// CTE MAX Support length in 8us units( MAX 160us)
#define LL_CTE_SUPP_LEN_UNIT					0x08
#define LL_CTE_MAX_PA_INTV_CNT					0x10
#define LL_CTE_MAX_IQ_SAMP_CNT					0x10
#define LL_CTE_ENABLE							0x1
#define LL_CTE_DISABLE							0x0
#define LL_IQ_SAMP_ENABLE						0x1
#define LL_IQ_SAMP_DISABLE						0x0
#define LL_CONN_IQSAMP_ENABLE					0x1
#define LL_CONN_IQSAMP_DISENABLE				0x0
#define LL_CONN_IQTX_ENABLE						0x1
#define LL_CONN_IQTX_DISENABLE					0x0
#define LL_CONN_CTE_REQ_ENABLE					0x1
#define LL_CONN_CTE_REQ_DISENABLE				0x0
#define LL_CONN_CTE_RSP_ENABLE					0x1
#define LL_CONN_CTE_RSP_DISENABLE				0x0
#define LL_IQ_SW_SAMP_1US						0x1
#define LL_IQ_SW_SAMP_2US						0x2
#define LL_CONTROLLER_SUPP_1US_AOD_TX			0x1
#define LL_CONTROLLER_SUPP_1US_AOD_SAMP			0x2
#define LL_CONTROLLER_SUPP_1US_AOA_TX_SAMP		0x4

// 2020-01-20 add for Extended advertising
#define LL_SECOND_ADV_PHY_1M					0x1
#define LL_SECOND_ADV_PHY_2M					0x2
#define LL_SECOND_ADV_PHY_CODE					0x3
#define LL_PHY_1M								0x1
#define LL_PHY_2M								0x2
#define LL_PHY_CODE								0x3


//LL connecction  control type
#define	    LL_CONNECTION_UPDATE_REQ             0
#define		LL_CHANNEL_MAP_REQ                   1
#define		LL_TERMINATE_IND                     2
#define		LL_ENC_REQ                           3
#define		LL_ENC_RSP                           4
#define		LL_START_ENC_REQ                     5
#define		LL_START_ENC_RSP                     6
#define		LL_UNKNOWN_RSP                       7
#define		LL_FEATURE_REQ                       8
#define		LL_FEATURE_RSP                       9
#define		LL_PAUSE_ENC_REQ                     10
#define		LL_PAUSE_ENC_RSP                     11
#define		LL_VERSION_IND                       12
#define		LL_REJECT_IND                        13
#define		LL_SLAVE_FEATURE_REQ                 14      
#define	    LL_CONNECTION_PARAM_REQ              15  
#define	    LL_CONNECTION_PARAM_RSP              16
#define	    LL_REJECT_IND_EXT                    17         
#define	    LL_PING_REQ                          18              
#define	    LL_PING_RSP                          19               
#define	    LL_LENGTH_REQ                        20            
#define	    LL_LENGTH_RSP                        21  
#define	    LL_PHY_REQ                           22  
#define	    LL_PHY_RSP                           23  
#define	    LL_PHY_UPDATE_IND                    24  


#define LL_CONNECT_REQ_PAYLOAD_LEN               18
#define LL_CONN_UPDATE_REQ_PAYLOAD_LEN           12
#define LL_CHAN_MAP_REQ_PAYLOAD_LEN              8
#define LL_TERM_IND_PAYLOAD_LEN                  2
#define LL_ENC_REQ_PAYLOAD_LEN                   23
#define LL_ENC_RSP_PAYLOAD_LEN                   13
#define LL_START_ENC_REQ_PAYLOAD_LEN             1
#define LL_START_ENC_RSP_PAYLOAD_LEN             1
#define LL_PAUSE_ENC_REQ_PAYLOAD_LEN             1
#define LL_PAUSE_ENC_RSP_PAYLOAD_LEN             1
#define LL_REJECT_IND_PAYLOAD_LEN                2
#define LL_REJECT_EXT_IND_PAYLOAD_LEN            3
#define LL_FEATURE_REQ_PAYLOAD_LEN               9
#define LL_FEATURE_RSP_PAYLOAD_LEN               9
#define LL_VERSION_IND_PAYLOAD_LEN               6
#define LL_UNKNOWN_RSP_PAYLOAD_LEN               2
#define LL_LENGTH_REQ_PAYLOAD_LEN                9
#define LL_LENGTH_RSP_PAYLOAD_LEN                9
#define LL_PHY_REQ_PAYLOAD_LEN                   3
#define LL_PHY_RSP_PAYLOAD_LEN                   3
#define LL_PHY_UPDATE_IND_PAYLOAD_LEN            5

// 2020-01-20 add for CTE
#define LL_CTE_REQ_LEN							 2
#define LL_CTE_RSP_LEN							 1

#define LL_MAX_NUM_CTRL_PROC_PKTS                4
#define LL_CTRL_UNDEFINED_PKT                    0xFF

// LL Events
#define LL_EVT_POST_PROCESS_NR                   0x0001
#define LL_EVT_DIRECTED_ADV_FAILED               0x0002
#define LL_EVT_SLAVE_CONN_CREATED                0x0004
#define LL_EVT_NEXT_INTERVAL                     0x0008
#define LL_EVT_MASTER_CONN_CANCELLED             0x0010
#define LL_EVT_TASK_TIMER_FENCE_EXPIRED          0x0020
#define LL_EVT_SLAVE_CONN_CREATED_BAD_PARAM      0x0040
#define LL_EVT_START_32KHZ_XOSC_DELAY            0x0080
#define LL_EVT_32KHZ_XOSC_DELAY                  0x0100
#define LL_EVT_RESET_SYSTEM_HARD                 0x0200
#define LL_EVT_RESET_SYSTEM_SOFT                 0x0400	

#define LL_EVT_MASTER_CONN_CREATED               0x0800	
#define LL_EVT_SECONDARY_SCAN                    0x1000	
#define LL_EVT_SECONDARY_ADV                     0x2000	
#define LL_EVT_SECONDARY_INIT                    0x4000
#define LL_EVT_RPA_TIMEOUT                       0x8000



#define LL_ADV_NONCONN_STATE                     0x00
#define LL_ADV_DISCOV_STATE                      0x01
#define LL_ADV_UNDIRECT_STATE                    0x02
#define LL_ADV_HDC_DIRECT_STATE                  0x03
#define LL_SCAN_PASSIVE_STATE                    0x04
#define LL_SCAN_ACTIVE_STATE                     0x05
#define LL_INIT_STATE                            0x06 // connection state in master role also supported
#define LL_SLAVE_STATE                           0x07
//
#define LL_ADV_NONCONN_SCAN_PASSIVE_STATE        0x10
#define LL_ADV_DISCOV_SCAN_PASSIVE_STATE         0x11
#define LL_ADV_UNDIRECT_SCAN_PASSIVE_STATE       0x12
#define LL_ADV_HDC_DIRECT_SCAN_PASSIVE_STATE     0x13
#define LL_ADV_NONCONN_SCAN_ACTIVE_STATE         0x14
#define LL_ADV_DISCOV_SCAN_ACTIVE_STATE          0x15
#define LL_ADV_UNDIRECT_SCAN_ACTIVE_STATE        0x16
#define LL_ADV_HDC_DIRECT_SCAN_ACTIVE_STATE      0x17
//
#define LL_ADV_NONCONN_INIT_STATE                0x20
#define LL_ADV_DISCOV_INIT_STATE                 0x21
#define LL_ADV_NONCONN_MASTER_STATE              0x22
#define LL_ADV_DISCOV_MASTER_STATE               0x23
#define LL_ADV_NONCONN_SLAVE_STATE               0x24
#define LL_ADV_DISCOV_SLAVE_STATE                0x25
#define LL_SCAN_PASSIVE_INIT_STATE               0x26
#define LL_SCAN_ACTIVE_INIT_STATE                0x27
//
#define LL_SCAN_PASSIVE_MASTER_STATE             0x30
#define LL_SCAN_ACTIVE_MASTER_STATE              0x31
#define LL_SCAN_PASSIVE_SLAVE_STATE              0x32
#define LL_SCAN_ACTIVE_SLAVE_STATE               0x33
#define LL_INIT_MASTER_STATE                     0x34 // master role and master role combination also supported
//
#define LL_ADV_LDC_DIRECT_STATE                  0x35
#define LL_ADV_LDC_DIRECT_SCAN_PASSIVE_STATE     0x36
#define LL_ADV_LDC_DIRECT_SCAN_ACTIVE_STATE      0x37

#define HCI_RX_PKT_HDR_SIZE                      5
#define LL_NUM_BYTES_FOR_CHAN_MAP                5    //(LL_MAX_NUM_ADV_CHAN+LL_MAX_NUM_DATA_CHAN)/sizeof(uint8)

#define LL_CTRL_PROC_STATUS_SUCCESS              0
#define LL_CTRL_PROC_STATUS_TERMINATE            1

// A2 multi-connection
#define LL_PROC_LINK_KEEP                        0
#define LL_PROC_LINK_TERMINATE                   1

#define LL_TX_DATA_CONTEXT_POST_PROCESSING       2

#define LL_TX_DATA_CONTEXT_SEND_DATA             0

#define LL_LINK_SETUP_TIMEOUT                    5  // 6 connection intervals (i.e. 0..5)

// Setup Next Slave Procedure Actions
#define LL_SETUP_NEXT_LINK_STATUS_SUCCESS        0
#define LL_SETUP_NEXT_LINK_STATUS_TERMINATE      1


// Data PDU Control Packet Types
#define LL_CTRL_CONNECTION_UPDATE_REQ            0  // M
#define LL_CTRL_CHANNEL_MAP_REQ                  1  // M
#define LL_CTRL_TERMINATE_IND                    2  // M, S
#define LL_CTRL_ENC_REQ                          3  // M
#define LL_CTRL_ENC_RSP                          4  //  , S
#define LL_CTRL_START_ENC_REQ                    5  //  , S
#define LL_CTRL_START_ENC_RSP                    6  // M, S
#define LL_CTRL_UNKNOWN_RSP                      7  // M, S
#define LL_CTRL_FEATURE_REQ                      8  // M   
#define LL_CTRL_FEATURE_RSP                      9  //  , S  , also could be M in ver4.2 ... HZF
#define LL_CTRL_PAUSE_ENC_REQ                    10 // M
#define LL_CTRL_PAUSE_ENC_RSP                    11 //  , S
#define LL_CTRL_VERSION_IND                      12 // M, S
#define LL_CTRL_REJECT_IND                       13 //  , S

// BLE 4.2
#define  LL_CTRL_SLAVE_FEATURE_REQ               14 
#define  LL_CTRL_CONNECTION_PARAM_REQ            15
#define  LL_CTRL_CONNECTION_PARAM_RSP            16
#define  LL_CTRL_REJECT_EXT_IND                  17
#define  LL_CTRL_PING_REQ                        18
#define  LL_CTRL_PING_RSP                        19
#define  LL_CTRL_LENGTH_REQ                      20
#define  LL_CTRL_LENGTH_RSP                      21
// BLE 5.0
#define  LL_CTRL_PHY_REQ                         22
#define  LL_CTRL_PHY_RSP                         23
#define  LL_CTRL_PHY_UPDATE_IND                  24
#define  LL_CTRL_MIN_USED_CHANNELS_IND           25

// TODO 2020-02-07 change , default: 26
#define LL_CTRL_TERMINATE_RX_WAIT_FOR_TX_ACK     0xFE //26 // M (internal to LL only)

// 2020-01-19 add for CTE
#define LL_CTRL_CTE_REQ							0x1A
#define LL_CTRL_CTE_RSP							0x1B

// control procedure timeout in coarse timer ticks
#define LL_MAX_CTRL_PROC_TIMEOUT                 64000 // 40s
 
// Encryption Related
#define LL_ENC_RAND_LEN                          8
#define LL_ENC_EDIV_LEN                          2
#define LL_ENC_LTK_LEN                           16
#define LL_ENC_IRK_LEN                           16

#define LL_ENC_IV_M_LEN                          4
#define LL_ENC_IV_S_LEN                          4
#define LL_ENC_IV_LINK_LEN                       4
#define LL_ENC_IV_LEN                            (LL_ENC_IV_M_LEN + LL_ENC_IV_S_LEN)
#define LL_ENC_SKD_M_LEN                         8
#define LL_ENC_SKD_S_LEN                         8
#define LL_ENC_SKD_LINK_LEN                      8
#define LL_ENC_SKD_LEN                           (LL_ENC_SKD_M_LEN + LL_ENC_SKD_S_LEN)
#define LL_ENC_SK_LEN                            16
#define LL_ENC_NONCE_LEN                         13
#define LL_END_NONCE_IV_OFFSET                   5
#define LL_ENC_MIC_LEN                           LL_PKT_MIC_LEN
//
#define LL_ENC_IV_M_OFFSET                       LL_ENC_IV_S_LEN
#define LL_ENC_IV_S_OFFSET                       0
#define LL_ENC_SKD_M_OFFSET                      LL_ENC_SKD_S_LEN
#define LL_ENC_SKD_S_OFFSET                      0
//
#define LL_ENC_BLOCK_LEN                         16
#define LL_ENC_CCM_BLOCK_LEN                     LL_ENC_BLOCK_LEN
#define LL_ENC_BLOCK_B0_FLAGS                    0x49
#define LL_ENC_BLOCK_A0_FLAGS                    0x01

// Resolving Private Address list
#define LEN_24BIT                             3 // Number of bytes in a 24 bit number
#define PRAND_SIZE                            LEN_24BIT // PRAND size in the Private Resolvable Address calculation

// Address header bits
#define RANDOM_ADDR_HDR                       0xC0  // Used for LL RANDOM Address
#define STATIC_ADDR_HDR                       0xC0  // Host Static Address, same as RANDOM address
#define PRIVATE_RESOLVE_ADDR_HDR              0x40


// Extended advertiser setting
#define LL_MAX_ADVERTISER_SET_LENGTH          0x672    // spec range: 0x1F ~ 0x672
#define LL_INVALID_ADV_SET_HANDLE             0xFF


////////////////////  for scan
// Scanner Advertisment Channels
#define LL_SCAN_ADV_CHAN_37                      37
#define LL_SCAN_ADV_CHAN_38                      38
#define LL_SCAN_ADV_CHAN_39                      39


// add by HZF for whitelist
#define   LL_WHITELIST_ENTRY_NUM               8

// BBB ROM code: resolving list size
#define   LL_RESOLVINGLIST_ENTRY_NUM           8

// Periodic advertiser list size
#define   LL_PRD_ADV_ENTRY_NUM                 8


struct bd_addr{
	uint8_t  addr[6];
};


typedef struct
{
  uint8_t     peerAddrType;                      // peer device address type of public or random
  uint8_t     peerAddr[ 6 ];                     // peer device address
} peerInfo_t;

#define NETWORK_PRIVACY_MODE               0 
#define DEVICE_PRIVACY_MODE                1
// BBB ROM code add
typedef struct
{
    uint8_t     localIrk[16];
	uint8_t     peerIrk[16];
    uint8_t     peerAddrType;                      // peer device address type of public or random
    uint8_t     peerAddr[6];                       // peer device address	

	uint8_t     privacyMode;                       // privacy mode, Network privacy mode or Device privacy mode

	// ==== add after BBB ROM code freeze
	uint8_t     localRpa[6];                       // local resolvable address
}  resolvingListInfo_t;

// Periodic Advertiser list
typedef struct
{
    uint8_t     addrType;                      // Advertising address type 
    uint8_t     addr[6];                       // Advertising address	
    uint8_t     sid;                           // Advertising SID
}  periodicAdvertiserListInfo_t;

/// Advertising parameters
typedef struct 
{
    uint8_t       active; 
    
    uint16_t  advInterval;                       // the advertiser interval, based on advIntMin and advIntMax
    /// Advertising type
    uint16_t advMode;                            // flag to indicate if currently advertising
  
    uint8_t ownAddrType;                         // own device address type of public or random
    uint8_t ownAddr[LL_DEVICE_ADDR_LEN];         // own device address
    
    uint8_t  advChanMap;                         // saved Adv channel map; note, only lower three bits used
                                                 
    uint8_t       advEvtType;                    //connectable directed, undirected, discoverable, or non-connectable
                                                 
    uint8_t       wlPolicy;                      // white list policy for Adv
    uint16_t      scaValue;                      // Slave SCA in PPM

    uint8_t       advDataLen;                    // advertiser data length
  
    // Scan Repsonse Parameters
    uint8_t       scanRspLen;                    // scan response data length
    
    // add by HZF
    uint8          advNextChan;

	// multi-connection
	uint8          connId;
 	  
}advInfo_t; 

/// Extended Advertising parameters
typedef struct 
{
//    uint8_t     advHandle;                                 // range: 0x00 - 0xEF
    uint8_t     advertisingSID;                            // range: 0x00 - 0x0F
	
    uint16_t    advEventProperties;                        // adv event type

    uint32_t    priAdvIntMin;                              // 3 octets, minimum primary adv interval 
    uint32_t    priAdvgIntMax;                             // 3 octets, maximum primary adv interval 
	
    uint8_t     priAdvChnMap;

    uint8_t     ownAddrType;                               // own device address type of public or random
    uint8_t     isOwnRandomAddressSet;                     // own random address type set flag. The address is set by HCI_LE_SET_ADVERTISING_SET_RANDOM_ADDRESS
    uint8_t     ownRandomAddress[LL_DEVICE_ADDR_LEN];        

	uint8_t     peerAddrType;
    uint8_t     peerAddress[LL_DEVICE_ADDR_LEN];

	uint8_t     wlPolicy;                                  // white list policy for Adv
    
    int8        advTxPower;
	
    uint8_t     primaryAdvPHY;
    uint8_t     secondaryAdvPHY;
	
    uint8_t     secondaryAdvMaxSkip;                       // the maximum number of advertising events that can be skipped before the AUX_ADV_IND can be sent
	
    uint8_t     scanReqNotificationEnable; 	

}extAdvParameter_t; 

/// data of Advertising set or scan response data
typedef struct 
{
//    uint8_t     advHandle;
	uint8_t     dataComplete;                        // all data of advert set received
    uint8       fragmentPreference;
	
	uint16       advertisingDataLength;
	uint8       *advertisingData;

    // LL generated
	uint16      DIDInfo;                            // 12bits
}advSetData_t; 

/// extended adv parameters, include spec parameters & implemented-specific parameters
typedef struct 
{
    uint8_t     advHandle;

	extAdvParameter_t  parameter;
	advSetData_t       data;                            // only for extended adv
	uint16             scanRspMaxLength;                // length of scan rsp data
	uint8              *scanRspData;

	// ===================== advertisement enable info
    uint32_t    duration;                               // unit us, note spec parameter is 10ms unit
    uint8_t     maxExtAdvEvents;

    // ================= advertisement context parameters  
	uint8_t     isPeriodic;	                               // is the adv parameters for periodic adv
    uint8_t     active;                                    // extended adv enable or not
    uint32_t    primary_advertising_interval;     
	
	uint16_t    adv_event_counter;                         // counter for extend adv event
	uint32_t    adv_event_duration;                        // duration of advertise

    int8        tx_power;                                  // range -127 ~ 127 dBm, will be filled to field TxPower

    uint8_t     sendingAuxAdvInd;

    // below parameters only applicable to extended adv, not for periodic adv
    uint8_t     currentChn;                                // current adv channel

    uint8_t     auxChn;                                    // 1st aux PDU channel No.
	uint16_t    currentAdvOffset;                          // current read ptr of adv data set, for fill AUX_XXX_IND PDUs	
} extAdvInfo_t; 

typedef struct  
{
    uint16       syncPacketOffset : 13;            // 13bits
    uint16       offsetUnit       : 1;             // 1 bit
    uint16       offsetAdj        : 1;             // 1 bit
    uint16       rfu              : 1;             // 1 bit    
} syncInfoOffset_t;

typedef struct  
{
    uint8       chn_map : 5;             // 5bits
    uint8       sca     : 3;             // 3 bit
} chanMap4_t;
    
typedef struct 
{
    syncInfoOffset_t   offset;

	uint16       interval;

	uint8        chn_map[4];       
	chanMap4_t   chn_map4;         

	uint8        AA[4];
	uint8        crcInit[3];

	uint16       event_counter;
} syncInfo_t; 

/// data of periodic Advertising set
typedef struct 
{
    uint8       dataComplete;                        // all data of advert set received
	
	uint16      advertisingDataLength;
	uint8       *advertisingData;
}periodicAdvSetData_t; 

// 2020-01-15 add for connection & connectionless parameter
typedef struct
{
	// common
//	uint16	handle;					// syncConnHandle for connectionless , connHandle for connection 
	uint8	enable;					// 
	uint8 	CTE_Length;				// connectionless transmit CTE length or connection request and response CTE Length
	uint8	CTE_Type;				// AOA, ADO 1us , AOD 2us
	uint8 	CTE_Count;				// number of CTE to transmit in each PA interval
									// IQ Sample:max number of CTE to sample and report in each PA interval
	uint8	CTE_Count_Idx;			// record the number of times that the CTE send , max equal to CTE_Count
	uint8	pattern_LEN;
	uint8	AntID[LL_CTE_MAX_PATTERN_LEN];

	uint8	slot_Duration;			// switching and sampling slot 1us or 2us
	
	// connectionless transmit param
//	uint8	advSet;					// identify connectionless advertising set
									// CTEInfo_t merge to periodicAdvInfo_t , advSet not used

	// connection CTE request & response enable command
	uint16	CTE_Request_Intv;	
	
}CTEInfo_t;


// periodic adv: data + parameters + enable flag
// note that periodic adv also need extended adv parameters + enable
typedef struct 
{
    uint8_t     advHandle;

	periodicAdvSetData_t       data;

    uint16    adv_interval_min;
    uint16    adv_interval_max;	
    uint16_t  adv_event_properties;                        // adv event type	

    // ================= advertisement context parameters   
    uint8_t     active;                                    // extended adv enable or not
    uint32_t    adv_interval;     

	uint8_t     secondaryAdvPHY;   // reserved, should we copy this setting from ext adv info? ext adv may be disabled while keep periodic adv alive

	uint8        chn_map[5];        // 37 bits
	uint8_t		chanMapTable[LL_MAX_NUM_DATA_CHAN];
	uint8_t     numUsedChans;                   	// count of the number of usable data channels
	uint8        sca;               // 3 bit

	uint32       AA;
	uint32       crcInit;	

    uint8_t     tx_power;                                  // not setting now, reserve for TxPwr field	
	
	uint16_t    periodic_adv_event_counter;                // counter for periodic adv event
	uint8       pa_current_chn;                            // current periodic adv channel

    uint8_t     currentChn;                                // current adv channel

	uint16_t    currentAdvOffset;                          // current read ptr of adv data set, for fill AUX_XXX_IND PDUs	

	// 2020-01-15 CTE global variable
	CTEInfo_t			PrdCTEInfo;
} periodicAdvInfo_t; 

///////////////////////////////////////////////////////////
// Scanner Event Parameters
typedef struct
{
//  taskInfo_t *llTask;                                // pointer to associated task block
  uint8       ownAddrType;                             // own device address type of public or random
  uint8       ownAddr[ LL_DEVICE_ADDR_LEN ];           // own device address
  uint8       initPending;                           // flag to indicate if Scan needs to be initialized
  uint8       scanMode;                              // flag to indicate if currently scanning
  uint8       scanType;                              // passive or active scan
  uint16      scanInterval;                          // the interval between scan events
  uint16      scanWindow;                            // the duration of a scan event
  uint8       wlPolicy;                              // white list policy for Scan
  uint8       filterReports;                         // flag to indicate if duplicate Adv packet reports are to be filtered
  uint16      scanBackoffUL;                         // backoff upper limit count
  uint8       nextScanChan;                          // advertising channel to be used by scanner
  uint8       numSuccess;                            // for adjusting backoff count by tracking successive successes
  uint8       numFailure;                            // for adjusting backoff count by tracking successive failures
  uint16      currentBackoff;                        // current back off count, uint16 because the upper limit is 256
} scanInfo_t;

///////////////////////////////////////////////////////////
// Extended Scanner Parameters
#define LL_MAX_EXTENDED_SCAN_PHYS                         2
#define LL_MAX_EXTENDED_INIT_PHYS                         3
#define LL_SCAN_PHY_1M_BITMASK                            0x01
#define LL_CONN_PHY_2M_BITMASK                            0x02     // only for init
#define LL_SCAN_PHY_CODED_BITMASK                         0x04
typedef struct
{
  uint8       enable;
  uint8       ownAddrType;                             // own device address type of public or random
  uint8       ownAddr[ LL_DEVICE_ADDR_LEN ];           // own device address
  uint8       wlPolicy;                                // white list policy for Scan

  uint8       numOfScanPHY;
  uint8       scanPHYs[LL_MAX_EXTENDED_SCAN_PHYS];     // scan PHYs

  uint8       scanType[LL_MAX_EXTENDED_SCAN_PHYS];       // passive or active scan
  uint16      scanInterval[LL_MAX_EXTENDED_SCAN_PHYS];   // the interval between scan events
  uint16      scanWindow[LL_MAX_EXTENDED_SCAN_PHYS];     // the duration of a scan event

  uint8       filterDuplicate;                         // Duplicate filtering setting
  uint16      duration;                                // scan duration in a scan period
  uint16      period;                                  // scan period

  // scan context
  uint8       current_index;                           // current scan parameter index, 0 or 1
  uint8       current_scan_PHY;
  uint8       current_chn;

  // TODO: check below members are required or not
  uint16      adv_data_offset;                        // offset of long adv data
  uint16      adv_data_buf_len;                       // adv data buffer size
  uint8       *adv_data;
} extScanInfo_t;

typedef struct
{
    uint8     valid;
    uint8     options;
    uint8     advertising_SID;
    uint8     advertiser_Address_Type;
    uint8     advertiser_Address[LL_DEVICE_ADDR_LEN];
    uint16    skip;
    uint16    sync_Timeout;
    uint8     sync_CTE_Type;
} scannerSyncInfo_t;

typedef struct
{
    uint8   header;

	uint8   advA[LL_DEVICE_ADDR_LEN];
	uint8   targetA[LL_DEVICE_ADDR_LEN];
	uint8   cteInfo;
	uint16  adi;

	struct 
	{
	    uint8  chn_idx;
		uint8  ca;
		uint8  offset_unit;
		uint16 aux_offset;
		uint8  aux_phy;
	}  auxPtr;

	uint8 syncInfo[18];

	uint8 txPower;
} extAdvHdr_t;

/////////////////// Initiator Event Parameters
typedef struct
{
  uint8       ownAddrType;                             // own device address type of public or random
  uint8       ownAddr[ LL_DEVICE_ADDR_LEN ];           // own device address
  //
  uint8       initPending;                           // flag to indicate if Scan needs to be initialized
  uint8       scanMode;                              // flag to indicate if currently scanning
  uint16      scanInterval;                          // the interval between scan events
  uint16      scanWindow;                            // the duration of a scan event
  uint8       nextScanChan;                          // advertising channel to be used by scanner
  uint8       wlPolicy;                              // white list policy for Init
  uint8       connId;                                // allocated connection ID
  uint8       scaValue;                              // Master SCA as an ordinal value for PPM
} initInfo_t;


typedef struct
{
  uint8       ownAddrType;                             // own device address type of public or random
  uint8       ownAddr[ LL_DEVICE_ADDR_LEN ];           // own device address

  uint8       wlPolicy;                                // white list policy for Init
//  uint8       initPending;                           // flag to indicate if Scan needs to be initialized
  uint8       scanMode;                              // flag to indicate if currently scanning
  
  uint8       numOfScanPHY;
  uint8       initPHYs[LL_MAX_EXTENDED_SCAN_PHYS];     // scan PHYs
  uint16      scanInterval[LL_MAX_EXTENDED_SCAN_PHYS];   // the interval between scan events
  uint16      scanWindow[LL_MAX_EXTENDED_SCAN_PHYS];     // the duration of a scan event

  uint16      conn_interval_min[LL_MAX_EXTENDED_SCAN_PHYS];
  uint16      conn_interval_max[LL_MAX_EXTENDED_SCAN_PHYS];
  uint16      conn_latency[LL_MAX_EXTENDED_SCAN_PHYS];
  uint16      supervision_timeout[LL_MAX_EXTENDED_SCAN_PHYS];
  uint16      minimum_CE_length[LL_MAX_EXTENDED_SCAN_PHYS];
  uint16      maximum_CE_length[LL_MAX_EXTENDED_SCAN_PHYS];

  // initiator parameters for 2Mbps PHY
  uint8       is_2M_parameter_present;
  uint16      conn_interval_min_2Mbps;
  uint16      conn_interval_max_2Mbps;
  uint16      conn_latency_2Mbps;
  uint16      supervision_timeout_2Mbps;
  uint16      minimum_CE_length_2Mbps;
  uint16      maximum_CE_length_2Mbps;

  // scan context
  uint8       current_index;                           // current scan parameter index, 0 or 1
  uint8       current_scan_PHY;
  uint8       current_chn;  
                           
  uint8       connId;                                // allocated connection ID
  uint8       scaValue;                              // Master SCA as an ordinal value for PPM
} extInitInfo_t;
/////////////////////////////////////////////////////////////////

typedef struct
{
  uint8_t  winSize;                              // window size
  uint16_t winOffset;                            // window offset
  uint16_t connInterval;                         // connection interval
  uint16_t slaveLatency;                         // number of connection events the slave can ignore
  uint16_t connTimeout;                          // supervision connection timeout
} connParam_t;

typedef struct
{
  uint8_t  verNum;                               // controller spec version
  uint16_t comId;                                // company identifier
  uint16_t subverNum;                            // implementation version
} verInfo_t;

typedef struct
{
  uint8_t connId;                                // connection ID
  uint8_t termIndRcvd;                           // indicates a TERMINATE_IND was received
  uint8_t reason;                                // reason code to return to Host when connection finally ends
} termInfo_t;

// TX Data
typedef struct txData_t
{
  struct txData_t *pNext;                        // pointer to next Tx data entry on queue
} txData_t;

// Data Packet Queue
typedef struct
{
  txData_t *head;                                // pointer to head of queue
  txData_t *tail;                                // pointer to tail of queue
} llDataQ_t;


// Version Information Exchange
typedef struct
{
  uint8_t peerInfoValid;                         // flag to indicate the peer's version information is valid
  uint8_t hostRequest;                           // flag to indicate the host has requested the peer's version information
  uint8_t verInfoSent;                           // flag to indicate this device's version information has been sent
} verExchange_t;

// Feature Set Data
typedef struct
{
  uint8_t featureRspRcved;                       // flag to indicate the Feature Request has been responded to
  uint8_t featureSet[ 8 ];
} featureSet_t;

// Channel Map
typedef struct
{
  uint8_t chanMap[ 5 ];                          // bit map corresponding to the data channels 0..39
} chanMap_t;

// Control Procedure Information
typedef struct
{
  uint8_t  ctrlPktActive;                              // flag that indicates a control packet is being processed
  uint8_t  ctrlPkts[ LL_MAX_NUM_CTRL_PROC_PKTS ];      // queue of control packets to be processed
  uint8_t  ctrlPktCount;                               // number of queued control packets
  uint16_t ctrlTimeoutVal;                             // timeout in CI events for control procedure for this connection
  uint16_t ctrlTimeout;                                // timeout counter in CI events for control procedure
} ctrlPktInfo_t;

typedef struct  
{
    uint16_t MaxTxOctets;  
	uint16_t MaxTxTime;
    uint16_t MaxRxOctets;  
    uint16_t MaxRxTime;
}ll_pdu_length_ctrl_t;

typedef struct
{
     ll_pdu_length_ctrl_t local;
     ll_pdu_length_ctrl_t remote;         
     ll_pdu_length_ctrl_t suggested;      // global setting
     uint8_t isProcessingReq;
     uint8_t isWatingRsp;
     uint8_t isChanged;
     uint8_t dummy[1];
}llPduLenManagment_t;

typedef struct  
{
    uint8_t allPhy;
    uint8_t txPhy;  
    uint8_t rxPhy;
    uint8_t dummy[1];
}ll_phy_ctrl_t;

typedef struct  
{
    uint8_t m2sPhy;  
    uint8_t s2mPhy;
    uint16_t instant;
}ll_phy_update_ind_t;

typedef struct
{
    ll_phy_ctrl_t def;
    ll_phy_ctrl_t local;
    ll_phy_ctrl_t req;
    ll_phy_ctrl_t rsp;
    uint16_t phyOptions;
    uint8_t isChanged;
    uint8_t isProcessingReq;
    uint8_t isWatingRsp;
    uint8_t status;
    uint8_t dummy[2];

}llPhyModeManagment_t;

// 2020-02-21 add for CTE req & rsp logic
typedef struct
{
	uint8_t isChanged;
	uint8_t isProcessingReq;
	uint8_t isWatingRsp;			// wait other Ctrl command procedure
	uint8_t	errorCode;
}llCTEModeManagement_t;

// for timer drift adjust
typedef struct
{
  uint32 coarse;                                       // number of 625us ticks at SFD capture
  uint16 fine;                                         // number of 31.25ns ticks at SFD capture
} sysTime_t;

// Encryption
typedef struct
{
  // Note: IV and SKD provide enough room for the full IV and SKD. When the
  //       Master and Slave values are provided, the result is one combined
  //       (concatenated) value.
  uint8  IV[ LL_ENC_IV_LEN ];                        // combined master and slave IV values concatenated
  uint8  SKD [ LL_ENC_SKD_LEN ];                     // combined master and slave SKD values concatenated
  uint8  RAND[ LL_ENC_RAND_LEN ];                    // random vector from Master
  uint8  EDIV[ LL_ENC_EDIV_LEN ];                    // encrypted diversifier from Master
  uint8  nonce[ LL_ENC_NONCE_LEN ];                  // current nonce with current IV value
  uint8  SK[ LL_ENC_SK_LEN ];                        // session key derived from LTK and SKD
  uint8  LTK[ LL_ENC_LTK_LEN ];                      // Long Term Key from Host
  uint8  SKValid;                                    // flag that indicates the Session Key is valid
  uint8  LTKValid;                                   // Long Term Key is valid
  uint32 txPktCount;                                 // used for nonce formation during encryption (Note: 39 bits!)??
  uint32 rxPktCount;                                 // used for nonce formation during encryption (Note: 39 bits!)??
  uint8  encRestart;                                 // flag to indicate if an encryption key change took place
  uint8  encRejectErrCode;                           // error code for rejecting encryption request
  // ALT: COULD USE ONE VARIABLE AND STATES FOR THESE FLAGS; IF SO, THE
  //      CONTROL PROCEDURE WOULD NEED TO BE REWORKED.
  uint8  startEncRspRcved;                           // flag to indicate the Start Request has been responded to
  uint8  pauseEncRspRcved;                           // flag to indicate the Pause Request has been responded to
  uint8  encReqRcved;                                // flag to indicate an Enc Req was received in a Enc Pause procedure


  uint8  startEncReqRcved;                           // flag to indicate the Start Request has been responded to
  uint8  rejectIndRcved;                             // flag to indicate the Start Encryption needs to be aborted

} encInfo_t;

// Packet Error Rate Information - General
typedef struct
{
  uint16 numPkts;                                    // total number of packets
  uint16 numCrcErr;                                  // total number of packets with CRC error
  uint16 numEvents;                                  // total number of connection events
  uint16 numMissedEvts;                              // total number of missed connection events
} perInfo_t;

typedef struct 
{
    // adv channel statistics
    int ll_send_undirect_adv_cnt;
    int ll_send_nonconn_adv_cnt;
    int ll_send_scan_adv_cnt;
    int ll_send_hdc_dir_adv_cnt;
    int ll_send_ldc_dir_adv_cnt;

	// adv in conn event
	int ll_send_conn_adv_cnt;
	int ll_conn_adv_pending_cnt;

    // scan in conn event
	int ll_conn_scan_pending_cnt;

	// slave counter
    int ll_recv_scan_req_cnt; 
    int ll_send_scan_rsp_cnt;
    int ll_recv_conn_req_cnt;
	int ll_send_conn_rsp_cnt;
    
    // whitelist
    int ll_filter_scan_req_cnt;
    int ll_filter_conn_req_cnt;

	// scan
	int ll_recv_adv_pkt_cnt;
	int ll_send_scan_req_cnt;	
	int ll_recv_scan_rsp_cnt;

    
    // connection event counters
    int ll_conn_succ_cnt;        // LL accept connect, but not always sync succ
    
    int ll_link_lost_cnt;
    int ll_link_estab_fail_cnt;

    // connection packet statistics
//    int ll_recv_ctrl_pkt_cnt;
//    int ll_recv_data_pkt_cnt;   
//    int ll_recv_invalid_pkt_cnt;
//    
//    int ll_recv_abnormal_cnt;
//    
//    int ll_send_data_pkt_cnt; 
//    
//    int ll_conn_event_cnt;   
//    int ll_recv_crcerr_event_cnt;              // CRC error detected in the connection event   
//    int ll_conn_event_timeout_cnt;             // timeout connection event countt  

    int ll_rx_peer_cnt;                        // scan/conn request counter, to consider whether we need it

    // LL <-> HCI packets statistics
//    int ll_to_hci_pkt_cnt;
//    int ll_hci_to_ll_pkt_cnt;
//    
//    int ll_hci_buffer_alloc_err_cnt;

    //ll_hw err cnt
    int ll_evt_shc_err;
    
    //ll_hw err cnt
    int ll_trigger_err;
    int ll_rfifo_rst_err;
    int ll_rfifo_rst_cnt;
    int ll_rfifo_read_err;
    
    // reserve counter
    int ll_tbd_cnt1;
    int ll_tbd_cnt2;
    int ll_tbd_cnt3;
    int ll_tbd_cnt4;
    int ll_tbd_cnt5;
    int ll_tbd_cnt6;
    int ll_tbd_cnt7;
    int ll_tbd_cnt8;
    
} llGlobalStatistics_t;	

// ======= multi-connection
typedef struct 
{   
    // connection packet statistics
    uint32_t ll_recv_ctrl_pkt_cnt;
    uint32_t ll_recv_data_pkt_cnt;   
    uint32_t ll_recv_invalid_pkt_cnt;
    
    uint32_t ll_recv_abnormal_cnt;
    
    uint32_t ll_send_data_pkt_cnt; 
    
    uint32_t ll_conn_event_cnt;   
    uint32_t ll_recv_crcerr_event_cnt;              // CRC error detected in the connection event   
    uint32_t ll_conn_event_timeout_cnt;             // timeout connection event countt  

    // LL <-> HCI packets statistics
    uint32_t ll_to_hci_pkt_cnt;
    uint32_t ll_hci_to_ll_pkt_cnt;
    
    uint32_t ll_hci_buffer_alloc_err_cnt;

	uint32_t ll_miss_master_evt_cnt;
	uint32_t ll_miss_slave_evt_cnt;


    // reserve counter
    uint32_t ll_tbd_cnt1;
    uint32_t ll_tbd_cnt2;
    uint32_t ll_tbd_cnt3;
    uint32_t ll_tbd_cnt4;
    
} llLinkStatistics_t;	

typedef struct
{
    uint8_t  chanMap[5];
    uint16_t chanMapUpdateEvent;               // event count to indicate when to apply pending chan map update
    uint8_t  chanMapUpdated;
} preChanMapUpdate_t;


// Connection Data
typedef struct
{
    uint8_t          rx_timeout;                     // ----- 
    uint8_t          rx_crcok;                       // ----- 
    uint8_t          allocConn;                      // flag to indicate if this connection is allocated    
    uint8_t          active;                         // flag to indicate if this connection is active
    uint8_t          connId;                         // connection ID
    uint8_t          firstPacket;                    // flag to indicate when the first packet has been received. 0 means TURE, 1 means FALSE  
	  
    uint16_t         currentEvent;                   // current event number
    uint16_t         nextEvent;                      // next active event number
    uint16_t         lastCurrentEvent;
    uint16_t         expirationEvent;                // event at which the LSTO has expired
    uint16_t         expirationValue;                // number of events to a LSTO expiration
	  
    
    uint16_t         scaFactor;                      // SCA factor for timer drift calculation
    uint32_t         timerDrift;                     // saved timer drift adjustment to avoid recalc
    uint32_t         accuTimerDrift;                 // accumulate timer drift
    // Connection Parameters
    uint32_t         lastTimeToNextEvt;              // the time to next event from the previous connection event
    uint8_t          slaveLatencyAllowed;            // flag to indicate slave latency is permitted
    uint16_t         slaveLatency;                   // current slave latency; 0 means inactive
    uint8_t          lastSlaveLatency;               // last slave latency value used
    uint16_t         slaveLatencyValue;              // current slave latency value (when enabled)
    
    uint32_t accessAddr;                             // saved synchronization word to be used by Slave
    uint32_t initCRC;                                // connection CRC initialization value (24 bits)	
	 
    uint8_t          sleepClkAccuracy;               // peer's sleep clock accurracy; used by own device to determine timer drift
    connParam_t     curParam;  

    // current connection parameters
    // Channel Map
    uint8_t          nextChan;                       // the channel for the next active connection event
    uint8_t          currentChan;                    // the channel for the currently completed connection event
    uint8_t          lastCurrentChan;                // the channel for the last currentChan for disable slavelatency usage
	  
    uint8_t          numUsedChans;                   // count of the number of usable data channels
    // uint8_t          hopLength;                   // used for finding next data channel at next connection event
    uint8_t          chanMapTable[LL_MAX_NUM_DATA_CHAN]; // current chan map table that is in use for this connection

    uint8_t          chanMap[5];

	chanMap_t       	chanMapUpdate;              // slave chanMapUpdate for different connId
	preChanMapUpdate_t preChanMapUpdate;            // used for disable latency
	uint8_t          hop;
	
    // TX Related
    uint8_t          txDataEnabled;                  // flag that indicates whether data output is allowed
    llDataQ_t        txDataQ;                        // queue of Tx Data packets
    // RX Related
    uint8_t          rxDataEnabled;                  // flag that indicates whether data input is allowed
    uint8_t          lastRssi;                       // last data packet RSSI received on this connection
    
    uint16_t         foff;                           // A2 add, sync qualitiy indicator, estimated by rx BB
    uint8_t          carrSens;                       // A2 add, estimated freq offset by rx BB ,foff-512-->[-512 511]KHz

    // Control Packet Information
    ctrlPktInfo_t   ctrlPktInfo;                     // information for control procedure processing
    // Parameter Update Control Procedure
    uint8_t          pendingParamUpdate;             // flag to indicate connection parameter update is pending
    uint16_t         paramUpdateEvent;               // event count to indicate when to apply pending param update
    connParam_t    paramUpdate;                      // update parameters
    // Channel Map Update Control Procedure
    uint8_t          pendingChanUpdate;              // flag to indicate connection channel map update is pending
    uint16         chanMapUpdateEvent;               // event count to indicate when to apply pending chan map update
    // Encryption Data Control Procedure
    uint8          encEnabled;                       // flag to indicate that encryption is enabled for this connection
    encInfo_t      encInfo;                          // structure that holds encryption related data
    // Feature Set
    featureSet_t   featureSetInfo;                   // feature set for this connection
    // Version Information
    verExchange_t  verExchange;                      // version information exchange
    verInfo_t      verInfo;                          // peer version information
    // Termination Control Procedure
    termInfo_t     termInfo;                         // structure that holds connection termination data
    // Unknnown Control Packet
    uint8          unknownCtrlType;                  // value of unknown control type
    // Packet Error Rate
    perInfo_t      perInfo;                          // PER

    uint8_t        isCollision;
    uint8_t        rejectOpCode;
        
	ll_phy_update_ind_t phyUpdateInfo;               // ll_phy update
    // Parameter Update Control Procedure
    uint8_t          pendingPhyModeUpdate;             // flag to indicate connection ll phy update is pending
    uint16_t         phyModeUpdateEvent;  
    
	uint8_t  sn_nesn;                                // use to save last sn/nesn in new IC
                                                     
    // for new IC                                    
    uint8_t llMode;                                  // for RTLP & TRLP loop, may need change the HW engine mode. 

	// ===============  A2 multi connection
	uint8_t ctrlDataIsProcess ;   // seding a control packet or not
    uint8_t ctrlDataIsPending ;   // control packet is pending to be sent	
//    uint8_t dummy[2];             // for 4-bytes align
    
    int  anchor_point_base_time;    // do we need it?
	int  anchor_point_fine_time;    // do we need it?
	
	int  next_event_base_time;      // do we need it?
	int  next_event_fine_time;      // do we need it?    

    ctrl_packet_buf   ctrlData;
	llLinkBuf_t       ll_buf;

	// DLE
	llPduLenManagment_t  llPduLen;
	llPhyModeManagment_t llPhyModeCtrl;

	// add after BBB ROM release, PHY format
	uint8_t              llRfPhyPktFmt;
	// add after BBB ROM release, channel selection algorithm
	uint8_t              channel_selection;

	llLinkStatistics_t pmCounter;

	// 2020-01-19 add for CTE
	// llCTE_ReqFlag,llCTE_RspFlag only indicate CTE Request and Response enable or disable status
	uint8 llCTE_ReqFlag;
	uint8 llCTE_RspFlag;
	// CTE REQ & RSP Control
	llCTEModeManagement_t llCTEModeCtrl;
	CTEInfo_t	llConnCTE;

	// reserved variables
	uint32      llTbd1;
	uint32      llTbd2;
	uint32      llTbd3;
	uint32      llTbd4;
} llConnState_t;

typedef struct 
{
	uint8   	  rsc_idx;	                      // connection ID, reserved for dynamic resource allocate
    uint8         priority;
    uint8         linkRole;                       // link role, slave(LL_ROLE_SLAVE) or master(LL_ROLE_MASTER)

    uint32        task_period;                    // schedule period, calculate from connection interval, in us. required???
    uint32        task_duration;                  // task duration
	uint32        remainder;                      // remainder time

//    uint32        lastTimerValue;                      // last timer configure value

}  llScheduleInfo_t;

// Per BLE LL Connection (max number is BLE_LL_MAX_NUM_LL_CONNS)
typedef struct
{
    uint8         numLLConns;                          // number of allocated connections
    uint8         numLLMasterConns;                    // number of master, to check whether we need it
    uint8         currentConn;                         // the LL connection currently in use

    llScheduleInfo_t         scheduleInfo[MAX_NUM_LL_CONN_ROM_LIMT];     // scheduler information

    // ========== common link parameter for all master connection
    uint16        connInterval;                         // connection interval
    uint16        slaveLatency;                         // number of connection events the slave can ignore
    uint16        connTimeout;                          // supervision connection timeout    

	uint32        per_slot_time;                        // delta T per resource slot

	uint32        timerExpiryTick;                      // last LL timer expiry tick in 1s timer	
	uint32        current_timer;                        // LL timer initial load value
  
} llConns_t;

// for extended/periodic adv shceduler
typedef struct 
{
//	uint8   	  advInfoIdx;	                      // index in the adv parameters array
//	uint8   	  advSetIdx;	                      // index in the adv parameters array
    uint8         adv_handler;
	extAdvInfo_t  *pAdvInfo;
	
//    uint8         eventType;                          // adv event type

//    uint32        task_period;                    // schedule period, calculate from connection interval, in us. required???
//    uint32        task_duration;                  // task duration
	uint32        nextEventRemainder;               // remainder time
	uint32        auxPduRemainder;                  // remainder time

}  llAdvScheduleInfo_t;

typedef struct 
{
//	uint8   	  advInfoIdx;	                      // index in the adv parameters array
//	uint8   	  advSetIdx;	                      // index in the adv parameters array
    uint8         adv_handler;
	periodicAdvInfo_t  *pAdvInfo_prd;
	extAdvInfo_t       *pAdvInfo;
	
//    uint32        task_period;                    // schedule period, calculate from connection interval, in us. required???
//    uint32        task_duration;                  // task duration
	uint32        nextEventRemainder;               // primary channel PDU remainder time
	uint32        auxPduRemainder;                  // auxilary channel PDU remainder time

}  llPeriodicAdvScheduleInfo_t;

// periodic scanner context
typedef struct 
{
    uint16       syncHandler;
	uint8        valid;                  // the syncInfo is valid or not
	uint8        syncEstOk;              // sync the periodic adv event OK?
	uint8        event1stFlag;           // indicate LL is searching AUX_SYNC_IND PDU

    uint16       skip;
    uint32       syncTimeout;            // unit us, need *1250 when convert from HCI value
    uint8        syncCteType;

//    syncInfoOffset_t   offset;

	uint32       advInterval;         // periodic adv event interval, unit us, need *1250 when convert from air interface PDU value

	uint8        chnMap[5];       

	uint8_t		chanMapTable[LL_MAX_NUM_DATA_CHAN];
	uint8_t     numUsedChans;                   	// count of the number of usable data channels	

	uint8        sca;

	uint8        accessAddress[4];
	uint16       channelIdentifier;
	uint8        crcInit[3];

    uint8        advPhy;
    uint8        current_channel;         // current scan channel, for AUX_CHAIN_IND, it may different with 1st PDU channel
	uint8        currentEventChannel;     // current periodic adv event 1st PDU channel
	uint16       eventCounter;	          // periodic adv event counter

	uint16       syncLostTime;
	
	uint32       nextEventRemainder;               // next periodic advertisement event remainder time

	// 2020-01-17 add for CTE Sampling
	CTEInfo_t	IQSampleInfo;
}  llPeriodicScannerInfo_t;

// ===== BBB ROM code added
typedef struct
{
    uint8    isTimer1RecoverRequired;
	uint32   timer1Remainder;

//    uint8    isTimer2RecoverRequired;
//	uint32   timer2Remainder;
//
//    uint8    isTimer3RecoverRequired;
//	uint32   timer3Remainder;

    uint8    isTimer4RecoverRequired;
	uint32   timer4Remainder;
}  llSleepContext;

typedef uint8 llStatus_t;

// Packet Error Rate Information By Channel
typedef struct
{
  uint16 numPkts[ LL_MAX_NUM_DATA_CHAN ];
  uint16 numCrcErr[ LL_MAX_NUM_DATA_CHAN ];
} perByChan_t;

typedef struct
{
  uint16 rxNumPkts[ LL_MAX_NUM_DATA_CHAN ];
  uint16 rxNumCrcErr[ LL_MAX_NUM_DATA_CHAN ];
  uint16 txNumRetry[ LL_MAX_NUM_DATA_CHAN ];
  uint16 TxNumAck[ LL_MAX_NUM_DATA_CHAN ];
  uint16 rxToCnt[ LL_MAX_NUM_DATA_CHAN ];
  uint16 connEvtCnt[ LL_MAX_NUM_DATA_CHAN ];
  
  
} perStatsByChan_t;

typedef struct
{
  uint16 rxNumPkts;
  uint16 rxNumCrcErr;
  uint16 txNumRetry;
  uint16 TxNumAck;
  uint16 rxToCnt;
  uint16 connEvtCnt;
  
  
} perStats_t;


typedef enum{
    LE_1M_PHY=  0x01,
    LE_2M_PHY=  0x02,
    LE_CODED_PHY=0x04,

}PhyModeCtrl_e;

typedef uint8_t ( *LL_PLUS_AdvDataFilterCB_t )(void);

typedef uint8_t ( *LL_PLUS_ScanRequestFilterCB_t )(void);

	
// Counters
typedef struct
{
  uint8 numTxDone;                                   // TX pkts ACK'ed (auto-empty not counted)
  uint8 numTxAck;                                    // TX pkts ACK'ed (both auto-empty and TX FIFO packets)
  uint8 numTxCtrlAck;                                // TX control pkts ACK'ed
  uint8 numTxCtrl;                                   // TX control pkts TX'ed
  uint8 numTxRetrans;                                // retrans + auto-empty retrans
  uint8 numTx;                                       // trans (incl. auto-empty) + retrans (incl. auto-empty)
  uint8 numRxOk;                                     // non-empty correctly RX'ed and not ignored data and control pkts
  uint8 numRxCtrl;                                   // correctly RX'ed control pkts
  uint8 numRxNotOk;                                  // RX'ed with bad CRC
  uint8 numRxIgnored;                                // correctly RX'ed, but ignored
  uint8 numRxEmpty;                                  // correctly RX'ed empty packets
  uint8 numRxFifoFull;                               // correctly RX'ed but discarded due to full RX FIFO
} rfCounters_t;


// global variables
extern uint8_t     		   LL_TaskID; 
extern uint8_t             llState;
extern peerInfo_t          peerInfo;
extern advInfo_t           adv_param;
extern scanInfo_t          scanInfo;                        // scan data
extern initInfo_t          initInfo;                        // Initiator info
extern extScanInfo_t       extScanInfo;                     // extended Scanner info
extern extInitInfo_t       extInitInfo;                     // extended Initiator info
extern chanMap_t           chanMapUpdate;
extern featureSet_t        deviceFeatureSet;
//extern preChanMapUpdate_t preChanMapUpdate[];

extern uint8               g_maxConnNum;
extern uint8               g_maxPktPerEventTx;
extern uint8               g_maxPktPerEventRx;
extern llConnState_t       *conn_param;

extern uint8               numComplPkts;
extern uint8               numComplPktsLimit;

extern verInfo_t         verInfo; 

extern  rfCounters_t  rfCounters;

extern  llConns_t     g_ll_conn_ctx;

extern llGlobalStatistics_t g_pmCounters;

extern llPduLenManagment_t g_llPduLen;
//extern llPhyModeManagment_t g_llPhyModeCtrl;

extern peerInfo_t        g_llWhitelist[];
// Resolving list
extern resolvingListInfo_t  g_llResolvinglist[]; 
extern uint8                g_llRlEnable;
extern uint8                g_llRlDeviceNum;                     // current device number in resolving list, should not exceed LL_RESOLVINGLIST_ENTRY_NUM
extern uint16               g_llRlTimeout;     

// extended advertiser
extern extAdvInfo_t        *g_pExtendedAdvInfo;
extern periodicAdvInfo_t   *g_pPeriodicAdvInfo;
extern uint8                g_extAdvNumber;           // number of ext adv set
extern uint8                g_perioAdvNumber;           // number of periodic adv set

extern uint16               g_advSetMaximumLen;

// extended adv scheduler context
extern llAdvScheduleInfo_t  *g_pAdvSchInfo;
extern uint8                g_schExtAdvNum;            // current schedule extended adv number
extern uint8                g_currentExtAdv;             // current schedule extended adv index

// ==== periodic adv scheduler context
extern llPeriodicAdvScheduleInfo_t  *g_pAdvSchInfo_periodic;        // periodic adv scheduler info
extern uint8          g_schExtAdvNum_periodic;              // current scheduler periodic adv number
extern uint8          g_currentExtAdv_periodic;             // current scheduler periodic adv index

extern uint32               g_advPerSlotTick;            // us
extern uint32               g_advSlotPeriodic;           // us
extern uint32               g_currentAdvTimer;           // us
extern uint32               g_timerExpiryTick;           // us

extern uint8                g_currentTimerTask; 

extern llSleepContext       g_llSleepContext;


extern llPeriodicScannerInfo_t    g_llPeriodAdvSyncInfo[];
// =========== BBB ROM code
#define    LL_TASK_EXTENDED_ADV           0x01
#define    LL_TASK_PERIODIC_ADV           0x02

#define    LL_TASK_EXTENDED_SCAN          0x03
#define    LL_TASK_EXTENDED_INIT          0x04
#define    LL_TASK_PERIODIC_SCAN          0x05
//#define    LL_TASK_SLAVE_CONN             0x03
//#define    LL_TASK_MASTER_CONN            0x04
#define    LL_TASK_OTHERS                 0x10
#define    LL_TASK_INVALID                0xFF
extern uint8    llTaskState;

extern extAdvHdr_t  ext_adv_hdr;

 // 2020-02-15 add for connectionless IQ Sample buffer
extern uint16 *g_pLLcteISample;
extern uint16 *g_pLLcteQSample;
#endif














