xref: /system/nfc/halimpl/bcm2079x/hal/hal/nfc_hal_main.c

/******************************************************************************
 *
 *  Copyright (C) 2010-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.
 *
 ******************************************************************************/

/******************************************************************************
 *
 *  Functions for handling NFC HAL NCI Transport events
 *
 ******************************************************************************/
#include <string.h>
#include "nfc_hal_int.h"
#include "nfc_hal_post_reset.h"
#include "upio.h"
#include "userial.h"

/****************************************************************************
** Definitions
****************************************************************************/

/* Default NFC HAL NCI port configuration  */
NFC_HAL_TRANS_CFG_QUALIFIER tNFC_HAL_TRANS_CFG nfc_hal_trans_cfg = {
    NFC_HAL_SHARED_TRANSPORT_ENABLED, /* bSharedTransport */
    USERIAL_BAUD_115200,              /* Baud rate */
    USERIAL_FC_HW                     /* Flow control */
};

/* Control block for NFC HAL NCI transport */
tNFC_HAL_CB nfc_hal_cb;

extern tNFC_HAL_CFG* p_nfc_hal_cfg;
/****************************************************************************
** Internal function prototypes
****************************************************************************/
static void nfc_hal_main_userial_cback(tUSERIAL_PORT port, tUSERIAL_EVT evt,
                                       tUSERIAL_EVT_DATA* p_data);
static void nfc_hal_main_handle_terminate(void);
static void nfc_hal_main_timeout_cback(void* p_tle);

#if (NFC_HAL_DEBUG == TRUE)
const char* const nfc_hal_init_state_str[] = {
    "IDLE",           /* Initialization is done                */
    "W4_XTAL_SET",    /* Waiting for crystal setting rsp       */
    "POST_XTAL_SET",  /* Waiting for reset ntf after xtal set  */
    "W4_NFCC_ENABLE", /* Waiting for reset ntf atter REG_PU up */
    "W4_BUILD_INFO",  /* Waiting for build info rsp            */
    "W4_PATCH_INFO",  /* Waiting for patch info rsp            */
    "W4_APP_COMPL",   /* Waiting for complete from application */
    "W4_POST_INIT",   /* Waiting for complete of post init     */
    "W4_CONTROL",     /* Waiting for control release           */
    "W4_PREDISC",     /* Waiting for complete of prediscover   */
    "CLOSING"         /* Shutting down                         */
};
#endif

/*******************************************************************************
**
** Function         nfc_hal_main_init
**
** Description      This function initializes control block for NFC HAL
**
** Returns          nothing
**
*******************************************************************************/
void nfc_hal_main_init(void) {
  /* Clear control block */
  memset(&nfc_hal_cb, 0, sizeof(tNFC_HAL_CB));

  nfc_hal_cb.ncit_cb.nci_ctrl_size = NFC_HAL_NCI_INIT_CTRL_PAYLOAD_SIZE;
  nfc_hal_cb.trace_level = NFC_HAL_INITIAL_TRACE_LEVEL;
  nfc_hal_cb.timer.p_cback = nfc_hal_main_timeout_cback;
}

/*******************************************************************************
**
** Function         nfc_hal_main_open_transport
**
** Description      Open transport and prepare for new incoming message;
**
** Returns          nothing
**
*******************************************************************************/
static void nfc_hal_main_open_transport(void) {
  tUSERIAL_OPEN_CFG open_cfg;

  /* Initialize control block */
  nfc_hal_cb.ncit_cb.rcv_state =
      NFC_HAL_RCV_IDLE_ST; /* to process packet type */

  if (nfc_hal_cb.ncit_cb.p_rcv_msg) {
    GKI_freebuf(nfc_hal_cb.ncit_cb.p_rcv_msg);
    nfc_hal_cb.ncit_cb.p_rcv_msg = NULL;
  }

  /* open transport */
  open_cfg.fmt =
      (USERIAL_DATABITS_8 | USERIAL_PARITY_NONE | USERIAL_STOPBITS_1);
  open_cfg.baud = nfc_hal_trans_cfg.userial_baud;
  open_cfg.fc = nfc_hal_trans_cfg.userial_fc;
  open_cfg.buf = USERIAL_BUF_BYTE;

  USERIAL_Open(USERIAL_NFC_PORT, &open_cfg, nfc_hal_main_userial_cback);

  {
    /* Wait for NFCC to enable - Core reset notification */
    NFC_HAL_SET_INIT_STATE(NFC_HAL_INIT_STATE_W4_NFCC_ENABLE);

    /* NFCC Enable timeout */
    nfc_hal_main_start_quick_timer(
        &nfc_hal_cb.timer, NFC_HAL_TTYPE_NFCC_ENABLE,
        ((p_nfc_hal_cfg->nfc_hal_nfcc_enable_timeout) *
         QUICK_TIMER_TICKS_PER_SEC) /
            1000);
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_close
**
** Description      Check and shutdown NFCC
**
** Returns          None
**
*******************************************************************************/
void nfc_hal_main_close(void) {
  tHAL_NFC_CBACK* p_stack_cback_temp;

  if ((nfc_hal_cb.dev_cb.initializing_state !=
       NFC_HAL_INIT_STATE_W4_NFCC_TURN_OFF) &&
      (nfc_hal_cb.hal_flags & NFC_HAL_FLAGS_NEED_DISABLE_VSC)) {
    nfc_hal_cb.dev_cb.initializing_state = NFC_HAL_INIT_STATE_W4_NFCC_TURN_OFF;
    nfc_hal_dm_set_power_level_zero();
  } else {
    nfc_hal_main_handle_terminate();

    /* Close uart */
    USERIAL_Close(USERIAL_NFC_PORT);

    if (nfc_hal_cb.p_stack_cback) {
      p_stack_cback_temp = nfc_hal_cb.p_stack_cback;
      nfc_hal_cb.p_stack_cback = NULL;
      p_stack_cback_temp(HAL_NFC_CLOSE_CPLT_EVT, HAL_NFC_STATUS_OK);
    }
  }
}

/*******************************************************************************
**
** Function         nfa_hal_pre_discover_done_cback
**
** Description      Pre-discovery CFG is sent.
**
** Returns          nothing
**
*******************************************************************************/
void nfa_hal_pre_discover_done_cback(tNFC_HAL_NCI_EVT event, uint16_t data_len,
                                     uint8_t* p_data) {
  NFC_HAL_SET_INIT_STATE(NFC_HAL_INIT_STATE_IDLE);
  nfc_hal_main_stop_quick_timer(&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer);
  nfc_hal_cb.p_stack_cback(HAL_NFC_PRE_DISCOVER_CPLT_EVT, HAL_NFC_STATUS_OK);
}

/*******************************************************************************
**
** Function         nfa_hal_send_pre_discover_cfg
**
** Description      sending Pre-discovery CFG
**
** Returns          nothing
**
*******************************************************************************/
void nfa_hal_send_pre_discover_cfg(void) {
  if (nfc_hal_dm_set_config(
          p_nfc_hal_pre_discover_cfg[0], &p_nfc_hal_pre_discover_cfg[1],
          nfa_hal_pre_discover_done_cback) != HAL_NFC_STATUS_OK) {
    nfa_hal_pre_discover_done_cback(0, 0, NULL);
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_send_error
**
** Description      send an Error event to NFC stack
**
** Returns          nothing
**
*******************************************************************************/
void nfc_hal_main_send_error(tHAL_NFC_STATUS status) {
  /* Notify stack */
  nfc_hal_cb.p_stack_cback(HAL_NFC_ERROR_EVT, status);
}

/*******************************************************************************
**
** Function         nfc_hal_main_userial_cback
**
** Description      USERIAL callback for NCI transport
**
** Returns          nothing
**
*******************************************************************************/
static void nfc_hal_main_userial_cback(tUSERIAL_PORT port, tUSERIAL_EVT evt,
                                       tUSERIAL_EVT_DATA* p_data) {
  if (evt == USERIAL_RX_READY_EVT) {
    /* Notify transport task of serial port event */
    GKI_send_event(NFC_HAL_TASK, NFC_HAL_TASK_EVT_DATA_RDY);
  } else if (evt == USERIAL_TX_DONE_EVT) {
    /* Serial driver has finshed sending data from USERIAL_Write */
    /* Currently, no action is needed for this event */
  } else if (evt == USERIAL_ERR_EVT) {
    HAL_TRACE_ERROR0(
        "nfc_hal_main_userial_cback: USERIAL_ERR_EVT. Notifying NFC_TASK of "
        "transport error");
    if (nfc_hal_cb.ncit_cb.nci_wait_rsp != NFC_HAL_WAIT_RSP_NONE) {
      nfc_hal_main_stop_quick_timer(&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer);
      nfc_hal_nci_cmd_timeout_cback(
          (void*)&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer);
    } else {
      nfc_hal_main_send_error(HAL_NFC_STATUS_ERR_TRANSPORT);
    }
  } else if (evt == USERIAL_WAKEUP_EVT) {
    HAL_TRACE_DEBUG1("nfc_hal_main_userial_cback: USERIAL_WAKEUP_EVT: %d",
                     p_data->sigs);
  } else {
    HAL_TRACE_DEBUG1("nfc_hal_main_userial_cback: unhandled userial evt: %i",
                     evt);
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_exit_op_done
**
** Description      handle completion of HAL exit operation
**
** Returns          nothing
**
*******************************************************************************/
void nfc_hal_main_exit_op_done(tNFC_HAL_NCI_EVT event, uint16_t data_len,
                               uint8_t* p_data) {
  nfc_hal_main_close();
}

/*******************************************************************************
**
** Function         nfc_hal_main_pre_init_done
**
** Description      notify complete of pre-initialization
**
** Returns          nothing
**
*******************************************************************************/
void nfc_hal_main_pre_init_done(tHAL_NFC_STATUS status) {
  HAL_TRACE_DEBUG1("nfc_hal_main_pre_init_done () status = %d", status);

  if (status != HAL_NFC_STATUS_OK) {
    nfc_hal_main_handle_terminate();

    /* Close uart */
    USERIAL_Close(USERIAL_NFC_PORT);
  }

  /* Notify NFC Task the status of initialization */
  nfc_hal_cb.p_stack_cback(HAL_NFC_OPEN_CPLT_EVT, status);
}

/*******************************************************************************
**
** Function         nfc_hal_main_timeout_cback
**
** Description      callback function for timeout
**
** Returns          void
**
*******************************************************************************/
static void nfc_hal_main_timeout_cback(void* p_tle) {
  TIMER_LIST_ENT* p_tlent = (TIMER_LIST_ENT*)p_tle;

  HAL_TRACE_DEBUG0("nfc_hal_main_timeout_cback ()");

  switch (p_tlent->event) {
    case NFC_HAL_TTYPE_POWER_CYCLE:
      nfc_hal_main_open_transport();
      break;

    case NFC_HAL_TTYPE_NFCC_ENABLE:
      /* NFCC should have enabled now, notify transport openned */
      nfc_hal_dm_pre_init_nfcc();
      break;

    default:
      HAL_TRACE_DEBUG1(
          "nfc_hal_main_timeout_cback: unhandled timer event (0x%04x)",
          p_tlent->event);
      break;
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_handle_terminate
**
** Description      Handle NFI transport shutdown
**
** Returns          nothing
**
*******************************************************************************/
static void nfc_hal_main_handle_terminate(void) {
  NFC_HDR* p_msg;

  /* dequeue and free buffer */
  if (nfc_hal_cb.ncit_cb.p_pend_cmd != NULL) {
    GKI_freebuf(nfc_hal_cb.ncit_cb.p_pend_cmd);
    nfc_hal_cb.ncit_cb.p_pend_cmd = NULL;
  }

  /* Free unsent nfc rx buffer */
  if (nfc_hal_cb.ncit_cb.p_rcv_msg) {
    GKI_freebuf(nfc_hal_cb.ncit_cb.p_rcv_msg);
    nfc_hal_cb.ncit_cb.p_rcv_msg = NULL;
  }

  /* Free buffer for pending fragmented response/notification */
  if (nfc_hal_cb.ncit_cb.p_frag_msg) {
    GKI_freebuf(nfc_hal_cb.ncit_cb.p_frag_msg);
    nfc_hal_cb.ncit_cb.p_frag_msg = NULL;
  }

  /* Free buffers in the tx mbox */
  while ((p_msg = (NFC_HDR*)GKI_read_mbox(NFC_HAL_TASK_MBOX)) != NULL) {
    GKI_freebuf(p_msg);
  }

  /* notify closing transport */
  nfc_hal_dm_shutting_down_nfcc();
}

/*******************************************************************************
**
** Function         nfc_hal_main_start_quick_timer
**
** Description      Start a timer for the specified amount of time.
**                  NOTE: The timeout resolution depends on including modules.
**                  QUICK_TIMER_TICKS_PER_SEC should be used to convert from
**                  time to ticks.
**
**
** Returns          void
**
*******************************************************************************/
void nfc_hal_main_start_quick_timer(TIMER_LIST_ENT* p_tle, uint16_t type,
                                    uint32_t timeout) {
  NFC_HDR* p_msg;

  /* if timer list is currently empty, start periodic GKI timer */
  if (nfc_hal_cb.quick_timer_queue.p_first == NULL) {
    /* if timer starts on other than NCIT task (script wrapper) */
    if (GKI_get_taskid() != NFC_HAL_TASK) {
      /* post event to start timer in NCIT task */
      p_msg = (NFC_HDR*)GKI_getbuf(NFC_HDR_SIZE);
      if (p_msg != NULL) {
        p_msg->event = NFC_HAL_EVT_TO_START_QUICK_TIMER;
        GKI_send_msg(NFC_HAL_TASK, NFC_HAL_TASK_MBOX, p_msg);
      }
    } else {
      GKI_start_timer(NFC_HAL_QUICK_TIMER_ID,
                      ((GKI_SECS_TO_TICKS(1) / QUICK_TIMER_TICKS_PER_SEC)),
                      true);
    }
  }

  GKI_remove_from_timer_list(&nfc_hal_cb.quick_timer_queue, p_tle);

  p_tle->event = type;
  p_tle->ticks = timeout; /* Save the number of ticks for the timer */

  GKI_add_to_timer_list(&nfc_hal_cb.quick_timer_queue, p_tle);
}

/*******************************************************************************
**
** Function         nfc_hal_main_stop_quick_timer
**
** Description      Stop a timer.
**
** Returns          void
**
*******************************************************************************/
void nfc_hal_main_stop_quick_timer(TIMER_LIST_ENT* p_tle) {
  GKI_remove_from_timer_list(&nfc_hal_cb.quick_timer_queue, p_tle);

  /* if timer list is empty stop periodic GKI timer */
  if (nfc_hal_cb.quick_timer_queue.p_first == NULL) {
    GKI_stop_timer(NFC_HAL_QUICK_TIMER_ID);
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_process_quick_timer_evt
**
** Description      Process quick timer event
**
** Returns          void
**
*******************************************************************************/
static void nfc_hal_main_process_quick_timer_evt(void) {
  TIMER_LIST_ENT* p_tle;

  GKI_update_timer_list(&nfc_hal_cb.quick_timer_queue, 1);

  while ((nfc_hal_cb.quick_timer_queue.p_first) &&
         (!nfc_hal_cb.quick_timer_queue.p_first->ticks)) {
    p_tle = nfc_hal_cb.quick_timer_queue.p_first;
    GKI_remove_from_timer_list(&nfc_hal_cb.quick_timer_queue, p_tle);

    if (p_tle->p_cback) {
      (*p_tle->p_cback)(p_tle);
    }
  }

  /* if timer list is empty stop periodic GKI timer */
  if (nfc_hal_cb.quick_timer_queue.p_first == NULL) {
    GKI_stop_timer(NFC_HAL_QUICK_TIMER_ID);
  }
}

/*******************************************************************************
**
** Function         nfc_hal_send_nci_msg_to_nfc_task
**
** Description      This function is called to send nci message to nfc task
**
** Returns          void
**
*******************************************************************************/
void nfc_hal_send_nci_msg_to_nfc_task(NFC_HDR* p_msg) {
#ifdef NFC_HAL_SHARED_GKI
  /* Using shared NFC/HAL GKI resources - send message buffer directly to
   * NFC_TASK for processing */
  p_msg->event = BT_EVT_TO_NFC_NCI;
  GKI_send_msg(NFC_TASK, NFC_MBOX_ID, p_msg);
#else
  /* Send NCI message to the stack */
  nfc_hal_cb.p_data_cback(p_msg->len, (uint8_t*)((p_msg + 1) + p_msg->offset));
  GKI_freebuf(p_msg);
#endif
}

/*******************************************************************************
**
** Function         nfc_hal_send_credit_ntf_for_cid
**
** Description      This function is called to send credit ntf
**                  for the specified connection id to nfc task
**
** Returns          void
**
*******************************************************************************/
static void nfc_hal_send_credit_ntf_for_cid(uint8_t cid) {
  NFC_HDR* p_msg;
  uint8_t *p, *ps;

  /* Start of new message. Allocate a buffer for message */
  p_msg = (NFC_HDR*)GKI_getpoolbuf(NFC_HAL_NCI_POOL_ID);
  if (p_msg != NULL) {
    /* Initialize NFC_HDR */
    p_msg->len = NCI_DATA_HDR_SIZE + 0x03;
    p_msg->event = 0;
    p_msg->offset = 0;
    p_msg->layer_specific = 0;

    p = (uint8_t*)(p_msg + 1) + p_msg->offset;
    ps = p;
    NCI_MSG_BLD_HDR0(p, NCI_MT_NTF, NCI_GID_CORE);
    NCI_MSG_BLD_HDR1(p, NCI_MSG_CORE_CONN_CREDITS);
    UINT8_TO_STREAM(p, 0x03);

    /* Number of credit entries */
    *p++ = 0x01;
    /* Connection id of the credit ntf */
    *p++ = cid;
    /* Number of credits */
    *p = 0x01;
#ifdef DISP_NCI
    DISP_NCI(ps, (uint16_t)p_msg->len, true);
#endif
    nfc_hal_send_nci_msg_to_nfc_task(p_msg);
  } else {
    HAL_TRACE_ERROR0(
        "Unable to allocate buffer for Sending credit ntf to stack");
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_send_message
**
** Description      This function is calledto send an NCI message.
**
** Returns          void
**
*******************************************************************************/
static void nfc_hal_main_send_message(NFC_HDR* p_msg) {
#if (NFC_HAL_HCI_INCLUDED == TRUE)
  uint8_t cid, pbf;
  uint16_t data_len;
#endif
  uint8_t *ps, *pp;
  uint16_t len = p_msg->len;
#ifdef DISP_NCI
  uint8_t delta;
#endif

  HAL_TRACE_DEBUG1("nfc_hal_main_send_message() ls:0x%x",
                   p_msg->layer_specific);
  if ((p_msg->layer_specific == NFC_HAL_WAIT_RSP_CMD) ||
      (p_msg->layer_specific == NFC_HAL_WAIT_RSP_VSC)) {
    nfc_hal_nci_send_cmd(p_msg);
  } else {
    /* NFC task has fragmented the data packet to the appropriate size
     * and data credit is available; just send it */

    /* add NCI packet type in front of message */
    nfc_hal_nci_add_nfc_pkt_type(p_msg);

    /* send this packet to transport */
    ps = (uint8_t*)(p_msg + 1) + p_msg->offset;
    pp = ps + 1;
#ifdef DISP_NCI
    delta = p_msg->len - len;
    DISP_NCI(ps + delta, (uint16_t)(p_msg->len - delta), false);
#endif

#if (NFC_HAL_HCI_INCLUDED == TRUE)
    if (nfc_hal_cb.hci_cb.hcp_conn_id) {
      NCI_DATA_PRS_HDR(pp, pbf, cid, data_len);
      if (cid == nfc_hal_cb.hci_cb.hcp_conn_id) {
        if (nfc_hal_hci_handle_hcp_pkt_to_hc(pp)) {
          HAL_TRACE_DEBUG0(
              "nfc_hal_main_send_message() - Drop rsp to Fake cmd, Fake credit "
              "ntf");
          GKI_freebuf(p_msg);
          nfc_hal_send_credit_ntf_for_cid(cid);
          return;
        }
      }
    }
#endif

    /* check low power mode state */
    if (nfc_hal_dm_power_mode_execute(NFC_HAL_LP_TX_DATA_EVT)) {
      USERIAL_Write(USERIAL_NFC_PORT, ps, p_msg->len);
    } else {
      HAL_TRACE_ERROR0(
          "nfc_hal_main_send_message(): drop data in low power mode");
    }
    GKI_freebuf(p_msg);
  }
}

/*******************************************************************************
**
** Function         nfc_hal_main_task
**
** Description      NFC HAL NCI transport event processing task
**
** Returns          0
**
*******************************************************************************/
uint32_t nfc_hal_main_task(uint32_t param) {
  uint16_t event;
  uint8_t byte;
  uint8_t num_interfaces;
  uint8_t* p;
  NFC_HDR* p_msg;
  bool free_msg;

  HAL_TRACE_DEBUG0("NFC_HAL_TASK started");

  /* Main loop */
  while (true) {
    event = GKI_wait(0xFFFF, 0);

    /* Handle NFC_HAL_TASK_EVT_INITIALIZE (for initializing NCI transport) */
    if (event & NFC_HAL_TASK_EVT_INITIALIZE) {
      HAL_TRACE_DEBUG0(
          "NFC_HAL_TASK got NFC_HAL_TASK_EVT_INITIALIZE signal. Opening NFC "
          "transport...");

      nfc_hal_main_open_transport();
    }

    /* Check for terminate event */
    if (event & NFC_HAL_TASK_EVT_TERMINATE) {
      HAL_TRACE_DEBUG0("NFC_HAL_TASK got NFC_HAL_TASK_EVT_TERMINATE");

      nfc_hal_main_close();

      continue;
    }

    /* Check for power cycle event */
    if (event & NFC_HAL_TASK_EVT_POWER_CYCLE) {
      HAL_TRACE_DEBUG0("NFC_HAL_TASK got NFC_HAL_TASK_EVT_POWER_CYCLE");
      nfc_hal_main_handle_terminate();

      /* Close uart */
      USERIAL_Close(USERIAL_NFC_PORT);

      /* power cycle timeout */
      nfc_hal_main_start_quick_timer(
          &nfc_hal_cb.timer, NFC_HAL_TTYPE_POWER_CYCLE,
          (NFC_HAL_POWER_CYCLE_DELAY * QUICK_TIMER_TICKS_PER_SEC) / 1000);
      continue;
    }

    /* NCI message ready to be sent to NFCC */
    if (event & NFC_HAL_TASK_EVT_MBOX) {
      while ((p_msg = (NFC_HDR*)GKI_read_mbox(NFC_HAL_TASK_MBOX)) != NULL) {
        free_msg = true;
        switch (p_msg->event & NFC_EVT_MASK) {
          case NFC_HAL_EVT_TO_NFC_NCI:
            nfc_hal_main_send_message(p_msg);
            /* do not free buffer. NCI VS code may keep it for processing later
             */
            free_msg = false;
            break;

          case NFC_HAL_EVT_POST_CORE_RESET:
            NFC_HAL_SET_INIT_STATE(NFC_HAL_INIT_STATE_W4_POST_INIT_DONE);

            /* set NCI Control packet size from CORE_INIT_RSP */
            p = (uint8_t*)(p_msg + 1) + p_msg->offset + NCI_MSG_HDR_SIZE;
            p += 5;
            STREAM_TO_UINT8(num_interfaces, p);
            p += (num_interfaces + 3);
            nfc_hal_cb.ncit_cb.nci_ctrl_size = *p;

            /* start post initialization */
            nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_LPTD;
            nfc_hal_cb.dev_cb.next_startup_vsc = 1;

            nfc_hal_dm_config_nfcc();
            break;

          case NFC_HAL_EVT_TO_START_QUICK_TIMER:
            GKI_start_timer(
                NFC_HAL_QUICK_TIMER_ID,
                ((GKI_SECS_TO_TICKS(1) / QUICK_TIMER_TICKS_PER_SEC)), true);
            break;

          case NFC_HAL_EVT_HCI:
            nfc_hal_hci_evt_hdlr((tNFC_HAL_HCI_EVENT_DATA*)p_msg);
            break;

          case NFC_HAL_EVT_PRE_DISCOVER:
            NFC_HAL_SET_INIT_STATE(NFC_HAL_INIT_STATE_W4_PREDISCOVER_DONE);
            nfa_hal_send_pre_discover_cfg();
            break;

          case NFC_HAL_EVT_CONTROL_GRANTED:
            nfc_hal_dm_send_pend_cmd();
            break;

          default:
            break;
        }

        if (free_msg) GKI_freebuf(p_msg);
      }
    }

    /* Data waiting to be read from serial port */
    if (event & NFC_HAL_TASK_EVT_DATA_RDY) {
      while (true) {
        /* Read one byte to see if there is anything waiting to be read */
        if (USERIAL_Read(USERIAL_NFC_PORT, &byte, 1) == 0) {
          break;
        }

        if (nfc_hal_nci_receive_msg(byte)) {
          /* complete of receiving NCI message */
          nfc_hal_nci_assemble_nci_msg();
          if (nfc_hal_cb.ncit_cb.p_rcv_msg) {
            if (nfc_hal_nci_preproc_rx_nci_msg(nfc_hal_cb.ncit_cb.p_rcv_msg)) {
              /* Send NCI message to the stack */
              nfc_hal_send_nci_msg_to_nfc_task(nfc_hal_cb.ncit_cb.p_rcv_msg);
            } else {
              if (nfc_hal_cb.ncit_cb.p_rcv_msg)
                GKI_freebuf(nfc_hal_cb.ncit_cb.p_rcv_msg);
            }
            nfc_hal_cb.ncit_cb.p_rcv_msg = NULL;
          }
        }
      } /* while (TRUE) */
    }

    /* Process quick timer tick */
    if (event & NFC_HAL_QUICK_TIMER_EVT_MASK) {
      nfc_hal_main_process_quick_timer_evt();
    }
  }

  HAL_TRACE_DEBUG0("nfc_hal_main_task terminated");

  GKI_exit_task(GKI_get_taskid());
  return 0;
}

/*******************************************************************************
**
** Function         HAL_NfcSetTraceLevel
**
** Description      This function sets the trace level for HAL.  If called with
**                  a value of 0xFF, it simply returns the current trace level.
**
** Returns          The new or current trace level
**
*******************************************************************************/
uint8_t HAL_NfcSetTraceLevel(uint8_t new_level) {
  if (new_level != 0xFF) nfc_hal_cb.trace_level = new_level;

  return (nfc_hal_cb.trace_level);
}