/******************************************************************************
 *
 *  Copyright (C) 2003-2014 Broadcom Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/
/******************************************************************************
 *
 *  The original Work has been changed by NXP.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *  Copyright 2018 NXP
 *
 ******************************************************************************/
/******************************************************************************
 *
 *  This is the private interface file for the NFA device manager.
 *
 ******************************************************************************/
#ifndef NFA_DM_INT_H
#define NFA_DM_INT_H

#include <string>
#include "nfa_api.h"
#include "nfa_sys.h"
#include "nfc_api.h"

/*****************************************************************************
**  Constants and data types
*****************************************************************************/

/* DM events */
enum {
  /* device manager local device API events */
  NFA_DM_API_ENABLE_EVT = NFA_SYS_EVT_START(NFA_ID_DM),
  NFA_DM_API_DISABLE_EVT,
  NFA_DM_API_SET_CONFIG_EVT,
  NFA_DM_API_GET_CONFIG_EVT,
  NFA_DM_API_REQUEST_EXCL_RF_CTRL_EVT,
  NFA_DM_API_RELEASE_EXCL_RF_CTRL_EVT,
  NFA_DM_API_ENABLE_POLLING_EVT,
  NFA_DM_API_DISABLE_POLLING_EVT,
  NFA_DM_API_ENABLE_LISTENING_EVT,
  NFA_DM_API_DISABLE_LISTENING_EVT,
  NFA_DM_API_PAUSE_P2P_EVT,
  NFA_DM_API_RESUME_P2P_EVT,
  NFA_DM_API_RAW_FRAME_EVT,
  NFA_DM_API_SET_P2P_LISTEN_TECH_EVT,
  NFA_DM_API_START_RF_DISCOVERY_EVT,
  NFA_DM_API_STOP_RF_DISCOVERY_EVT,
  NFA_DM_API_SET_RF_DISC_DURATION_EVT,
  NFA_DM_API_SELECT_EVT,
  NFA_DM_API_UPDATE_RF_PARAMS_EVT,
  NFA_DM_API_DEACTIVATE_EVT,
  NFA_DM_API_POWER_OFF_SLEEP_EVT,
  NFA_DM_API_REG_NDEF_HDLR_EVT,
  NFA_DM_API_DEREG_NDEF_HDLR_EVT,
  NFA_DM_API_REG_VSC_EVT,
  NFA_DM_API_SEND_VSC_EVT,
  NFA_DM_TIMEOUT_DISABLE_EVT,
  NFA_DM_API_SET_POWER_SUB_STATE_EVT,
  NFA_DM_API_SEND_RAW_VS_EVT,
#if (NXP_EXTNS == TRUE)
  NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT,
  NFA_DM_API_SET_TRANSIT_CONFIG_EVT,
#endif
  NFA_DM_MAX_EVT
};

/* data type for NFA_DM_API_ENABLE_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_DM_CBACK* p_dm_cback;
  tNFA_CONN_CBACK* p_conn_cback;
} tNFA_DM_API_ENABLE;

/* data type for NFA_DM_API_DISABLE_EVT */
typedef struct {
  NFC_HDR hdr;
  bool graceful;
} tNFA_DM_API_DISABLE;

/* data type for NFA_DM_API_SET_CONFIG_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_PMID param_id;
  uint8_t length;
  uint8_t* p_data;
} tNFA_DM_API_SET_CONFIG;

/* data type for NFA_DM_API_GET_CONFIG_EVT */
typedef struct {
  NFC_HDR hdr;
  uint8_t num_ids;
  tNFA_PMID* p_pmids;
} tNFA_DM_API_GET_CONFIG;

/* data type for NFA_DM_API_REQ_EXCL_RF_CTRL_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_TECHNOLOGY_MASK poll_mask;
  tNFA_LISTEN_CFG listen_cfg;
  tNFA_CONN_CBACK* p_conn_cback;
  tNFA_NDEF_CBACK* p_ndef_cback;
} tNFA_DM_API_REQ_EXCL_RF_CTRL;

/* data type for NFA_DM_API_ENABLE_POLLING_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_TECHNOLOGY_MASK poll_mask;
} tNFA_DM_API_ENABLE_POLL;

#if (NXP_EXTNS == TRUE)
/* data type for NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT*/
typedef struct
{
    NFC_HDR               hdr;
    tNFA_TECHNOLOGY_MASK listenTech;
    tNFA_TECHNOLOGY_MASK pollTech;
} tNFA_DM_API_CHANGE_DISCOVERY_TECH;
#endif
/* data type for NFA_DM_API_SET_P2P_LISTEN_TECH_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_TECHNOLOGY_MASK tech_mask;
} tNFA_DM_API_SET_P2P_LISTEN_TECH;

/* data type for NFA_DM_API_SELECT_EVT */
typedef struct {
  NFC_HDR hdr;
  uint8_t rf_disc_id;
  tNFA_NFC_PROTOCOL protocol;
  tNFA_INTF_TYPE rf_interface;
} tNFA_DM_API_SELECT;

/* data type for NFA_DM_API_UPDATE_RF_PARAMS_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_RF_COMM_PARAMS params;
} tNFA_DM_API_UPDATE_RF_PARAMS;

/* data type for NFA_DM_API_DEACTIVATE_EVT */
typedef struct {
  NFC_HDR hdr;
  bool sleep_mode;
} tNFA_DM_API_DEACTIVATE;

/* data type for NFA_DM_API_SET_RF_DISC_DURATION_EVT */
typedef struct {
  NFC_HDR hdr;
  uint16_t rf_disc_dur_ms;
} tNFA_DM_API_SET_RF_DISC_DUR;
#if (NXP_EXTNS == TRUE)
/* data type for NFA_DM_SET_TRANSIT_CONFIG*/
typedef struct {
  NFC_HDR hdr;
  tNFA_DM_CBACK* p_dm_cback;
  char* transitConfig;
} tNFA_DM_API_SET_TRANSIT_CONFIG;
#endif
/* data type for NFA_DM_API_REG_NDEF_HDLR_EVT */
#define NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE 0x01
#define NFA_NDEF_FLAGS_WKT_URI 0x02
#define NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED 0x04

typedef struct {
  NFC_HDR hdr;
  tNFA_HANDLE ndef_type_handle;
  uint8_t flags;
  tNFA_NDEF_CBACK* p_ndef_cback;
  tNFA_TNF tnf; /* Type-name field of record-type that was registered. */
  tNFA_NDEF_URI_ID
      uri_id; /* URI prefix abrieviation (for NFA_RegisterNDefUriHandler) */
  uint8_t name_len; /* Length of type name or absolute URI */
  uint8_t name[1];  /* Type name or absolute URI of record-type that got was
                       registered.    */
} tNFA_DM_API_REG_NDEF_HDLR;

/* data type for NFA_DM_API_DEREG_NDEF_HDLR_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_HANDLE ndef_type_handle;
} tNFA_DM_API_DEREG_NDEF_HDLR;

/* data type for NFA_DM_API_REG_VSC_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_VSC_CBACK* p_cback;
  bool is_register;
} tNFA_DM_API_REG_VSC;

/* data type for NFA_DM_API_SEND_VSC_EVT */
typedef struct {
  NFC_HDR hdr;
  tNFA_VSC_CBACK* p_cback;
  uint8_t oid;
  uint8_t cmd_params_len;
  uint16_t pad; /* add padding to ensure the size is big enough for
                   offset=NCI_VSC_MSG_HDR_SIZE */
  uint8_t* p_cmd_params;
} tNFA_DM_API_SEND_VSC;

/* data type for NFA_DM_API_SET_POWER_SUB_STATE_EVT */
typedef struct {
  NFC_HDR hdr;
  uint8_t screen_state;
} tNFA_DM_API_SET_POWER_SUB_STATE;

/* union of all data types */
typedef union {
  /* GKI event buffer header */
  NFC_HDR hdr;                      /* NFA_DM_API_RAW_FRAME_EVT             */
                                    /* NFA_DM_API_MULTI_TECH_RSP_EVT        */
                                    /* NFA_DM_API_RELEASE_EXCL_RF_CTRL      */
                                    /* NFA_DM_API_DISABLE_POLLING_EVT       */
                                    /* NFA_DM_API_START_RF_DISCOVERY_EVT    */
                                    /* NFA_DM_API_STOP_RF_DISCOVERY_EVT     */
  tNFA_DM_API_ENABLE enable;        /* NFA_DM_API_ENABLE_EVT                */
  tNFA_DM_API_DISABLE disable;      /* NFA_DM_API_DISABLE_EVT               */
  tNFA_DM_API_SET_CONFIG setconfig; /* NFA_DM_API_SET_CONFIG_EVT            */
  tNFA_DM_API_GET_CONFIG getconfig; /* NFA_DM_API_GET_CONFIG_EVT            */
  tNFA_DM_API_SET_RF_DISC_DUR
      disc_duration; /* NFA_DM_API_SET_RF_DISC_DURATION_EVT  */
  tNFA_DM_API_REG_NDEF_HDLR reg_ndef_hdlr; /* NFA_DM_API_REG_NDEF_HDLR_EVT */
  tNFA_DM_API_DEREG_NDEF_HDLR
      dereg_ndef_hdlr; /* NFA_DM_API_DEREG_NDEF_HDLR_EVT       */
  tNFA_DM_API_REQ_EXCL_RF_CTRL
      req_excl_rf_ctrl; /* NFA_DM_API_REQUEST_EXCL_RF_CTRL      */
  tNFA_DM_API_ENABLE_POLL enable_poll; /* NFA_DM_API_ENABLE_POLLING_EVT */
  tNFA_DM_API_SET_P2P_LISTEN_TECH
      set_p2p_listen_tech;   /* NFA_DM_API_SET_P2P_LISTEN_TECH_EVT   */
  tNFA_DM_API_SELECT select; /* NFA_DM_API_SELECT_EVT                */
  tNFA_DM_API_UPDATE_RF_PARAMS
      update_rf_params;              /* NFA_DM_API_UPDATE_RF_PARAMS_EVT      */
  tNFA_DM_API_DEACTIVATE deactivate; /* NFA_DM_API_DEACTIVATE_EVT            */
  tNFA_DM_API_SEND_VSC send_vsc;     /* NFA_DM_API_SEND_VSC_EVT              */
  tNFA_DM_API_REG_VSC reg_vsc;       /* NFA_DM_API_REG_VSC_EVT               */
  /* NFA_DM_API_SET_POWER_SUB_STATE_EVT */
  tNFA_DM_API_SET_POWER_SUB_STATE set_power_state;
#if (NXP_EXTNS == TRUE)
  tNFA_DM_API_CHANGE_DISCOVERY_TECH       change_discovery_tech;      /* NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT        */
  tNFA_DM_API_SET_TRANSIT_CONFIG transit_config; /* NFA_DM_SET_TRANSIT_CONFIG */
#endif
} tNFA_DM_MSG;

/* DM RF discovery state */
enum {
  NFA_DM_RFST_IDLE,               /* idle state                     */
  NFA_DM_RFST_DISCOVERY,          /* discovery state                */
  NFA_DM_RFST_W4_ALL_DISCOVERIES, /* wait for all discoveries state */
  NFA_DM_RFST_W4_HOST_SELECT,     /* wait for host selection state  */
  NFA_DM_RFST_POLL_ACTIVE,        /* poll mode activated state      */
  NFA_DM_RFST_LISTEN_ACTIVE,      /* listen mode activated state    */
  NFA_DM_RFST_LISTEN_SLEEP,       /* listen mode sleep state        */
  NFA_DM_RFST_LP_LISTEN,          /* Listening in Low Power mode    */
  NFA_DM_RFST_LP_ACTIVE           /* Activated in Low Power mode    */
};
typedef uint8_t tNFA_DM_RF_DISC_STATE;

/* DM RF discovery state machine event */
enum {
  NFA_DM_RF_DISCOVER_CMD,        /* start RF discovery                    */
  NFA_DM_RF_DISCOVER_RSP,        /* discover response from NFCC           */
  NFA_DM_RF_DISCOVER_NTF,        /* RF discovery NTF from NFCC            */
  NFA_DM_RF_DISCOVER_SELECT_CMD, /* select discovered target              */
  NFA_DM_RF_DISCOVER_SELECT_RSP, /* select response from NFCC             */
  NFA_DM_RF_INTF_ACTIVATED_NTF,  /* RF interface activation NTF from NFCC */
  NFA_DM_RF_DEACTIVATE_CMD,      /* deactivate RF interface               */
  NFA_DM_RF_DEACTIVATE_RSP,      /* deactivate response from NFCC         */
  NFA_DM_RF_DEACTIVATE_NTF,      /* deactivate RF interface NTF from NFCC */
  NFA_DM_LP_LISTEN_CMD,          /* NFCC is listening in low power mode   */
  NFA_DM_CORE_INTF_ERROR_NTF,    /* RF interface error NTF from NFCC      */
  NFA_DM_DISC_SM_MAX_EVENT
};
typedef uint8_t tNFA_DM_RF_DISC_SM_EVENT;

/* DM RF discovery state machine data */
typedef struct {
  uint8_t rf_disc_id;
  tNFA_NFC_PROTOCOL protocol;
  tNFA_INTF_TYPE rf_interface;
} tNFA_DM_DISC_SELECT_PARAMS;

typedef union {
  tNFC_DISCOVER nfc_discover;        /* discovery data from NFCC    */
  tNFC_DEACT_TYPE deactivate_type;   /* deactivation type           */
  tNFA_DM_DISC_SELECT_PARAMS select; /* selected target information */
} tNFA_DM_RF_DISC_DATA;

/* Callback event from NFA DM RF Discovery to other NFA sub-modules */
enum {
  NFA_DM_RF_DISC_START_EVT, /* discovery started with protocol, technology and
                               mode       */
  NFA_DM_RF_DISC_ACTIVATED_EVT,  /* activated with configured protocol,
                                    technology and mode    */
  NFA_DM_RF_DISC_DEACTIVATED_EVT /* deactivated sleep or idle */
};
typedef uint8_t tNFA_DM_RF_DISC_EVT;

/* Combined NFC Technology and protocol bit mask */
#define NFA_DM_DISC_MASK_PA_T1T 0x00000001
#define NFA_DM_DISC_MASK_PA_T2T 0x00000002
#define NFA_DM_DISC_MASK_PA_ISO_DEP 0x00000004
#define NFA_DM_DISC_MASK_PA_NFC_DEP 0x00000008
#define NFA_DM_DISC_MASK_PB_ISO_DEP 0x00000010
#define NFA_DM_DISC_MASK_PF_T3T 0x00000020
#define NFA_DM_DISC_MASK_PF_NFC_DEP 0x00000040
#define NFA_DM_DISC_MASK_P_T5T 0x00000100
#define NFA_DM_DISC_MASK_P_B_PRIME 0x00000200
#define NFA_DM_DISC_MASK_P_KOVIO 0x00000400
#define NFA_DM_DISC_MASK_PAA_NFC_DEP 0x00000800
#define NFA_DM_DISC_MASK_PACM_NFC_DEP 0x00000800
#define NFA_DM_DISC_MASK_PFA_NFC_DEP 0x00001000
/* Legacy/proprietary/non-NFC Forum protocol (e.g Shanghai transit card) */
#define NFA_DM_DISC_MASK_P_LEGACY 0x00002000
#define NFA_DM_DISC_MASK_POLL 0x0000FFFF

#define NFA_DM_DISC_MASK_LA_T1T 0x00010000
#define NFA_DM_DISC_MASK_LA_T2T 0x00020000
#define NFA_DM_DISC_MASK_LA_ISO_DEP 0x00040000
#define NFA_DM_DISC_MASK_LA_NFC_DEP 0x00080000
#define NFA_DM_DISC_MASK_LB_ISO_DEP 0x00100000
#define NFA_DM_DISC_MASK_LF_T3T 0x00200000
#define NFA_DM_DISC_MASK_LF_NFC_DEP 0x00400000
#define NFA_DM_DISC_MASK_L_ISO15693 0x01000000
#define NFA_DM_DISC_MASK_L_B_PRIME 0x02000000
#define NFA_DM_DISC_MASK_LACM_NFC_DEP 0x04000000
#define NFA_DM_DISC_MASK_LAA_NFC_DEP 0x04000000
#define NFA_DM_DISC_MASK_LFA_NFC_DEP 0x08000000
#define NFA_DM_DISC_MASK_L_LEGACY 0x10000000
#define NFA_DM_DISC_MASK_LISTEN 0xFFFF0000

#define NFA_DM_DISC_MASK_NFC_DEP 0x0C481848

typedef uint32_t tNFA_DM_DISC_TECH_PROTO_MASK;

/* DM RF discovery host ID */
#define NFA_DM_DISC_HOST_ID_DH NFC_DH_ID
typedef uint8_t tNFA_DM_DISC_HOST_ID;

/* DM deactivation callback type */
typedef void(tNFA_DISCOVER_CBACK)(tNFA_DM_RF_DISC_EVT event,
                                  tNFC_DISCOVER* p_data);

/* DM RF discovery action flags */
/* RF discovery process has been started        */
#define NFA_DM_DISC_FLAGS_ENABLED 0x0001
/* Stop RF discovery is pending                 */
#define NFA_DM_DISC_FLAGS_STOPPING 0x0002
/* Disable NFA is pending                       */
#define NFA_DM_DISC_FLAGS_DISABLING 0x0004
/* Sleep wakeup in progress                     */
#define NFA_DM_DISC_FLAGS_CHECKING 0x0008
/* Notify sub-module that discovery is starting */
#define NFA_DM_DISC_FLAGS_NOTIFY 0x0010
/* command has been sent to NFCC in the state   */
#define NFA_DM_DISC_FLAGS_W4_RSP 0x0020
/* wait for NTF before changing discovery state */
#define NFA_DM_DISC_FLAGS_W4_NTF 0x0040

typedef uint16_t tNFA_DM_DISC_FLAGS;

/* DM Discovery control block */
typedef struct {
  bool in_use;                       /* TRUE if used          */
  tNFA_DISCOVER_CBACK* p_disc_cback; /* discovery callback    */

  tNFA_DM_DISC_FLAGS disc_flags; /* specific action flags */
  tNFA_DM_DISC_HOST_ID host_id;  /* DH or UICC1/UICC2     */
  tNFA_DM_DISC_TECH_PROTO_MASK
      requested_disc_mask; /* technology and protocol requested              */
  tNFA_DM_DISC_TECH_PROTO_MASK
      selected_disc_mask; /* technology and protocol waiting for activation */
} tNFA_DM_DISC_ENTRY;

/* polling, raw listen, P2P listen, NDEF CE, 2xVSE, 2xUICC */
#define NFA_DM_DISC_NUM_ENTRIES 8

/* max discovery technology parameters */
#define NFA_DM_MAX_DISC_PARAMS 16

/* index of listen mode routing table for technologies */
enum {
  NFA_DM_DISC_LRT_NFC_A,
  NFA_DM_DISC_LRT_NFC_B,
  NFA_DM_DISC_LRT_NFC_F,
  NFA_DM_DISC_LRT_NFC_BP
};

/* NFA_EE_MAX_TECH_ROUTE. only A, B, F, Bprime are supported by UICC now */
#define NFA_DM_MAX_TECH_ROUTE 4

/* timeout for waiting deactivation NTF,
** possible delay to send deactivate CMD if all credit wasn't returned
** transport delay (1sec) and max RWT (5sec)
*/
#define NFA_DM_DISC_TIMEOUT_W4_DEACT_NTF (NFC_DEACTIVATE_TIMEOUT * 1000 + 6000)

typedef struct {
  uint16_t disc_duration; /* Disc duration                                    */
  tNFA_DM_DISC_FLAGS disc_flags;    /* specific action flags */
  tNFA_DM_RF_DISC_STATE disc_state; /* RF discovery state */

  tNFC_RF_TECH_N_MODE activated_tech_mode; /* activated technology and mode */
  uint8_t activated_rf_disc_id;            /* activated RF discovery ID */
  tNFA_INTF_TYPE activated_rf_interface;   /* activated RF interface */
  tNFA_NFC_PROTOCOL activated_protocol;    /* activated protocol */
  tNFA_HANDLE activated_handle;            /* handle of activated sub-module */
  uint8_t activated_sel_res; /* activated tag's SEL_RES response */

  tNFA_DM_DISC_ENTRY entry[NFA_DM_DISC_NUM_ENTRIES];

  tNFA_DM_DISC_ENTRY excl_disc_entry; /* exclusive RF discovery */
  tNFA_LISTEN_CFG excl_listen_config; /* listen cfg for exclusive-rf mode */

  uint8_t listen_RT[NFA_DM_MAX_TECH_ROUTE]; /* Host ID for A, B, F, B'
                                               technology routing*/
  tNFA_DM_DISC_TECH_PROTO_MASK
      dm_disc_mask; /* technology and protocol waiting for activation   */

  TIMER_LIST_ENT tle; /* timer for waiting deactivation NTF               */
  TIMER_LIST_ENT kovio_tle; /* timer for Kovio bar code tag presence check */

  bool deact_pending; /* TRUE if deactivate while checking presence       */
  bool deact_notify_pending; /* TRUE if notify DEACTIVATED EVT while Stop rf
                                discovery*/
  tNFA_DEACTIVATE_TYPE pending_deact_type; /* pending deactivate type */

} tNFA_DM_DISC_CB;

/* NDEF Type Handler Definitions */
/* Default handler entry in ndef_handler table      */
#define NFA_NDEF_DEFAULT_HANDLER_IDX 0

/* Maximum number of pending SetConfigs */
#define NFA_DM_SETCONFIG_PENDING_MAX 32

/* NFA_DM flags */
/* DM is enabled                                                        */
#define NFA_DM_FLAGS_DM_IS_ACTIVE 0x00000001
/* Exclusive RF mode is active                                          */
#define NFA_DM_FLAGS_EXCL_RF_ACTIVE 0x00000002
/* Polling is enabled (while not in exclusive RF mode                   */
#define NFA_DM_FLAGS_POLLING_ENABLED 0x00000004
/* send poll stop event                                                 */
#define NFA_DM_FLAGS_SEND_POLL_STOP_EVT 0x00000008
/* auto reading of NDEF in progress                                     */
#define NFA_DM_FLAGS_AUTO_READING_NDEF 0x00000010
/* NFA_DM_ENABLE_EVT is not reported yet                                */
#define NFA_DM_FLAGS_ENABLE_EVT_PEND 0x00000020
/* Send NFA_DEACTIVATED_EVT when deactivated                            */
#define NFA_DM_FLAGS_SEND_DEACTIVATED_EVT 0x00000040
/* NFCC is restoring after back to full power mode                      */
#define NFA_DM_FLAGS_NFCC_IS_RESTORING 0x00000100
/* NFCC power mode is updating                                          */
#define NFA_DM_FLAGS_SETTING_PWR_MODE 0x00000200
/* NFA DM is disabling NFC                                              */
#define NFA_DM_FLAGS_DM_DISABLING_NFC 0x00000400
/* NFA_SendRawFrame() is called since RF activation                     */
#define NFA_DM_FLAGS_RAW_FRAME 0x00000800
/* NFA_DisableListening() is called and engaged                         */
#define NFA_DM_FLAGS_LISTEN_DISABLED 0x00001000
/* NFA_PauseP2p() is called and engaged                         */
#define NFA_DM_FLAGS_P2P_PAUSED 0x00002000
/* Power Off Sleep                                                      */
#define NFA_DM_FLAGS_POWER_OFF_SLEEP 0x00008000
#if (NXP_EXTNS == TRUE)
#define NFA_DM_FLAGS_DISCOVERY_TECH_CHANGED     0x20000000  /* NFA_ChangeDiscoveryTech() is called and engaged                         */
#endif
/* stored parameters */
typedef struct {
  uint8_t total_duration[NCI_PARAM_LEN_TOTAL_DURATION];

  uint8_t la_bit_frame_sdd[NCI_PARAM_LEN_LA_BIT_FRAME_SDD];
  uint8_t la_bit_frame_sdd_len;
  uint8_t la_platform_config[NCI_PARAM_LEN_LA_PLATFORM_CONFIG];
  uint8_t la_platform_config_len;
  uint8_t la_sel_info[NCI_PARAM_LEN_LA_SEL_INFO];
  uint8_t la_sel_info_len;
  uint8_t la_nfcid1[NCI_NFCID1_MAX_LEN];
  uint8_t la_nfcid1_len;
  uint8_t la_hist_by[NCI_MAX_HIS_BYTES_LEN];
  uint8_t la_hist_by_len;

  uint8_t lb_sensb_info[NCI_PARAM_LEN_LB_SENSB_INFO];
  uint8_t lb_sensb_info_len;
  uint8_t lb_nfcid0[NCI_PARAM_LEN_LB_NFCID0];
  uint8_t lb_nfcid0_len;
  uint8_t lb_appdata[NCI_PARAM_LEN_LB_APPDATA];
  uint8_t lb_appdata_len;
  uint8_t lb_adc_fo[NCI_PARAM_LEN_LB_ADC_FO];
  uint8_t lb_adc_fo_len;
  uint8_t lb_h_info[NCI_MAX_ATTRIB_LEN];
  uint8_t lb_h_info_len;

  uint8_t lf_protocol[NCI_PARAM_LEN_LF_PROTOCOL];
  uint8_t lf_protocol_len;
  uint8_t lf_t3t_flags2[NCI_PARAM_LEN_LF_T3T_FLAGS2];
  uint8_t lf_t3t_flags2_len;
  uint8_t lf_t3t_pmm[NCI_PARAM_LEN_LF_T3T_PMM];
  uint8_t lf_t3t_id[NFA_CE_LISTEN_INFO_MAX]
                   [NCI_PARAM_LEN_LF_T3T_ID(NCI_VERSION_2_0)];

  uint8_t fwi[NCI_PARAM_LEN_FWI];
  uint8_t wt[NCI_PARAM_LEN_WT];
  uint8_t atr_req_gen_bytes[NCI_MAX_GEN_BYTES_LEN];
  uint8_t atr_req_gen_bytes_len;
  uint8_t atr_res_gen_bytes[NCI_MAX_GEN_BYTES_LEN];
  uint8_t atr_res_gen_bytes_len;

  uint8_t pf_rc[NCI_PARAM_LEN_PF_RC];
} tNFA_DM_PARAMS;

/*
**  NFA_NDEF CHO callback
**  It returns TRUE if NDEF is handled by connection handover module.
*/
typedef bool(tNFA_NDEF_CHO_CBACK)(uint32_t ndef_len, uint8_t* p_ndef_data);

/* DM control block */
typedef struct {
  uint32_t flags; /* NFA_DM flags (see definitions for NFA_DM_FLAGS_*)    */
  tNFA_DM_CBACK* p_dm_cback; /* NFA DM callback */
  TIMER_LIST_ENT tle;

  /* NFC link connection management */
  tNFA_CONN_CBACK* p_conn_cback;  /* callback for connection events       */
  tNFA_TECHNOLOGY_MASK poll_mask; /* technologies being polled            */

  tNFA_CONN_CBACK* p_excl_conn_cback; /* exclusive RF mode callback           */
  tNFA_NDEF_CBACK* p_excl_ndef_cback; /* ndef callback for exclusive RF mdoe  */

  tNFA_NDEF_CHO_CBACK*
      p_ndef_cho_cback; /* NDEF callback for static connection handover */

  tNFA_HANDLE poll_disc_handle; /* discovery handle for polling         */

  uint8_t* p_activate_ntf; /* temp holding activation notfication  */
  tHAL_API_GET_MAX_NFCEE* get_max_ee;

  tNFC_RF_TECH_N_MODE
      activated_tech_mode; /* previous activated technology and mode */
  uint8_t activated_nfcid[NFC_KOVIO_MAX_LEN]; /* NFCID 0/1/2 or UID of
                                                 ISO15694/Kovio  */
  uint8_t activated_nfcid_len; /* length of NFCID or UID               */

  /* NFC link discovery management */
  tNFA_DM_DISC_CB disc_cb;

  /* NDEF Type handler */
  tNFA_DM_API_REG_NDEF_HDLR*
      p_ndef_handler[NFA_NDEF_MAX_HANDLERS]; /* ndef handler table */

  /* stored parameters */
  tNFA_DM_PARAMS params;

  /* SetConfig management */
  uint32_t setcfg_pending_mask; /* Mask of to indicate whether pending
                                   SET_CONFIGs require NFA_DM_SET_CONFIG_EVT.
                                   LSB=oldest pending */
  uint8_t setcfg_pending_num;   /* Number of setconfigs pending */

  /* NFCC power mode */
  uint8_t nfcc_pwr_mode; /* NFA_DM_PWR_MODE_FULL or NFA_DM_PWR_MODE_OFF_SLEEP */

  uint8_t deactivate_cmd_retry_count; /*number of times the deactivation cmd
                                         sent in case of error scenerio */

  uint8_t power_state; /* current screen/power  state */
  uint32_t eDtaMode;   /* To enable the DTA type modes. */
#if (NXP_EXTNS == TRUE)
  uint8_t nfa_pending_power_state;
  tNFA_TECHNOLOGY_MASK        pollTech;
  tNFA_TECHNOLOGY_MASK        listenTech;
  uint8_t selected_uicc_id; /* Current selected UICC ID */
#endif
} tNFA_DM_CB;

/* Internal function prototypes */
void nfa_dm_ndef_handle_message(tNFA_STATUS status, uint8_t* p_msg_buf,
                                uint32_t len);
void nfa_dm_ndef_dereg_all(void);
void nfa_dm_act_conn_cback_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data);
void nfa_dm_notify_activation_status(tNFA_STATUS status,
                                     tNFA_TAG_PARAMS* p_params);
#if (NXP_EXTNS == TRUE)
bool nfa_dm_act_change_discovery_tech(tNFA_DM_MSG *p_data);
#endif
bool nfa_dm_act_send_raw_vs(tNFA_DM_MSG* p_data);

void nfa_dm_disable_complete(void);

/* Internal functions from nfa_rw */
void nfa_rw_init(void);
void nfa_rw_proc_disc_evt(tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER* p_data,
                          bool excl_rf_not_active);
tNFA_STATUS nfa_rw_send_raw_frame(NFC_HDR* p_data);

/* Internal functions from nfa_ce */
void nfa_ce_init(void);

/* Pointer to compile-time configuration structure */
extern tNFA_DM_DISC_FREQ_CFG* p_nfa_dm_rf_disc_freq_cfg;
extern tNFA_HCI_CFG* p_nfa_hci_cfg;
extern tNFA_DM_CFG* p_nfa_dm_cfg;
extern uint8_t* p_nfa_dm_ce_cfg;
extern uint8_t* p_nfa_dm_gen_cfg;
extern uint8_t nfa_ee_max_ee_cfg;
extern tNCI_DISCOVER_MAPS* p_nfa_dm_interface_mapping;
extern uint8_t nfa_dm_num_dm_interface_mapping;
extern bool nfa_poll_bail_out_mode;

void nfa_dm_poll_disc_cback_dta_wrapper(tNFA_DM_RF_DISC_EVT event,
                                        tNFC_DISCOVER* p_data);
extern unsigned char appl_dta_mode_flag;

/* NFA device manager control block */
extern tNFA_DM_CB nfa_dm_cb;

void nfa_dm_init(void);
void nfa_p2p_init(void);
#if (NFA_SNEP_INCLUDED == TRUE)
void nfa_snep_init(bool is_dta_mode);
#else
#define nfa_snep_init(is_dta_mode)
#endif

#if (NFC_NFCEE_INCLUDED == TRUE)
void nfa_ee_init(void);
void nfa_hci_init(void);
#else
#define nfa_ee_init()
#define nfa_hci_init()
#endif

/* Action function prototypes */
bool nfa_dm_enable(tNFA_DM_MSG* p_data);
bool nfa_dm_disable(tNFA_DM_MSG* p_data);
bool nfa_dm_set_config(tNFA_DM_MSG* p_data);
bool nfa_dm_get_config(tNFA_DM_MSG* p_data);
bool nfa_dm_act_request_excl_rf_ctrl(tNFA_DM_MSG* p_data);
bool nfa_dm_act_release_excl_rf_ctrl(tNFA_DM_MSG* p_data);
bool nfa_dm_act_enable_polling(tNFA_DM_MSG* p_data);
bool nfa_dm_act_disable_polling(tNFA_DM_MSG* p_data);
bool nfa_dm_act_enable_listening(tNFA_DM_MSG* p_data);
bool nfa_dm_act_disable_listening(tNFA_DM_MSG* p_data);
bool nfa_dm_act_pause_p2p(tNFA_DM_MSG* p_data);
bool nfa_dm_act_resume_p2p(tNFA_DM_MSG* p_data);
bool nfa_dm_act_send_raw_frame(tNFA_DM_MSG* p_data);
bool nfa_dm_set_p2p_listen_tech(tNFA_DM_MSG* p_data);
bool nfa_dm_act_start_rf_discovery(tNFA_DM_MSG* p_data);
bool nfa_dm_act_stop_rf_discovery(tNFA_DM_MSG* p_data);
bool nfa_dm_act_set_rf_disc_duration(tNFA_DM_MSG* p_data);
bool nfa_dm_act_select(tNFA_DM_MSG* p_data);
bool nfa_dm_act_update_rf_params(tNFA_DM_MSG* p_data);
bool nfa_dm_act_deactivate(tNFA_DM_MSG* p_data);
bool nfa_dm_act_power_off_sleep(tNFA_DM_MSG* p_data);
bool nfa_dm_ndef_reg_hdlr(tNFA_DM_MSG* p_data);
bool nfa_dm_ndef_dereg_hdlr(tNFA_DM_MSG* p_data);

bool nfa_dm_act_reg_vsc(tNFA_DM_MSG* p_data);
bool nfa_dm_act_send_vsc(tNFA_DM_MSG* p_data);
uint16_t nfa_dm_act_get_rf_disc_duration();
bool nfa_dm_act_disable_timeout(tNFA_DM_MSG* p_data);

bool nfa_dm_set_power_sub_state(tNFA_DM_MSG* p_data);

void nfa_dm_proc_nfcc_power_mode(uint8_t nfcc_power_mode);
#if (NXP_EXTNS == TRUE)
bool nfa_dm_set_transit_config(tNFA_DM_MSG* p_data);
#endif
/* Main function prototypes */
bool nfa_dm_evt_hdlr(NFC_HDR* p_msg);
void nfa_dm_sys_enable(void);
void nfa_dm_sys_disable(void);
tNFA_STATUS nfa_dm_check_set_config(uint8_t tlv_list_len, uint8_t* p_tlv_list,
                                    bool app_init);

void nfa_dm_conn_cback_event_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data);

/* Discovery function prototypes */
void nfa_dm_disc_sm_execute(tNFA_DM_RF_DISC_SM_EVENT event,
                            tNFA_DM_RF_DISC_DATA* p_data);
tNFA_HANDLE nfa_dm_add_rf_discover(tNFA_DM_DISC_TECH_PROTO_MASK disc_mask,
                                   tNFA_DM_DISC_HOST_ID host_id,
                                   tNFA_DISCOVER_CBACK* p_disc_cback);
void nfa_dm_delete_rf_discover(tNFA_HANDLE handle);
void nfa_dm_start_excl_discovery(tNFA_TECHNOLOGY_MASK poll_tech_mask,
                                 tNFA_LISTEN_CFG* p_listen_cfg,
                                 tNFA_DISCOVER_CBACK* p_disc_cback);
void nfa_dm_rel_excl_rf_control_and_notify(void);
void nfa_dm_stop_excl_discovery(void);
void nfa_dm_disc_new_state(tNFA_DM_RF_DISC_STATE new_state);

void nfa_dm_start_rf_discover(void);
void nfa_dm_rf_discover_select(uint8_t rf_disc_id, tNFA_NFC_PROTOCOL protocol,
                               tNFA_INTF_TYPE rf_interface);
tNFA_STATUS nfa_dm_rf_deactivate(tNFA_DEACTIVATE_TYPE deactivate_type);
bool nfa_dm_is_protocol_supported(tNFA_NFC_PROTOCOL protocol, uint8_t sel_res);
bool nfa_dm_is_active(void);
tNFC_STATUS nfa_dm_disc_sleep_wakeup(void);
tNFC_STATUS nfa_dm_disc_start_kovio_presence_check(void);
bool nfa_dm_is_raw_frame_session(void);
bool nfa_dm_is_p2p_paused(void);

#if (NFC_NFCEE_INCLUDED == FALSE)
#define nfa_ee_get_tech_route(ps, ha) \
  memset(ha, NFC_DH_ID, NFA_DM_MAX_TECH_ROUTE);
#endif

std::string nfa_dm_nfc_revt_2_str(tNFC_RESPONSE_EVT event);
#if (NXP_EXTNS == TRUE)
tNFC_STATUS nfc_ncif_reset_nfcc();
bool nfa_dm_is_hci_supported();
#endif

#endif /* NFA_DM_INT_H */