Home | History | Annotate | Download | only in dm
      1 /******************************************************************************
      2  *
      3  *  Copyright (C) 2010-2013 Broadcom Corporation
      4  *
      5  *  Licensed under the Apache License, Version 2.0 (the "License");
      6  *  you may not use this file except in compliance with the License.
      7  *  You may obtain a copy of the License at:
      8  *
      9  *  http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  *
     17  ******************************************************************************/
     18 
     19 
     20 /******************************************************************************
     21  *
     22  *  This file contains the action functions for device manager state
     23  *  machine.
     24  *
     25  ******************************************************************************/
     26 #include <string.h>
     27 #include "nfa_sys.h"
     28 #include "nfa_api.h"
     29 #include "nfa_dm_int.h"
     30 #include "nfa_sys_int.h"
     31 #include "nfa_ce_int.h"
     32 #include "nfc_api.h"
     33 #include "nfa_rw_int.h"
     34 #include "nfa_rw_api.h"
     35 #include "nfa_p2p_int.h"
     36 #include "nci_hmsgs.h"
     37 
     38 #if (defined (NFA_CHO_INCLUDED) && (NFA_CHO_INCLUDED==TRUE))
     39 #include "nfa_cho_int.h"
     40 #endif
     41 
     42 #if (NFC_NFCEE_INCLUDED == TRUE)
     43 #include "nfa_ee_int.h"
     44 #include "nfa_hci_int.h"
     45 #endif
     46 
     47 #if (defined (NFA_SNEP_INCLUDED) && (NFA_SNEP_INCLUDED==TRUE))
     48 #include "nfa_snep_int.h"
     49 #endif
     50 
     51 /* This is the timeout value to guarantee disable is performed within reasonable amount of time */
     52 #ifndef NFA_DM_DISABLE_TIMEOUT_VAL
     53 #define NFA_DM_DISABLE_TIMEOUT_VAL         1000
     54 #endif
     55 
     56 static void nfa_dm_set_init_nci_params (void);
     57 static tNFA_STATUS nfa_dm_start_polling (void);
     58 static BOOLEAN nfa_dm_deactivate_polling (void);
     59 static void nfa_dm_excl_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data);
     60 static void nfa_dm_poll_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data);
     61 
     62 
     63 /*******************************************************************************
     64 **
     65 ** Function         nfa_dm_module_init_cback
     66 **
     67 ** Description      Processing initialization complete event from sub-modules
     68 **
     69 ** Returns          None
     70 **
     71 *******************************************************************************/
     72 static void nfa_dm_module_init_cback (void)
     73 {
     74     tNFA_DM_CBACK_DATA dm_cback_data;
     75 
     76     nfa_dm_cb.flags &= ~NFA_DM_FLAGS_ENABLE_EVT_PEND;
     77 
     78     /* All subsystem are initialized */
     79     dm_cback_data.status = NFA_STATUS_OK;
     80     (*nfa_dm_cb.p_dm_cback) (NFA_DM_ENABLE_EVT, &dm_cback_data);
     81 }
     82 
     83 /*******************************************************************************
     84 **
     85 ** Function         nfa_dm_nfcc_power_mode_proc_complete_cback
     86 **
     87 ** Description      Processing complete of processing NFCC power state change
     88 **                  from all sub-modules
     89 **
     90 ** Returns          None
     91 **
     92 *******************************************************************************/
     93 static void nfa_dm_nfcc_power_mode_proc_complete_cback (void)
     94 {
     95     tNFA_DM_PWR_MODE_CHANGE power_mode_change;
     96 
     97     NFA_TRACE_DEBUG1 ("nfa_dm_nfcc_power_mode_proc_complete_cback () nfcc_pwr_mode = 0x%x",
     98                       nfa_dm_cb.nfcc_pwr_mode);
     99 
    100     /* if NFCC power state is change to full power */
    101     if (nfa_dm_cb.nfcc_pwr_mode != NFA_DM_PWR_MODE_OFF_SLEEP)
    102     {
    103         nfa_dm_cb.flags &= ~NFA_DM_FLAGS_NFCC_IS_RESTORING;
    104 
    105         /* reconfigure BRCM NFCC */
    106         nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_CMD, NULL);
    107     }
    108 
    109     nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SETTING_PWR_MODE;
    110 
    111     power_mode_change.status     = NFA_STATUS_OK;
    112     power_mode_change.power_mode = nfa_dm_cb.nfcc_pwr_mode;
    113     (*nfa_dm_cb.p_dm_cback) (NFA_DM_PWR_MODE_CHANGE_EVT, (tNFA_DM_CBACK_DATA*) &power_mode_change);
    114 }
    115 /*******************************************************************************
    116 **
    117 ** Function         nfa_dm_sys_enable
    118 **
    119 ** Description      This function on enable
    120 **
    121 ** Returns          void
    122 **
    123 *******************************************************************************/
    124 void nfa_dm_sys_enable (void)
    125 {
    126     nfa_dm_set_init_nci_params ();
    127 }
    128 
    129 /*******************************************************************************
    130 **
    131 ** Function         nfa_dm_set_init_nci_params
    132 **
    133 ** Description      Set initial NCI configuration parameters
    134 **
    135 ** Returns          void
    136 **
    137 *******************************************************************************/
    138 static void nfa_dm_set_init_nci_params (void)
    139 {
    140     UINT8   xx;
    141 
    142     /* set NCI default value if other than zero */
    143 
    144     /* LF_T3T_IDENTIFIERS_1/2/.../16 */
    145     for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++)
    146     {
    147         nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
    148         nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
    149         nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
    150         nfa_dm_cb.params.lf_t3t_id[xx][2] = 0xFE;
    151     }
    152 
    153     /* LF_T3T_PMM */
    154     for (xx = 0; xx < NCI_PARAM_LEN_LF_T3T_PMM; xx++)
    155     {
    156         nfa_dm_cb.params.lf_t3t_pmm[xx] = 0xFF;
    157     }
    158 
    159     /* LF_T3T_FLAGS:
    160     ** DH needs to set this configuration, even if default value (not listening) is used,
    161     ** to let NFCC know of intention (not listening) of DH.
    162     */
    163 
    164     /* FWI */
    165     nfa_dm_cb.params.fwi[0] = 0x04;
    166 
    167     /* WT */
    168     nfa_dm_cb.params.wt[0] = 14;
    169 
    170     /* Set CE default configuration */
    171     if (p_nfa_dm_ce_cfg[0])
    172     {
    173         nfa_dm_check_set_config (p_nfa_dm_ce_cfg[0], &p_nfa_dm_ce_cfg[1], FALSE);
    174     }
    175 
    176     /* Set optional general default configuration */
    177     if (p_nfa_dm_gen_cfg && p_nfa_dm_gen_cfg[0])
    178     {
    179         nfa_dm_check_set_config (p_nfa_dm_gen_cfg[0], &p_nfa_dm_gen_cfg[1], FALSE);
    180     }
    181 
    182     if (p_nfa_dm_interface_mapping && nfa_dm_num_dm_interface_mapping)
    183     {
    184         NFC_DiscoveryMap (nfa_dm_num_dm_interface_mapping, p_nfa_dm_interface_mapping, NULL);
    185     }
    186 }
    187 
    188 /*******************************************************************************
    189 **
    190 ** Function         nfa_dm_proc_nfcc_power_mode
    191 **
    192 ** Description      Processing NFCC power mode changes
    193 **
    194 ** Returns          None
    195 **
    196 *******************************************************************************/
    197 void nfa_dm_proc_nfcc_power_mode (UINT8 nfcc_power_mode)
    198 {
    199     NFA_TRACE_DEBUG1 ("nfa_dm_proc_nfcc_power_mode (): nfcc_power_mode=%d",
    200                        nfcc_power_mode);
    201 
    202     /* if NFCC power mode is change to full power */
    203     if (nfcc_power_mode == NFA_DM_PWR_MODE_FULL)
    204     {
    205         memset (&nfa_dm_cb.params, 0x00, sizeof (tNFA_DM_PARAMS));
    206         NFA_TRACE_DEBUG2 ("setcfg_pending_mask=0x%x, setcfg_pending_num=%d",
    207             nfa_dm_cb.setcfg_pending_mask, nfa_dm_cb.setcfg_pending_num);
    208         nfa_dm_cb.setcfg_pending_mask = 0;
    209         nfa_dm_cb.setcfg_pending_num  = 0;
    210 
    211         nfa_dm_set_init_nci_params ();
    212     }
    213 
    214     nfa_sys_cback_notify_nfcc_power_mode_proc_complete (NFA_ID_DM);
    215 }
    216 
    217 /*******************************************************************************
    218 **
    219 ** Function         nfa_dm_disable_event
    220 **
    221 ** Description      report disable event
    222 **
    223 ** Returns          void
    224 **
    225 *******************************************************************************/
    226 static void nfa_dm_disable_event (void)
    227 {
    228     /* Deregister DM from sys */
    229     nfa_sys_deregister (NFA_ID_DM);
    230 
    231     /* Notify app */
    232     nfa_dm_cb.flags &= ~(NFA_DM_FLAGS_DM_IS_ACTIVE
    233                         |NFA_DM_FLAGS_DM_DISABLING_NFC
    234                         |NFA_DM_FLAGS_ENABLE_EVT_PEND);
    235     (*nfa_dm_cb.p_dm_cback) (NFA_DM_DISABLE_EVT, NULL);
    236 }
    237 
    238 /*******************************************************************************
    239 **
    240 ** Function         nfa_dm_nfc_response_cback
    241 **
    242 ** Description      Call DM event hanlder with NFC response callback data
    243 **
    244 ** Returns          void
    245 **
    246 *******************************************************************************/
    247 static void nfa_dm_nfc_response_cback (tNFC_RESPONSE_EVT event, tNFC_RESPONSE *p_data)
    248 {
    249     tNFA_DM_CBACK_DATA dm_cback_data;
    250     tNFA_GET_CONFIG   *p_nfa_get_confg;
    251     tNFA_CONN_EVT_DATA conn_evt;
    252     UINT8 dm_cback_evt;
    253 
    254 #if (BT_TRACE_VERBOSE == TRUE)
    255     NFA_TRACE_DEBUG2 ("nfa_dm_nfc_response_cback () %s(0x%x)", nfa_dm_nfc_revt_2_str (event), event);
    256 #else
    257     NFA_TRACE_DEBUG1 ("nfa_dm_nfc_response_cback () event=0x%x", event);
    258 #endif
    259 
    260     switch (event)
    261     {
    262     case NFC_ENABLE_REVT:                        /* 0  Enable event */
    263 
    264         /* NFC stack enabled. Enable nfa sub-systems */
    265         if (p_data->enable.status == NFC_STATUS_OK)
    266         {
    267             nfa_dm_set_init_nci_params ();
    268 
    269             /* Initialize NFA subsystems */
    270             nfa_sys_enable_subsystems ();
    271         }
    272         else if (nfa_dm_cb.flags & NFA_DM_FLAGS_ENABLE_EVT_PEND)
    273         {
    274             /* Notify app */
    275             nfa_dm_cb.flags &= ~(NFA_DM_FLAGS_ENABLE_EVT_PEND | NFA_DM_FLAGS_DM_IS_ACTIVE);
    276             dm_cback_data.status = p_data->enable.status;
    277             (*nfa_dm_cb.p_dm_cback) (NFA_DM_ENABLE_EVT, &dm_cback_data);
    278         }
    279         break;
    280 
    281     case NFC_DISABLE_REVT:                       /* 1  Disable event */
    282         nfa_dm_disable_event ();
    283         break;
    284 
    285     case NFC_SET_CONFIG_REVT:                    /* 2  Set Config Response */
    286         /* If this setconfig was due to NFA_SetConfig, then notify the app */
    287         if (nfa_dm_cb.setcfg_pending_mask & 1)      /* lsb=whether last NCI_SET_CONFIG was due to NFA_SetConfig */
    288         {
    289             dm_cback_data.set_config.status         = p_data->set_config.status;
    290             dm_cback_data.set_config.num_param_id   = p_data->set_config.num_param_id;
    291             memcpy (dm_cback_data.set_config.param_ids, p_data->set_config.param_ids, p_data->set_config.num_param_id);
    292             (*nfa_dm_cb.p_dm_cback) (NFA_DM_SET_CONFIG_EVT, &dm_cback_data);
    293         }
    294 
    295         /* Update the pending mask */
    296         if (nfa_dm_cb.setcfg_pending_num>0)
    297         {
    298             nfa_dm_cb.setcfg_pending_mask >>= 1;
    299             nfa_dm_cb.setcfg_pending_num--;
    300         }
    301         else
    302         {
    303             /* This should not occur (means we got a SET_CONFIG_NTF that's unaccounted for */
    304             NFA_TRACE_ERROR0 ("NFA received unexpected NFC_SET_CONFIG_REVT");
    305         }
    306         break;
    307 
    308     case NFC_GET_CONFIG_REVT:                    /* 3  Get Config Response */
    309         if (p_data->get_config.status == NFC_STATUS_OK)
    310         {
    311             if ((p_nfa_get_confg = (tNFA_GET_CONFIG *) GKI_getbuf ((UINT16) (sizeof (tNFA_GET_CONFIG) + p_data->get_config.tlv_size))) != NULL)
    312             {
    313                 p_nfa_get_confg->status = NFA_STATUS_OK;
    314                 p_nfa_get_confg->tlv_size = p_data->get_config.tlv_size;
    315                 memcpy (p_nfa_get_confg->param_tlvs, p_data->get_config.p_param_tlvs, p_data->get_config.tlv_size);
    316                 (*nfa_dm_cb.p_dm_cback) (NFA_DM_GET_CONFIG_EVT, (tNFA_DM_CBACK_DATA *) p_nfa_get_confg);
    317 
    318                 GKI_freebuf (p_nfa_get_confg);
    319                 return;
    320             }
    321             else
    322             {
    323                 NFA_TRACE_DEBUG0 ("nfa_dm_nfc_response_cback unable to allocate buffer");
    324             }
    325         }
    326 
    327         /* Return result of getconfig to the app */
    328         dm_cback_data.get_config.status = NFA_STATUS_FAILED;
    329         (*nfa_dm_cb.p_dm_cback) (NFA_DM_GET_CONFIG_EVT, &dm_cback_data);
    330         break;
    331 
    332 #if (NFC_NFCEE_INCLUDED == TRUE)
    333     case NFC_NFCEE_DISCOVER_REVT:                /* NFCEE Discover response */
    334     case NFC_NFCEE_INFO_REVT:                    /* NFCEE Discover Notification */
    335     case NFC_EE_ACTION_REVT:                     /* EE Action notification */
    336     case NFC_NFCEE_MODE_SET_REVT:                /* NFCEE Mode Set response */
    337         nfa_ee_proc_evt (event, p_data);
    338         break;
    339 
    340     case NFC_EE_DISCOVER_REQ_REVT:               /* EE Discover Req notification */
    341         if (nfa_dm_is_active() &&
    342             (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY) )
    343         {
    344             nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);
    345         }
    346         nfa_ee_proc_evt (event, p_data);
    347         break;
    348 #endif
    349 
    350     case NFC_RF_FIELD_REVT:                      /* RF Field information            */
    351         dm_cback_data.rf_field.status          = NFA_STATUS_OK;
    352         dm_cback_data.rf_field.rf_field_status = p_data->rf_field.rf_field;
    353         (*nfa_dm_cb.p_dm_cback) (NFA_DM_RF_FIELD_EVT, &dm_cback_data);
    354         break;
    355 
    356     case NFC_SET_ROUTING_REVT:                   /* Configure Routing response */
    357         break;
    358 
    359     case NFC_GET_ROUTING_REVT:                   /* Retrieve Routing response */
    360         break;
    361 
    362     case NFC_GEN_ERROR_REVT:                     /* generic error command or notification */
    363         break;
    364 
    365     case NFC_NFCC_RESTART_REVT:                  /* NFCC has been re-initialized */
    366 
    367         if (p_data->status == NFC_STATUS_OK)
    368         {
    369             nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_FULL;
    370             nfa_dm_cb.flags |= NFA_DM_FLAGS_NFCC_IS_RESTORING;
    371 
    372             /* NFCC will start from IDLE when turned on again */
    373             nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
    374             nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
    375             nfa_dm_cb.disc_cb.disc_state = NFA_DM_RFST_IDLE;
    376         }
    377         else
    378         {
    379             nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_OFF_SLEEP;
    380         }
    381         /* Notify NFA submodules change of NFCC power mode */
    382         nfa_sys_cback_reg_nfcc_power_mode_proc_complete (nfa_dm_nfcc_power_mode_proc_complete_cback);
    383         nfa_sys_notify_nfcc_power_mode (nfa_dm_cb.nfcc_pwr_mode);
    384         break;
    385 
    386     case NFC_NFCC_TIMEOUT_REVT:
    387     case NFC_NFCC_TRANSPORT_ERR_REVT:
    388         NFA_TRACE_DEBUG1 ("flags:0x%08x", nfa_dm_cb.flags);
    389         dm_cback_evt = (event == NFC_NFCC_TIMEOUT_REVT) ? NFA_DM_NFCC_TIMEOUT_EVT : NFA_DM_NFCC_TRANSPORT_ERR_EVT;
    390         (*nfa_dm_cb.p_dm_cback) (dm_cback_evt, NULL);
    391         break;
    392 
    393     case NFC_NFCC_POWER_OFF_REVT:
    394         nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_OFF_SLEEP;
    395 
    396         /* Notify NFA submodules change of NFCC power mode */
    397         nfa_sys_cback_reg_nfcc_power_mode_proc_complete (nfa_dm_nfcc_power_mode_proc_complete_cback);
    398         nfa_sys_notify_nfcc_power_mode (NFA_DM_PWR_MODE_OFF_SLEEP);
    399         break;
    400 
    401     case NFC_RF_COMM_PARAMS_UPDATE_REVT:
    402         conn_evt.status = p_data->status;
    403         nfa_dm_conn_cback_event_notify (NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt);
    404         break;
    405 
    406 
    407     default:
    408         break;
    409     }
    410 }
    411 
    412 
    413 /*******************************************************************************
    414 **
    415 ** Function         nfa_dm_enable
    416 **
    417 ** Description      Initialises the NFC device manager
    418 **
    419 ** Returns          TRUE (message buffer to be freed by caller)
    420 **
    421 *******************************************************************************/
    422 BOOLEAN nfa_dm_enable (tNFA_DM_MSG *p_data)
    423 {
    424     tNFA_DM_CBACK_DATA dm_cback_data;
    425     NFA_TRACE_DEBUG0 ("nfa_dm_enable ()");
    426 
    427     /* Check if NFA is already enabled */
    428     if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_DM_IS_ACTIVE))
    429     {
    430         /* Initialize BRCM control block, it musb be called before setting any flags */
    431         nfa_dm_cb.flags |= (NFA_DM_FLAGS_DM_IS_ACTIVE | NFA_DM_FLAGS_ENABLE_EVT_PEND);
    432         nfa_sys_cback_reg_enable_complete (nfa_dm_module_init_cback);
    433 
    434 
    435         /* Store Enable parameters */
    436         nfa_dm_cb.p_dm_cback    = p_data->enable.p_dm_cback;
    437         nfa_dm_cb.p_conn_cback  = p_data->enable.p_conn_cback;
    438 
    439         /* Enable NFC stack */
    440         NFC_Enable (nfa_dm_nfc_response_cback);
    441     }
    442     else
    443     {
    444         NFA_TRACE_ERROR0 ("nfa_dm_enable: ERROR ALREADY ENABLED.");
    445         dm_cback_data.status = NFA_STATUS_ALREADY_STARTED;
    446         (*(p_data->enable.p_dm_cback)) (NFA_DM_ENABLE_EVT, &dm_cback_data);
    447     }
    448 
    449     return (TRUE);
    450 }
    451 
    452 /*******************************************************************************
    453 **
    454 ** Function         nfa_dm_disable
    455 **
    456 ** Description      Disables the NFC device manager
    457 **
    458 ** Returns          TRUE (message buffer to be freed by caller)
    459 **
    460 *******************************************************************************/
    461 BOOLEAN nfa_dm_disable (tNFA_DM_MSG *p_data)
    462 {
    463     tNFC_DEACT_TYPE deactivate_type = NFA_DEACTIVATE_TYPE_IDLE;
    464 
    465     NFA_TRACE_DEBUG1 ("nfa_dm_disable (): graceful:%d", p_data->disable.graceful);
    466 
    467     if (p_data->disable.graceful)
    468     {
    469         /* if RF discovery is enabled */
    470         if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED)
    471         {
    472             nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
    473 
    474             if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE)
    475             {
    476                 /* if waiting RSP in idle state */
    477                 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)
    478                 {
    479                     nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_DISABLING;
    480                 }
    481             }
    482             else
    483             {
    484                 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_DISABLING;
    485                 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type);
    486                 if ((nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF)) == 0)
    487                 {
    488                     /* not waiting to deactivate, clear the flag now */
    489                     nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING;
    490                 }
    491             }
    492         }
    493         /* Start timeout for graceful shutdown. If timer expires, then force an ungraceful shutdown */
    494         nfa_sys_start_timer (&nfa_dm_cb.tle, NFA_DM_TIMEOUT_DISABLE_EVT, NFA_DM_DISABLE_TIMEOUT_VAL);
    495     }
    496 
    497     /* Disable all subsystems other than DM (DM will be disabled after all  */
    498     /* the other subsystem have been disabled)                              */
    499     nfa_sys_disable_subsystems (p_data->disable.graceful);
    500     return (TRUE);
    501 }
    502 
    503 
    504 /*******************************************************************************
    505 **
    506 ** Function         nfa_dm_disable_complete
    507 **
    508 ** Description      Called when all NFA subsytems are disabled.
    509 **
    510 **                  NFC core stack can now be disabled.
    511 **
    512 ** Returns          void
    513 **
    514 *******************************************************************************/
    515 void nfa_dm_disable_complete (void)
    516 {
    517     NFA_TRACE_DEBUG0 ("nfa_dm_disable_complete ()");
    518 
    519     if ((nfa_dm_cb.flags & NFA_DM_FLAGS_DM_DISABLING_NFC) == 0)
    520     {
    521         NFA_TRACE_DEBUG0 ("nfa_dm_disable_complete (): proceeding with nfc core shutdown.");
    522 
    523         nfa_dm_cb.flags |= NFA_DM_FLAGS_DM_DISABLING_NFC;
    524 
    525         nfa_sys_stop_timer (&nfa_dm_cb.tle);
    526 
    527         /* Free all buffers for NDEF handlers */
    528         nfa_dm_ndef_dereg_all();
    529 
    530         /* Disable nfc core stack */
    531         NFC_Disable ();
    532     }
    533 }
    534 
    535 /*******************************************************************************
    536 **
    537 ** Function         nfa_dm_set_config
    538 **
    539 ** Description      Process set config command
    540 **
    541 ** Returns          TRUE (message buffer to be freed by caller)
    542 **
    543 *******************************************************************************/
    544 BOOLEAN nfa_dm_set_config (tNFA_DM_MSG *p_data)
    545 {
    546     tNFC_STATUS status;
    547     UINT8       buff[255];
    548     UINT8      *p = buff;
    549 
    550     tNFA_DM_CBACK_DATA dm_cback_data;
    551 
    552     if (p_data->setconfig.length + 2 > 255)
    553     {
    554         /* Total length of TLV must be less than 256 (1 byte) */
    555         status = NFC_STATUS_FAILED;
    556     }
    557     else
    558     {
    559         UINT8_TO_STREAM (p, p_data->setconfig.param_id);
    560         UINT8_TO_STREAM (p, p_data->setconfig.length);
    561         ARRAY_TO_STREAM (p, p_data->setconfig.p_data, p_data->setconfig.length)
    562         status = nfa_dm_check_set_config ((UINT8) (p_data->setconfig.length + 2), buff, TRUE);
    563     }
    564 
    565     if (status != NFC_STATUS_OK)
    566     {
    567         dm_cback_data.set_config.status = NFA_STATUS_INVALID_PARAM;
    568         (*nfa_dm_cb.p_dm_cback) (NFA_DM_SET_CONFIG_EVT, &dm_cback_data);
    569     }
    570 
    571     return (TRUE);
    572 }
    573 
    574 /*******************************************************************************
    575 **
    576 ** Function         nfa_dm_get_config
    577 **
    578 ** Description      Process get config command
    579 **
    580 ** Returns          TRUE (message buffer to be freed by caller)
    581 **
    582 *******************************************************************************/
    583 BOOLEAN nfa_dm_get_config (tNFA_DM_MSG *p_data)
    584 {
    585     NFC_GetConfig (p_data->getconfig.num_ids, p_data->getconfig.p_pmids);
    586 
    587     return (TRUE);
    588 }
    589 
    590 /*******************************************************************************
    591 **
    592 ** Function         nfa_dm_conn_cback_event_notify
    593 **
    594 ** Description      Notify application of CONN_CBACK event, using appropriate
    595 **                  callback
    596 **
    597 ** Returns          nothing
    598 **
    599 *******************************************************************************/
    600 void nfa_dm_conn_cback_event_notify (UINT8 event, tNFA_CONN_EVT_DATA *p_data)
    601 {
    602     if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)
    603     {
    604         /* Use exclusive RF mode callback */
    605         if (nfa_dm_cb.p_excl_conn_cback)
    606             (*nfa_dm_cb.p_excl_conn_cback) (event, p_data);
    607     }
    608     else
    609     {
    610         (*nfa_dm_cb.p_conn_cback) (event, p_data);
    611     }
    612 }
    613 
    614 /*******************************************************************************
    615 **
    616 ** Function         nfa_dm_rel_excl_rf_control_and_notify
    617 **
    618 ** Description      Stop exclusive RF control and notify app of
    619 **                  NFA_EXCLUSIVE_RF_CONTROL_STOPPED_EVT
    620 **
    621 ** Returns          void
    622 **
    623 *******************************************************************************/
    624 void nfa_dm_rel_excl_rf_control_and_notify (void)
    625 {
    626     tNFA_CONN_EVT_DATA conn_evt;
    627 
    628     NFA_TRACE_DEBUG0 ("nfa_dm_rel_excl_rf_control_and_notify ()");
    629 
    630     /* Exclusive RF control stopped. Notify app */
    631     nfa_dm_cb.flags &= ~NFA_DM_FLAGS_EXCL_RF_ACTIVE;
    632 
    633     /* Stop exclusive RF discovery for exclusive RF mode */
    634     nfa_dm_stop_excl_discovery ();
    635 
    636     /* Notify app that exclusive RF control has stopped */
    637     conn_evt.status = NFA_STATUS_OK;
    638     (*nfa_dm_cb.p_excl_conn_cback) (NFA_EXCLUSIVE_RF_CONTROL_STOPPED_EVT, &conn_evt);
    639     nfa_dm_cb.p_excl_conn_cback = NULL;
    640     nfa_dm_cb.p_excl_ndef_cback = NULL;
    641 }
    642 
    643 /*******************************************************************************
    644 **
    645 ** Function         nfa_dm_act_request_excl_rf_ctrl
    646 **
    647 ** Description      Request exclusive RF control
    648 **
    649 ** Returns          TRUE (message buffer to be freed by caller)
    650 **
    651 *******************************************************************************/
    652 BOOLEAN nfa_dm_act_request_excl_rf_ctrl (tNFA_DM_MSG *p_data)
    653 {
    654     tNFA_CONN_EVT_DATA conn_evt;
    655 
    656     NFA_TRACE_DEBUG0 ("nfa_dm_act_request_excl_rf_ctrl ()");
    657 
    658     if (!nfa_dm_cb.p_excl_conn_cback)
    659     {
    660         if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE)
    661         {
    662             conn_evt.status = NFA_STATUS_FAILED;
    663             (*p_data->req_excl_rf_ctrl.p_conn_cback) (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &conn_evt);
    664             return TRUE;
    665         }
    666 
    667         /* Store callbacks */
    668         nfa_dm_cb.p_excl_conn_cback = p_data->req_excl_rf_ctrl.p_conn_cback;
    669         nfa_dm_cb.p_excl_ndef_cback = p_data->req_excl_rf_ctrl.p_ndef_cback;
    670 
    671         nfa_dm_cb.flags |= NFA_DM_FLAGS_EXCL_RF_ACTIVE;
    672 
    673         /* start exclusive RF discovery */
    674         nfa_dm_start_excl_discovery (p_data->req_excl_rf_ctrl.poll_mask,
    675                                      &p_data->req_excl_rf_ctrl.listen_cfg,
    676                                      nfa_dm_excl_disc_cback);
    677     }
    678     else
    679     {
    680         NFA_TRACE_ERROR0 ("Exclusive rf control already requested");
    681 
    682         conn_evt.status = NFA_STATUS_FAILED;
    683         (*p_data->req_excl_rf_ctrl.p_conn_cback) (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &conn_evt);
    684     }
    685 
    686     return TRUE;
    687 }
    688 
    689 
    690 /*******************************************************************************
    691 **
    692 ** Function         nfa_dm_act_release_excl_rf_ctrl
    693 **
    694 ** Description      Release exclusive RF control
    695 **
    696 ** Returns          TRUE (message buffer to be freed by caller)
    697 **
    698 *******************************************************************************/
    699 BOOLEAN nfa_dm_act_release_excl_rf_ctrl (tNFA_DM_MSG *p_data)
    700 {
    701     NFA_TRACE_DEBUG0 ("nfa_dm_act_release_excl_rf_ctrl ()");
    702 
    703     /* nfa_dm_rel_excl_rf_control_and_notify() is called when discovery state goes IDLE */
    704     nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
    705 
    706     /* if discover command has been sent in IDLE state and waiting for response
    707     ** then just wait for responose. Otherwise initiate deactivating.
    708     */
    709     if (!(  (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE)
    710           &&(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)  ))
    711     {
    712         nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);
    713     }
    714 
    715     return TRUE;
    716 }
    717 
    718 /*******************************************************************************
    719 **
    720 ** Function         nfa_dm_act_deactivate
    721 **
    722 ** Description      Process deactivate command
    723 **
    724 ** Returns          TRUE (message buffer to be freed by caller)
    725 **
    726 *******************************************************************************/
    727 BOOLEAN nfa_dm_act_deactivate (tNFA_DM_MSG *p_data)
    728 {
    729     tNFA_CONN_EVT_DATA conn_evt;
    730     tNFA_DEACTIVATE_TYPE deact_type;
    731 
    732     NFA_TRACE_DEBUG0 ("nfa_dm_act_deactivate ()");
    733 
    734     if (  (p_data->deactivate.sleep_mode == FALSE)                 /* Always allow deactivate to IDLE */
    735         ||(  (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T1T)      /* Do not allow deactivate to SLEEP for T1T,NFCDEP, ISO15693 */
    736            &&(nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_NFC_DEP)
    737            &&(nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_ISO15693)  )  )
    738     {
    739         if (  (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP)
    740             &&((nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) == 0x00)  )
    741         {
    742             /* Exclusive RF control doesn't use NFA P2P */
    743             /* NFA P2P will deactivate NFC link after deactivating LLCP link */
    744             nfa_p2p_deactivate_llcp ();
    745             return (TRUE);
    746         }
    747         else
    748         {
    749             deact_type  = NFA_DEACTIVATE_TYPE_DISCOVERY;
    750             if (p_data->deactivate.sleep_mode)
    751             {
    752                 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT)
    753                 {
    754                     /* Deactivate to sleep mode not allowed in this state. */
    755                     deact_type = NFA_DEACTIVATE_TYPE_IDLE;
    756                 }
    757                 else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP)
    758                 {
    759                     deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
    760                 }
    761             }
    762             if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_ALL_DISCOVERIES)
    763             {
    764                 /* Only deactivate to IDLE is allowed in this state. */
    765                 deact_type = NFA_DEACTIVATE_TYPE_IDLE;
    766             }
    767             if (nfa_dm_rf_deactivate (deact_type) == NFA_STATUS_OK)
    768             {
    769                 nfa_rw_stop_presence_check_timer ();
    770                 return (TRUE);
    771             }
    772         }
    773     }
    774 
    775     NFA_TRACE_ERROR0 ("nfa_dm_act_deactivate (): invalid protocol or mode");
    776 
    777     /* Notify error to application */
    778     conn_evt.status = NFA_STATUS_FAILED;
    779     nfa_dm_conn_cback_event_notify (NFA_DEACTIVATE_FAIL_EVT, &conn_evt);
    780 
    781     return (TRUE);
    782 }
    783 
    784 /*******************************************************************************
    785 **
    786 ** Function         nfa_dm_act_power_off_sleep
    787 **
    788 ** Description      Process power off sleep mode request
    789 **
    790 ** Returns          TRUE (message buffer to be freed by caller)
    791 **
    792 *******************************************************************************/
    793 BOOLEAN nfa_dm_act_power_off_sleep (tNFA_DM_MSG *p_data)
    794 {
    795     NFA_TRACE_DEBUG0 ("nfa_dm_act_power_off_sleep ()");
    796 
    797     NFC_SetPowerOffSleep ((BOOLEAN) (p_data->hdr.layer_specific));
    798 
    799     return (TRUE);
    800 }
    801 
    802 /*******************************************************************************
    803 **
    804 ** Function         nfa_dm_act_reg_vsc
    805 **
    806 ** Description      Process registers VSC callback
    807 **
    808 ** Returns          TRUE (message buffer to be freed by caller)
    809 **
    810 *******************************************************************************/
    811 BOOLEAN nfa_dm_act_reg_vsc(tNFA_DM_MSG *p_data)
    812 {
    813     if (NFC_RegVSCback(p_data->reg_vsc.is_register, p_data->reg_vsc.p_cback) != NFC_STATUS_OK)
    814     {
    815         NFA_TRACE_ERROR0 ("NFC_RegVSCback failed");
    816     }
    817     return (TRUE);
    818 }
    819 
    820 /*******************************************************************************
    821 **
    822 ** Function         nfa_dm_act_send_vsc
    823 **
    824 ** Description      Send the NCI Vendor Specific command to the NCI command queue
    825 **
    826 ** Returns          FALSE (message buffer is NOT freed by caller)
    827 **
    828 *******************************************************************************/
    829 BOOLEAN nfa_dm_act_send_vsc(tNFA_DM_MSG *p_data)
    830 {
    831     BT_HDR  *p_cmd = (BT_HDR *)p_data;
    832 
    833     p_cmd->offset   = sizeof (tNFA_DM_API_SEND_VSC) - BT_HDR_SIZE;
    834     p_cmd->len      = p_data->send_vsc.cmd_params_len;
    835     NFC_SendVsCommand (p_data->send_vsc.oid, p_cmd, p_data->send_vsc.p_cback);
    836 
    837     /* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer carrying the message,
    838      * This action function re-use the GKI buffer to send the VSC, so the GKI buffer can not be freed by nfa-sys */
    839     return (FALSE);
    840 }
    841 
    842 /*******************************************************************************
    843 **
    844 ** Function         nfa_dm_start_polling
    845 **
    846 ** Description      Start polling
    847 **
    848 ** Returns          tNFA_STATUS
    849 **
    850 *******************************************************************************/
    851 tNFA_STATUS nfa_dm_start_polling (void)
    852 {
    853     tNFA_STATUS             status;
    854     tNFA_TECHNOLOGY_MASK    poll_tech_mask;
    855     tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0;
    856 
    857     NFA_TRACE_DEBUG0 ("nfa_dm_start_polling ()");
    858 
    859     poll_tech_mask = nfa_dm_cb.poll_mask;
    860 
    861     /* start RF discovery with discovery callback */
    862     if (nfa_dm_cb.poll_disc_handle == NFA_HANDLE_INVALID)
    863     {
    864         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A)
    865         {
    866             poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T;
    867             poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T;
    868             poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP;
    869             poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
    870             poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
    871         }
    872         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
    873         {
    874             poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
    875         }
    876         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B)
    877         {
    878             poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
    879         }
    880         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F)
    881         {
    882             poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
    883             poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
    884         }
    885         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
    886         {
    887             poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
    888         }
    889         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693)
    890         {
    891             poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693;
    892         }
    893         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME)
    894         {
    895             poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
    896         }
    897         if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO)
    898         {
    899             poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO;
    900         }
    901 
    902         nfa_dm_cb.poll_disc_handle = nfa_dm_add_rf_discover (poll_disc_mask,
    903                                                              NFA_DM_DISC_HOST_ID_DH,
    904                                                              nfa_dm_poll_disc_cback);
    905 
    906         if (nfa_dm_cb.poll_disc_handle != NFA_HANDLE_INVALID)
    907             status = NFA_STATUS_OK;
    908         else
    909             status = NFA_STATUS_FAILED;
    910     }
    911     else
    912     {
    913         status = NFA_STATUS_OK;
    914     }
    915 
    916     return (status);
    917 }
    918 
    919 /*******************************************************************************
    920 **
    921 ** Function         nfa_dm_act_enable_polling
    922 **
    923 ** Description      Process enable polling command
    924 **
    925 ** Returns          TRUE (message buffer to be freed by caller)
    926 **
    927 *******************************************************************************/
    928 BOOLEAN nfa_dm_act_enable_polling (tNFA_DM_MSG *p_data)
    929 {
    930     tNFA_CONN_EVT_DATA evt_data;
    931 
    932     NFA_TRACE_DEBUG0 ("nfa_dm_act_enable_polling ()");
    933 
    934     if (  (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED))
    935         &&(!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)  )  )
    936     {
    937         nfa_dm_cb.poll_mask = p_data->enable_poll.poll_mask;
    938 
    939         if (nfa_dm_start_polling () == NFA_STATUS_OK)
    940         {
    941             nfa_dm_cb.flags |= NFA_DM_FLAGS_POLLING_ENABLED;
    942 
    943             evt_data.status = NFA_STATUS_OK;
    944             nfa_dm_conn_cback_event_notify (NFA_POLL_ENABLED_EVT, &evt_data);
    945             return (TRUE);
    946         }
    947     }
    948     else
    949     {
    950         NFA_TRACE_ERROR0 ("nfa_dm_act_enable_polling (): already started");
    951     }
    952 
    953     /* send NFA_POLL_ENABLED_EVT with NFA_STATUS_FAILED */
    954     evt_data.status = NFA_STATUS_FAILED;
    955     nfa_dm_conn_cback_event_notify (NFA_POLL_ENABLED_EVT, &evt_data);
    956 
    957     return (TRUE);
    958 }
    959 
    960 /*******************************************************************************
    961 **
    962 ** Function         nfa_dm_deactivate_polling
    963 **
    964 ** Description      Deactivate any polling state
    965 **
    966 ** Returns          TRUE if need to wait for deactivation
    967 **
    968 *******************************************************************************/
    969 static BOOLEAN nfa_dm_deactivate_polling (void)
    970 {
    971     NFA_TRACE_DEBUG0 ("nfa_dm_deactivate_polling ()");
    972 
    973     if (  (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_ALL_DISCOVERIES)
    974         ||(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT)  )
    975     {
    976         nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);
    977         return FALSE;
    978     }
    979     else if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)
    980     {
    981         if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP)
    982         {
    983             /* NFA P2P will deactivate NFC link after deactivating LLCP link */
    984             nfa_p2p_deactivate_llcp ();
    985         }
    986         else
    987         {
    988             nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);
    989         }
    990         return TRUE;
    991     }
    992     else
    993     {
    994         return FALSE;
    995     }
    996 }
    997 
    998 /*******************************************************************************
    999 **
   1000 ** Function         nfa_dm_act_disable_polling
   1001 **
   1002 ** Description      Process disable polling command
   1003 **
   1004 ** Returns          TRUE (message buffer to be freed by caller)
   1005 **
   1006 *******************************************************************************/
   1007 BOOLEAN nfa_dm_act_disable_polling (tNFA_DM_MSG *p_data)
   1008 {
   1009     tNFA_CONN_EVT_DATA evt_data;
   1010 
   1011     NFA_TRACE_DEBUG0 ("nfa_dm_act_disable_polling ()");
   1012 
   1013     if (nfa_dm_cb.poll_disc_handle != NFA_HANDLE_INVALID)
   1014     {
   1015         nfa_dm_cb.flags &= ~NFA_DM_FLAGS_POLLING_ENABLED;
   1016 
   1017         if (nfa_dm_deactivate_polling () == FALSE)
   1018         {
   1019             nfa_dm_delete_rf_discover (nfa_dm_cb.poll_disc_handle);
   1020             nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID;
   1021 
   1022             evt_data.status = NFA_STATUS_OK;
   1023             nfa_dm_conn_cback_event_notify (NFA_POLL_DISABLED_EVT, &evt_data);
   1024         }
   1025         else
   1026         {
   1027             nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_POLL_STOP_EVT;
   1028         }
   1029     }
   1030     else
   1031     {
   1032         evt_data.status = NFA_STATUS_FAILED;
   1033         nfa_dm_conn_cback_event_notify (NFA_POLL_DISABLED_EVT, &evt_data);
   1034     }
   1035 
   1036     return (TRUE);
   1037 }
   1038 
   1039 /*******************************************************************************
   1040 **
   1041 ** Function         nfa_dm_act_send_raw_frame
   1042 **
   1043 ** Description      Send an raw frame on RF link
   1044 **
   1045 ** Returns          TRUE (message buffer to be freed by caller)
   1046 **
   1047 *******************************************************************************/
   1048 BOOLEAN nfa_dm_act_send_raw_frame (tNFA_DM_MSG *p_data)
   1049 {
   1050     tNFC_STATUS status = NFC_STATUS_FAILED;
   1051 
   1052     NFA_TRACE_DEBUG0 ("nfa_dm_act_send_raw_frame ()");
   1053 
   1054     /* If NFC link is activated */
   1055     if (  (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)
   1056         ||(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE)  )
   1057     {
   1058         /* If not in exclusive mode, and not activated for LISTEN, then forward raw data to NFA_RW to send */
   1059         if (  !(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)
   1060             &&!(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE)
   1061             &&(  (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T1T)
   1062                ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T2T)
   1063                ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T3T)
   1064                ||(  (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO_DEP)
   1065                   &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP)  )
   1066                ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693)  )  )
   1067         {
   1068             /* if RW is checking presence then it will put into pending queue */
   1069             status = nfa_rw_send_raw_frame ((BT_HDR*)p_data);
   1070         }
   1071         else
   1072         {
   1073             status = NFC_SendData (NFC_RF_CONN_ID, (BT_HDR*) p_data);
   1074             /* Already freed or NCI layer will free buffer */
   1075             return FALSE;
   1076         }
   1077     }
   1078 
   1079     if (status == NFC_STATUS_FAILED)
   1080     {
   1081         /* free the buffer */
   1082         return TRUE;
   1083     }
   1084     else
   1085     {
   1086         /* NCI layer will free buffer */
   1087         return FALSE;
   1088     }
   1089 }
   1090 
   1091 /*******************************************************************************
   1092 **
   1093 ** Function         nfa_dm_set_p2p_listen_tech
   1094 **
   1095 ** Description      Notify change of P2P listen technologies to NFA P2P
   1096 **
   1097 ** Returns          TRUE (message buffer to be freed by caller)
   1098 **
   1099 *******************************************************************************/
   1100 BOOLEAN nfa_dm_set_p2p_listen_tech (tNFA_DM_MSG *p_data)
   1101 {
   1102     NFA_TRACE_DEBUG1 ("nfa_dm_set_p2p_listen_tech ()  tech_mask = %d",
   1103                       p_data->set_p2p_listen_tech.tech_mask);
   1104 
   1105     nfa_p2p_update_listen_tech (p_data->set_p2p_listen_tech.tech_mask);
   1106     nfa_dm_conn_cback_event_notify (NFA_SET_P2P_LISTEN_TECH_EVT, NULL);
   1107 
   1108     return (TRUE);
   1109 }
   1110 
   1111 /*******************************************************************************
   1112 **
   1113 ** Function         nfa_dm_act_start_rf_discovery
   1114 **
   1115 ** Description      Process start RF discovery command
   1116 **
   1117 ** Returns          TRUE (message buffer to be freed by caller)
   1118 **
   1119 *******************************************************************************/
   1120 BOOLEAN nfa_dm_act_start_rf_discovery (tNFA_DM_MSG *p_data)
   1121 {
   1122     tNFA_CONN_EVT_DATA evt_data;
   1123 
   1124     NFA_TRACE_DEBUG0 ("nfa_dm_act_start_rf_discovery ()");
   1125 
   1126     if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED)
   1127     {
   1128         evt_data.status = NFA_STATUS_OK;
   1129         nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
   1130     }
   1131     else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE)
   1132     {
   1133         evt_data.status = NFA_STATUS_SEMANTIC_ERROR;
   1134         nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
   1135     }
   1136     else
   1137     {
   1138         nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_ENABLED|NFA_DM_DISC_FLAGS_NOTIFY);
   1139         nfa_dm_start_rf_discover ();
   1140     }
   1141 
   1142     return (TRUE);
   1143 }
   1144 
   1145 /*******************************************************************************
   1146 **
   1147 ** Function         nfa_dm_act_stop_rf_discovery
   1148 **
   1149 ** Description      Process stop RF discovery command
   1150 **
   1151 ** Returns          TRUE (message buffer to be freed by caller)
   1152 **
   1153 *******************************************************************************/
   1154 BOOLEAN nfa_dm_act_stop_rf_discovery (tNFA_DM_MSG *p_data)
   1155 {
   1156     tNFA_CONN_EVT_DATA evt_data;
   1157 
   1158     NFA_TRACE_DEBUG0 ("nfa_dm_act_stop_rf_discovery ()");
   1159 
   1160     if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) ||
   1161         (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) )
   1162     {
   1163         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
   1164 
   1165         /* if discover command has been sent in IDLE state and waiting for response */
   1166         if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)
   1167         {
   1168             nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
   1169         }
   1170         else
   1171         {
   1172             evt_data.status = NFA_STATUS_OK;
   1173             nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data);
   1174         }
   1175     }
   1176     else
   1177     {
   1178         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
   1179         nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
   1180         nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);
   1181     }
   1182     return (TRUE);
   1183 }
   1184 
   1185 /*******************************************************************************
   1186 **
   1187 ** Function         nfa_dm_act_set_rf_disc_duration
   1188 **
   1189 ** Description      Set duration for RF discovery
   1190 **
   1191 ** Returns          TRUE (message buffer to be freed by caller)
   1192 **
   1193 *******************************************************************************/
   1194 BOOLEAN nfa_dm_act_set_rf_disc_duration (tNFA_DM_MSG *p_data)
   1195 {
   1196     nfa_dm_cb.disc_cb.disc_duration = p_data->disc_duration.rf_disc_dur_ms;
   1197     return (TRUE);
   1198 }
   1199 
   1200 /*******************************************************************************
   1201 **
   1202 ** Function         nfa_dm_act_select
   1203 **
   1204 ** Description      Process RF select command
   1205 **
   1206 ** Returns          TRUE (message buffer to be freed by caller)
   1207 **
   1208 *******************************************************************************/
   1209 BOOLEAN nfa_dm_act_select (tNFA_DM_MSG *p_data)
   1210 {
   1211     NFA_TRACE_DEBUG0 ("nfa_dm_act_select ()");
   1212 
   1213     nfa_dm_rf_discover_select (p_data->select.rf_disc_id,
   1214                                p_data->select.protocol,
   1215                                p_data->select.rf_interface);
   1216     return (TRUE);
   1217 }
   1218 
   1219 /*******************************************************************************
   1220 **
   1221 ** Function         nfa_dm_act_update_rf_params
   1222 **
   1223 ** Description      Process update RF communication parameters command
   1224 **
   1225 ** Returns          TRUE (message buffer to be freed by caller)
   1226 **
   1227 *******************************************************************************/
   1228 BOOLEAN nfa_dm_act_update_rf_params (tNFA_DM_MSG *p_data)
   1229 {
   1230     tNFA_CONN_EVT_DATA conn_evt;
   1231 
   1232     NFA_TRACE_DEBUG0 ("nfa_dm_act_update_rf_params ()");
   1233 
   1234     if (NFC_UpdateRFCommParams (&p_data->update_rf_params.params) != NFC_STATUS_OK)
   1235     {
   1236         conn_evt.status = NFA_STATUS_FAILED;
   1237         nfa_dm_conn_cback_event_notify (NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt);
   1238     }
   1239 
   1240     return (TRUE);
   1241 }
   1242 
   1243 /*******************************************************************************
   1244 **
   1245 ** Function         nfa_dm_act_disable_timeout
   1246 **
   1247 ** Description      timeout on disable process. Shutdown immediately
   1248 **
   1249 ** Returns          TRUE (message buffer to be freed by caller)
   1250 **
   1251 *******************************************************************************/
   1252 BOOLEAN nfa_dm_act_disable_timeout (tNFA_DM_MSG *p_data)
   1253 {
   1254     tNFA_DM_API_DISABLE disable;
   1255 
   1256     disable.graceful = FALSE;
   1257     nfa_dm_disable ((tNFA_DM_MSG *) &disable);
   1258     return (TRUE);
   1259 }
   1260 
   1261 /*******************************************************************************
   1262 **
   1263 ** Function         nfa_dm_act_conn_cback_notify
   1264 **
   1265 ** Description      Notify app of reader/writer/ndef events
   1266 **
   1267 ** Returns          nothing
   1268 **
   1269 *******************************************************************************/
   1270 void nfa_dm_act_conn_cback_notify (UINT8 event, tNFA_CONN_EVT_DATA *p_data)
   1271 {
   1272     NFA_TRACE_DEBUG1 ("nfa_dm_act_conn_cback_notify (): event:0x%X", event);
   1273 
   1274     /* Notify event using appropriate CONN_CBACK */
   1275     nfa_dm_conn_cback_event_notify (event, p_data);
   1276 
   1277     /* If not in exclusive RF mode, then read NDEF message from tag (if automatic reading is enabled) */
   1278     if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE))
   1279     {
   1280         if (  (event == NFA_NDEF_DETECT_EVT)
   1281             &&(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)  )
   1282         {
   1283             /* read NDEF message from tag */
   1284             if (p_data->ndef_detect.status == NFA_STATUS_OK)
   1285             {
   1286                 NFA_RwReadNDef ();
   1287             }
   1288             else if (p_data->ndef_detect.status == NFA_STATUS_FAILED)
   1289             {
   1290                 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF;
   1291             }
   1292             /* ignore NFA_STATUS_BUSY */
   1293         }
   1294         else if (  (event == NFA_READ_CPLT_EVT)
   1295                  &&(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF))
   1296         {
   1297             /* reading NDEF message is done */
   1298             nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF;
   1299         }
   1300     }
   1301 }
   1302 
   1303 /*******************************************************************************
   1304 **
   1305 ** Function         nfa_dm_act_data_cback
   1306 **
   1307 ** Description      Processing data from RF link
   1308 **
   1309 ** Returns          None
   1310 **
   1311 *******************************************************************************/
   1312 static void nfa_dm_act_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data)
   1313 {
   1314     BT_HDR             *p_msg = (BT_HDR *) p_data->data.p_data;
   1315     tNFA_CONN_EVT_DATA evt_data;
   1316 
   1317     NFA_TRACE_DEBUG1 ("nfa_dm_act_data_cback (): event = 0x%X", event);
   1318 
   1319     if (event == NFC_DATA_CEVT)
   1320     {
   1321         if (p_msg)
   1322         {
   1323             evt_data.data.p_data = (UINT8 *) (p_msg + 1) + p_msg->offset;
   1324             evt_data.data.len    = p_msg->len;
   1325 
   1326             nfa_dm_conn_cback_event_notify (NFA_DATA_EVT, &evt_data);
   1327 
   1328             GKI_freebuf (p_msg);
   1329         }
   1330         else
   1331         {
   1332             NFA_TRACE_ERROR0 ("nfa_dm_act_data_cback (): received NFC_DATA_CEVT with NULL data pointer");
   1333         }
   1334     }
   1335     else if (event == NFC_DEACTIVATE_CEVT)
   1336     {
   1337         NFC_SetStaticRfCback (NULL);
   1338     }
   1339 }
   1340 
   1341 /*******************************************************************************
   1342 **
   1343 ** Function         nfa_dm_excl_disc_cback
   1344 **
   1345 ** Description      Processing event from discovery callback
   1346 **
   1347 ** Returns          None
   1348 **
   1349 *******************************************************************************/
   1350 static void nfa_dm_excl_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data)
   1351 {
   1352     tNFA_CONN_EVT_DATA evt_data;
   1353 
   1354     NFA_TRACE_DEBUG1 ("nfa_dm_excl_disc_cback (): event:0x%02X", event);
   1355 
   1356     switch (event)
   1357     {
   1358     case NFA_DM_RF_DISC_START_EVT:
   1359         evt_data.status = NFA_STATUS_OK;
   1360         nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data);
   1361         break;
   1362 
   1363     case NFA_DM_RF_DISC_ACTIVATED_EVT:
   1364         if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A)
   1365         {
   1366             /* store SEL_RES response */
   1367             nfa_dm_cb.disc_cb.activated_sel_res = p_data->activate.rf_tech_param.param.pa.sel_rsp;
   1368         }
   1369 
   1370         if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE)
   1371         {
   1372             /* Set data callback to receive raw frame */
   1373             NFC_SetStaticRfCback (nfa_dm_act_data_cback);
   1374 
   1375             memset (&(evt_data.activated.params), 0x00, sizeof (tNFA_TAG_PARAMS));
   1376             memcpy (&(evt_data.activated.activate_ntf), &(p_data->activate), sizeof (tNFC_ACTIVATE_DEVT));
   1377 
   1378             nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data);
   1379         }
   1380         else
   1381         {
   1382             /* holding activation notification until sub-module is ready */
   1383             nfa_dm_cb.p_activate_ntf = (UINT8*) GKI_getbuf (sizeof (tNFC_ACTIVATE_DEVT));
   1384 
   1385             if (nfa_dm_cb.p_activate_ntf)
   1386             {
   1387                 memcpy (nfa_dm_cb.p_activate_ntf,
   1388                         &(p_data->activate),
   1389                         sizeof (tNFC_ACTIVATE_DEVT));
   1390 
   1391                 if (  (nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T1T)
   1392                     ||(nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T2T)
   1393                     ||(nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T3T)
   1394                     ||(  (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP)
   1395                        &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP) )
   1396                     ||(nfa_dm_cb.disc_cb.activated_protocol  == NFA_PROTOCOL_ISO15693) )
   1397                 {
   1398                     /* Notify NFA tag sub-system */
   1399                     nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, FALSE);
   1400                 }
   1401                 else /* if NFC-DEP, ISO-DEP with frame interface or others */
   1402                 {
   1403                     /* Set data callback to receive raw frame */
   1404                     NFC_SetStaticRfCback (nfa_dm_act_data_cback);
   1405                     nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL);
   1406                 }
   1407             }
   1408             else
   1409             {
   1410                 /* deactivate and restart RF discovery */
   1411                 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY);
   1412             }
   1413         }
   1414         break;
   1415 
   1416     case NFA_DM_RF_DISC_DEACTIVATED_EVT:
   1417 
   1418         /* clear stored NFCID/UID */
   1419         nfa_dm_cb.activated_nfcid_len = 0;
   1420 
   1421         if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP)
   1422         {
   1423             /* Notify NFA RW sub-systems */
   1424             nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, FALSE);
   1425         }
   1426 
   1427         /* if deactivated as sleep mode */
   1428         if (  (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP)
   1429             ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)  )
   1430         {
   1431             evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
   1432         }
   1433         else
   1434         {
   1435             evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
   1436         }
   1437 
   1438         /* notify deactivation to upper layer */
   1439         nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
   1440 
   1441         /* clean up SEL_RES response */
   1442         nfa_dm_cb.disc_cb.activated_sel_res = 0;
   1443         break;
   1444 
   1445     default:
   1446         NFA_TRACE_ERROR0 ("Unexpected event");
   1447         break;
   1448     }
   1449 }
   1450 
   1451 /*******************************************************************************
   1452 **
   1453 ** Function         nfa_dm_poll_disc_cback
   1454 **
   1455 ** Description      Processing event from discovery callback
   1456 **
   1457 ** Returns          None
   1458 **
   1459 *******************************************************************************/
   1460 static void nfa_dm_poll_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data)
   1461 {
   1462     tNFA_CONN_EVT_DATA evt_data;
   1463 
   1464     NFA_TRACE_DEBUG1 ("nfa_dm_poll_disc_cback (): event:0x%02X", event);
   1465 
   1466     switch (event)
   1467     {
   1468     case NFA_DM_RF_DISC_START_EVT:
   1469         break;
   1470 
   1471     case NFA_DM_RF_DISC_ACTIVATED_EVT:
   1472 
   1473         if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A)
   1474         {
   1475             /* store SEL_RES response */
   1476             nfa_dm_cb.disc_cb.activated_sel_res = p_data->activate.rf_tech_param.param.pa.sel_rsp;
   1477         }
   1478 
   1479         /* holding activation notification until sub-module is ready */
   1480         nfa_dm_cb.p_activate_ntf = (UINT8*) GKI_getbuf (sizeof (tNFC_ACTIVATE_DEVT));
   1481 
   1482         if (nfa_dm_cb.p_activate_ntf)
   1483         {
   1484             memcpy (nfa_dm_cb.p_activate_ntf,
   1485                     &(p_data->activate),
   1486                     sizeof (tNFC_ACTIVATE_DEVT));
   1487 
   1488             if (  (nfa_dm_cb.disc_cb.activated_protocol     == NFC_PROTOCOL_NFC_DEP)
   1489                 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP)  )
   1490             {
   1491                 /* activate LLCP */
   1492                 nfa_p2p_activate_llcp (p_data);
   1493             }
   1494             else if (  (nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T1T)
   1495                      ||(nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T2T)
   1496                      ||(nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T3T)
   1497                      ||(  (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP)
   1498                         &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP)  )
   1499                      ||(nfa_dm_cb.disc_cb.activated_protocol  == NFA_PROTOCOL_ISO15693)  )
   1500             {
   1501                 /* Notify NFA tag sub-system */
   1502                 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, TRUE);
   1503             }
   1504             else /* if NFC-DEP/ISO-DEP with frame interface */
   1505             {
   1506                 /* Set data callback to receive raw frame */
   1507                 NFC_SetStaticRfCback (nfa_dm_act_data_cback);
   1508                 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL);
   1509             }
   1510         }
   1511         else
   1512         {
   1513             /* deactivate and restart RF discovery */
   1514             nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY);
   1515         }
   1516         break;
   1517 
   1518     case NFA_DM_RF_DISC_DEACTIVATED_EVT:
   1519 
   1520         /* clear stored NFCID/UID */
   1521         nfa_dm_cb.activated_nfcid_len = 0;
   1522 
   1523         if (  (nfa_dm_cb.disc_cb.activated_protocol     == NFC_PROTOCOL_NFC_DEP)
   1524             &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP)  )
   1525         {
   1526             /*
   1527             ** If LLCP link is not deactivated yet,
   1528             ** LLCP will receive deactivation ntf through data callback.
   1529             ** NFA P2P will receive callback event from LLCP.
   1530             */
   1531         }
   1532         else
   1533         {
   1534             /* Notify NFA RW sub-systems */
   1535             nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, TRUE);
   1536         }
   1537 
   1538         /* if NFA sent NFA_ACTIVATED_EVT earlier */
   1539         if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_DEACTIVATED_EVT)
   1540         {
   1541             nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_DEACTIVATED_EVT;
   1542 
   1543             /* if deactivated as sleep mode */
   1544             if (  (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP)
   1545                 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)  )
   1546             {
   1547                 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
   1548             }
   1549             else
   1550             {
   1551                 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
   1552             }
   1553             /* notify deactivation to application */
   1554             nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
   1555         }
   1556 
   1557         /* clean up SEL_RES response */
   1558         nfa_dm_cb.disc_cb.activated_sel_res = 0;
   1559 
   1560         if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED))
   1561         {
   1562             /* deregister discovery callback from NFA DM Discovery */
   1563             nfa_dm_delete_rf_discover (nfa_dm_cb.poll_disc_handle);
   1564             nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID;
   1565 
   1566             /* this is for disable polling */
   1567             if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_POLL_STOP_EVT)
   1568             {
   1569                 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_POLL_STOP_EVT;
   1570 
   1571                 evt_data.status = NFA_STATUS_OK;
   1572                 nfa_dm_conn_cback_event_notify (NFA_POLL_DISABLED_EVT, &evt_data);
   1573             }
   1574         }
   1575         break;
   1576     }
   1577 }
   1578 
   1579 /*******************************************************************************
   1580 **
   1581 ** Function         nfa_dm_notify_activation_status
   1582 **
   1583 ** Description      Processing activation status from sub-modules
   1584 **
   1585 ** Returns          None
   1586 **
   1587 *******************************************************************************/
   1588 void nfa_dm_notify_activation_status (tNFA_STATUS status, tNFA_TAG_PARAMS *p_params)
   1589 {
   1590     tNFA_CONN_EVT_DATA  evt_data;
   1591     tNFC_RF_TECH_PARAMS *p_tech_params;
   1592     UINT8               *p_nfcid = NULL, nfcid_len;
   1593 
   1594     NFA_TRACE_DEBUG1 ("nfa_dm_notify_activation_status (): status:0x%X", status);
   1595 
   1596     if (!nfa_dm_cb.p_activate_ntf)
   1597     {
   1598         /* this is for NFA P2P listen */
   1599         return;
   1600     }
   1601 
   1602     if (status == NFA_STATUS_OK)
   1603     {
   1604         /* notify NFC link activation */
   1605         memcpy ( &(evt_data.activated.activate_ntf),
   1606                  nfa_dm_cb.p_activate_ntf,
   1607                  sizeof (tNFC_ACTIVATE_DEVT));
   1608 
   1609         p_tech_params = &evt_data.activated.activate_ntf.rf_tech_param;
   1610 
   1611         if (p_params)
   1612         {
   1613             memcpy (&(evt_data.activated.params),
   1614                     p_params,
   1615                     sizeof (tNFA_TAG_PARAMS));
   1616         }
   1617 
   1618         /* get length of NFCID and location */
   1619         if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_A)
   1620         {
   1621             nfcid_len = p_tech_params->param.pa.nfcid1_len;
   1622             p_nfcid   = p_tech_params->param.pa.nfcid1;
   1623         }
   1624         else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_B)
   1625         {
   1626             nfcid_len = NFC_NFCID0_MAX_LEN;
   1627             p_nfcid   = p_tech_params->param.pb.nfcid0;
   1628         }
   1629         else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F)
   1630         {
   1631             nfcid_len = NFC_NFCID2_LEN;
   1632             p_nfcid   = p_tech_params->param.pf.nfcid2;
   1633         }
   1634         else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_ISO15693)
   1635         {
   1636             nfcid_len = NFC_ISO15693_UID_LEN;
   1637             p_nfcid   = p_tech_params->param.pi93.uid;
   1638         }
   1639         else
   1640         {
   1641             nfcid_len = 0;
   1642         }
   1643 
   1644         /*
   1645         ** If not in exlusive RF mode, and
   1646         **      P2P activation, then push default NDEF message through SNEP
   1647         **      TAG activation, then read NDEF message
   1648         */
   1649         if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP)
   1650         {
   1651             /*
   1652             ** Default NDEF message will be put to NFC Forum defualt SNEP server
   1653             ** after receiving NFA_LLCP_ACTIVATED_EVT.
   1654             */
   1655         }
   1656         /* Do not perform NDEF operations on KOVIO */
   1657         else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO)
   1658         {
   1659             NFA_TRACE_DEBUG1 ("Not an NFC-Forum tag, bypassing NDEF detection", nfa_dm_cb.disc_cb.activated_protocol);
   1660         }
   1661         else if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE))
   1662         {
   1663             /*
   1664             ** if the same tag is activated then do not perform auto NDEF detection.
   1665             ** Application may put a tag into sleep mode and reactivate the same tag.
   1666             */
   1667 
   1668             if (  (p_tech_params->mode != nfa_dm_cb.disc_cb.activated_tech_mode)
   1669                 ||(nfcid_len != nfa_dm_cb.activated_nfcid_len)
   1670                 ||(memcmp (p_nfcid, nfa_dm_cb.activated_nfcid, nfcid_len)))
   1671             {
   1672                 if (  (nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T1T)
   1673                     ||(nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T2T)
   1674                     ||(nfa_dm_cb.disc_cb.activated_protocol  == NFC_PROTOCOL_T3T)
   1675                     ||(  (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP)
   1676                        &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP)  )
   1677                     ||(nfa_dm_cb.disc_cb.activated_protocol  == NFA_PROTOCOL_ISO15693)  )
   1678                 {
   1679                     if (p_nfa_dm_cfg->auto_detect_ndef)
   1680                     {
   1681                         if (p_nfa_dm_cfg->auto_read_ndef)
   1682                         {
   1683                             nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF;
   1684                         }
   1685                         NFA_RwDetectNDef ();
   1686                     }
   1687                     else if (p_nfa_dm_cfg->auto_read_ndef)
   1688                     {
   1689                         NFA_RwReadNDef ();
   1690                     }
   1691                 }
   1692             }
   1693         }
   1694 
   1695         /* store activated tag information */
   1696         nfa_dm_cb.activated_nfcid_len = nfcid_len;
   1697         if (nfcid_len)
   1698             memcpy (nfa_dm_cb.activated_nfcid, p_nfcid, nfcid_len);
   1699 
   1700         nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_DEACTIVATED_EVT;
   1701         nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data);
   1702     }
   1703     else
   1704     {
   1705         /* if NFC_DEP, NFA P2P will deactivate */
   1706         if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP)
   1707         {
   1708             nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY);
   1709         }
   1710     }
   1711 
   1712     GKI_freebuf (nfa_dm_cb.p_activate_ntf);
   1713     nfa_dm_cb.p_activate_ntf = NULL;
   1714 }
   1715 
   1716 #if (BT_TRACE_VERBOSE == TRUE)
   1717 /*******************************************************************************
   1718 **
   1719 ** Function         nfa_dm_nfc_revt_2_str
   1720 **
   1721 ** Description      convert nfc revt to string
   1722 **
   1723 *******************************************************************************/
   1724 char *nfa_dm_nfc_revt_2_str (tNFC_RESPONSE_EVT event)
   1725 {
   1726     switch (event) {
   1727     case NFC_ENABLE_REVT:
   1728         return "NFC_ENABLE_REVT";
   1729 
   1730     case NFC_DISABLE_REVT:
   1731         return "NFC_DISABLE_REVT";
   1732 
   1733     case NFC_SET_CONFIG_REVT:
   1734         return "NFC_SET_CONFIG_REVT";
   1735 
   1736     case NFC_GET_CONFIG_REVT:
   1737         return "NFC_GET_CONFIG_REVT";
   1738 
   1739     case NFC_NFCEE_DISCOVER_REVT:
   1740         return "NFC_NFCEE_DISCOVER_REVT";
   1741 
   1742     case NFC_NFCEE_INFO_REVT:
   1743         return "NFC_NFCEE_INFO_REVT";
   1744 
   1745     case NFC_NFCEE_MODE_SET_REVT:
   1746         return "NFC_NFCEE_MODE_SET_REVT";
   1747 
   1748     case NFC_RF_FIELD_REVT:
   1749         return "NFC_RF_FIELD_REVT";
   1750 
   1751     case NFC_EE_ACTION_REVT:
   1752         return "NFC_EE_ACTION_REVT";
   1753 
   1754     case NFC_EE_DISCOVER_REQ_REVT:
   1755         return "NFC_EE_DISCOVER_REQ_REVT";
   1756 
   1757     case NFC_SET_ROUTING_REVT:
   1758         return "NFC_SET_ROUTING_REVT";
   1759 
   1760     case NFC_GET_ROUTING_REVT:
   1761         return "NFC_GET_ROUTING_REVT";
   1762 
   1763     case NFC_GEN_ERROR_REVT:
   1764         return "NFC_GEN_ERROR_REVT";
   1765 
   1766     case NFC_NFCC_RESTART_REVT:
   1767         return "NFC_NFCC_RESTART_REVT";
   1768 
   1769     case NFC_NFCC_TIMEOUT_REVT:
   1770         return "NFC_NFCC_TIMEOUT_REVT";
   1771 
   1772     case NFC_NFCC_TRANSPORT_ERR_REVT:
   1773         return "NFC_NFCC_TRANSPORT_ERR_REVT";
   1774 
   1775     case NFC_NFCC_POWER_OFF_REVT:
   1776         return "NFC_NFCC_POWER_OFF_REVT";
   1777 
   1778     default:
   1779         return "unknown revt";
   1780         break;
   1781     }
   1782 }
   1783 #endif /* BT_VERBOSE */
   1784