/******************************************************************************* ** ** 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_dm_send_pend_cmd ** ** Description Send a command to NFCC ** ** Returns void ** *******************************************************************************/ void nfc_hal_dm_send_pend_cmd (void) { NFC_HDR *p_buf = nfc_hal_cb.ncit_cb.p_pend_cmd; UINT8 *p; if (p_buf == NULL) return; /* check low power mode state */ if (!nfc_hal_dm_power_mode_execute (NFC_HAL_LP_TX_DATA_EVT)) { return; } if (nfc_hal_cb.ncit_cb.nci_wait_rsp == NFC_HAL_WAIT_RSP_PROP) { #if (NFC_HAL_TRACE_PROTOCOL == TRUE) DispHciCmd (p_buf); #endif /* save the message header to double check the response */ p = (UINT8 *)(p_buf + 1) + p_buf->offset; memcpy(nfc_hal_cb.ncit_cb.last_hdr, p, NFC_HAL_SAVED_HDR_SIZE); /* add packet type for BT message */ p_buf->offset--; p_buf->len++; p = (UINT8 *) (p_buf + 1) + p_buf->offset; *p = HCIT_TYPE_COMMAND; USERIAL_Write (USERIAL_NFC_PORT, p, p_buf->len); GKI_freebuf (p_buf); nfc_hal_cb.ncit_cb.p_pend_cmd = NULL; /* start NFC command-timeout timer */ nfc_hal_main_start_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer, (UINT16)(NFC_HAL_TTYPE_NCI_WAIT_RSP), ((UINT32) NFC_HAL_CMD_TOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000); } }
/******************************************************************************* ** ** Function HAL_NfcReInit ** ** Description This function is called to restart initialization after REG_PU ** toggled because of failure to detect NVM type or download patchram. ** ** Note This function should be called only during the HAL init process ** ** Returns HAL_NFC_STATUS_OK if successfully initiated ** HAL_NFC_STATUS_FAILED otherwise ** *******************************************************************************/ tHAL_NFC_STATUS HAL_NfcReInit (void) { tHAL_NFC_STATUS status = HAL_NFC_STATUS_FAILED; HAL_TRACE_DEBUG1 ("HAL_NfcReInit () init st=0x%x", nfc_hal_cb.dev_cb.initializing_state); if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_APP_COMPLETE) { { /* 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); } status = HAL_NFC_STATUS_OK; } return status; }
/******************************************************************************* ** ** Function nfc_hal_dm_send_nci_cmd ** ** Description Send NCI command to NFCC while initializing BRCM NFCC ** ** Returns void ** *******************************************************************************/ void nfc_hal_dm_send_nci_cmd (const UINT8 *p_data, UINT16 len, tNFC_HAL_NCI_CBACK *p_cback) { NFC_HDR *p_buf; UINT8 *ps; HAL_TRACE_DEBUG1 ("nfc_hal_dm_send_nci_cmd (): nci_wait_rsp = 0x%x", nfc_hal_cb.ncit_cb.nci_wait_rsp); if (nfc_hal_cb.ncit_cb.nci_wait_rsp != NFC_HAL_WAIT_RSP_NONE) { HAL_TRACE_ERROR0 ("nfc_hal_dm_send_nci_cmd(): no command window"); return; } if ((p_buf = (NFC_HDR *)GKI_getpoolbuf (NFC_HAL_NCI_POOL_ID)) != NULL) { nfc_hal_cb.ncit_cb.nci_wait_rsp = NFC_HAL_WAIT_RSP_VSC; p_buf->offset = NFC_HAL_NCI_MSG_OFFSET_SIZE; p_buf->event = NFC_HAL_EVT_TO_NFC_NCI; p_buf->len = len; memcpy ((UINT8*) (p_buf + 1) + p_buf->offset, p_data, len); /* Keep a copy of the command and send to NCI transport */ /* save the message header to double check the response */ ps = (UINT8 *)(p_buf + 1) + p_buf->offset; memcpy(nfc_hal_cb.ncit_cb.last_hdr, ps, NFC_HAL_SAVED_HDR_SIZE); memcpy(nfc_hal_cb.ncit_cb.last_cmd, ps + NCI_MSG_HDR_SIZE, NFC_HAL_SAVED_CMD_SIZE); /* save the callback for NCI VSCs */ nfc_hal_cb.ncit_cb.p_vsc_cback = (void *)p_cback; nfc_hal_nci_send_cmd (p_buf); /* start NFC command-timeout timer */ nfc_hal_main_start_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer, (UINT16)(NFC_HAL_TTYPE_NCI_WAIT_RSP), ((UINT32) NFC_HAL_CMD_TOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000); } }
/******************************************************************************* ** ** Function nfc_hal_dm_set_snooze_mode_cback ** ** Description This is snooze update complete callback. ** ** Returns void ** *******************************************************************************/ static void nfc_hal_dm_set_snooze_mode_cback (tNFC_HAL_BTVSC_CPLT *pData) { UINT8 status = pData->p_param_buf[0]; tHAL_NFC_STATUS hal_status; tHAL_NFC_STATUS_CBACK *p_cback; /* if it is completed */ if (status == HCI_SUCCESS) { /* update snooze mode */ nfc_hal_cb.dev_cb.snooze_mode = nfc_hal_cb.dev_cb.new_snooze_mode; nfc_hal_dm_set_nfc_wake (NFC_HAL_ASSERT_NFC_WAKE); if ( nfc_hal_cb.dev_cb.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE) { /* start idle timer */ nfc_hal_main_start_quick_timer (&nfc_hal_cb.dev_cb.lp_timer, 0x00, ((UINT32) NFC_HAL_LP_IDLE_TIMEOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000); } else { nfc_hal_main_stop_quick_timer (&nfc_hal_cb.dev_cb.lp_timer); } hal_status = HAL_NFC_STATUS_OK; } else { hal_status = HAL_NFC_STATUS_FAILED; } if (nfc_hal_cb.dev_cb.p_prop_cback) { p_cback = nfc_hal_cb.dev_cb.p_prop_cback; nfc_hal_cb.dev_cb.p_prop_cback = NULL; (*p_cback) (hal_status); } }
/******************************************************************************* ** ** Function nfc_hal_dm_power_mode_execute ** ** Description If snooze mode is enabled in full power mode, ** Assert NFC_WAKE before sending data ** Deassert NFC_WAKE when idle timer expires ** ** Returns TRUE if DH can send data to NFCC ** *******************************************************************************/ BOOLEAN nfc_hal_dm_power_mode_execute (tNFC_HAL_LP_EVT event) { BOOLEAN send_to_nfcc = FALSE; HAL_TRACE_DEBUG1 ("nfc_hal_dm_power_mode_execute () event = %d", event); if (nfc_hal_cb.dev_cb.power_mode == NFC_HAL_POWER_MODE_FULL) { if (nfc_hal_cb.dev_cb.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE) { /* if any transport activity */ if ( (event == NFC_HAL_LP_TX_DATA_EVT) ||(event == NFC_HAL_LP_RX_DATA_EVT) ) { /* if idle timer is not running */ if (nfc_hal_cb.dev_cb.lp_timer.in_use == FALSE) { nfc_hal_dm_set_nfc_wake (NFC_HAL_ASSERT_NFC_WAKE); } /* start or extend idle timer */ nfc_hal_main_start_quick_timer (&nfc_hal_cb.dev_cb.lp_timer, 0x00, ((UINT32) NFC_HAL_LP_IDLE_TIMEOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000); } else if (event == NFC_HAL_LP_TIMEOUT_EVT) { /* let NFCC go to snooze mode */ nfc_hal_dm_set_nfc_wake (NFC_HAL_DEASSERT_NFC_WAKE); } } send_to_nfcc = TRUE; } return (send_to_nfcc); }
/******************************************************************************* ** ** Function nfc_hal_prm_nci_command_complete_cback ** ** Description Callback for NCI vendor specific command complete ** (for secure patch download) ** ** Returns void ** *******************************************************************************/ void nfc_hal_prm_nci_command_complete_cback (tNFC_HAL_NCI_EVT event, UINT16 data_len, UINT8 *p_data) { UINT8 status, u8; UINT8 *p; UINT32 post_signature_delay; NFC_HAL_PRM_STATE ("nfc_hal_prm_nci_command_complete_cback"); /* Stop the command-timeout timer */ nfc_hal_main_stop_quick_timer (&nfc_hal_cb.prm.timer); /* Skip over NCI header */ p = p_data + NCI_MSG_HDR_SIZE; /* Handle SECURE_PATCH_DOWNLOAD Rsp */ if (event == NFC_VS_SEC_PATCH_DOWNLOAD_EVT) { /* Status and error code */ STREAM_TO_UINT8 (status, p); STREAM_TO_UINT8 (u8, p); if (status != NCI_STATUS_OK) { #if (NFC_HAL_TRACE_VERBOSE == TRUE) HAL_TRACE_ERROR2 ("Patch download failed, reason code=0x%X (%s)", status, nfc_hal_prm_spd_status_str (status)); #else HAL_TRACE_ERROR1 ("Patch download failed, reason code=0x%X", status); #endif /* Notify application */ nfc_hal_prm_spd_handle_download_complete (NFC_HAL_PRM_ABORT_INVALID_PATCH_EVT); return; } /* If last segment (SIGNATURE) sent */ if (nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_SIGNATURE_SENT) { /* Wait for authentication complete (SECURE_PATCH_DOWNLOAD NTF), including time to commit to NVM (for BCM43341B0) */ int auth_delay = NFC_HAL_PRM_SPD_TOUT; if (!(nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_BCM20791B3)) { /* XXX maco only wait 30 seconds for B4+ revisions to avoid watchdog timeouts */ auth_delay = NFC_HAL_PRM_COMMIT_DELAY; } nfc_hal_cb.prm.state = NFC_HAL_PRM_ST_SPD_AUTHENTICATING; nfc_hal_main_start_quick_timer (&nfc_hal_cb.prm.timer, 0x00, (auth_delay * QUICK_TIMER_TICKS_PER_SEC) / 1000); return; } /* Download next segment */ else if (nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_USE_PATCHRAM_BUF) { /* If patch is in a buffer, get next patch from buffer */ nfc_hal_prm_spd_send_next_segment (); } else { /* Notify adaptation layer to get next patch segment (via HAL_NfcPrmDownloadContinue) */ (nfc_hal_cb.prm.p_cback) (NFC_HAL_PRM_CONTINUE_EVT); } } /* Handle SECURE_PATCH_DOWNLOAD NTF */ else if (event == NFC_VS_SEC_PATCH_AUTH_EVT) { HAL_TRACE_DEBUG1 ("prm flags:0x%x.", nfc_hal_cb.prm.flags); /* Status and error code */ STREAM_TO_UINT8 (status, p); STREAM_TO_UINT8 (u8, p); /* Sanity check - should only get this NTF while in AUTHENTICATING stage */ if (nfc_hal_cb.prm.state == NFC_HAL_PRM_ST_SPD_AUTHENTICATING) { if (status != NCI_STATUS_OK) { HAL_TRACE_ERROR0 ("Patch authentication failed"); nfc_hal_prm_spd_handle_download_complete (NFC_HAL_PRM_ABORT_BAD_SIGNATURE_EVT); return; } #if (defined (NFC_HAL_PRE_I2C_PATCH_INCLUDED) && (NFC_HAL_PRE_I2C_PATCH_INCLUDED == TRUE)) if (nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_I2C_FIX_REQUIRED) { HAL_TRACE_DEBUG1 ("PreI2C patch downloaded...waiting %i ms for NFCC to reboot.", nfc_hal_cb.prm_i2c.prei2c_delay); /* Restore pointers to patchfile */ nfc_hal_cb.prm.flags &= ~NFC_HAL_PRM_FLAGS_I2C_FIX_REQUIRED; nfc_hal_cb.prm.p_cur_patch_data = nfc_hal_cb.prm.p_spd_patch; nfc_hal_cb.prm.cur_patch_offset = nfc_hal_cb.prm.spd_patch_offset; nfc_hal_cb.prm.cur_patch_len_remaining = nfc_hal_cb.prm.spd_patch_len_remaining; /* Resume normal patch download */ nfc_hal_cb.prm.state = NFC_HAL_PRM_ST_SPD_GET_PATCH_HEADER; nfc_hal_cb.prm.flags &= ~NFC_HAL_PRM_FLAGS_SIGNATURE_SENT; /* Post PreI2C delay */ nfc_hal_main_start_quick_timer (&nfc_hal_cb.prm.timer, 0x00, (nfc_hal_cb.prm_i2c.prei2c_delay * QUICK_TIMER_TICKS_PER_SEC) / 1000); return; } #endif /* NFC_HAL_PRE_I2C_PATCH_INCLUDED */ /* Wait for NFCC to save the patch to NVM */ if (!(nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_BCM20791B3)) { /* 20791B4 or newer - wait for RESET_NTF; including time to commit to NVM (for BCM20791B4+) */ post_signature_delay = NFC_HAL_PRM_COMMIT_DELAY; HAL_TRACE_DEBUG1 ("Patch downloaded and authenticated. Waiting %i ms for RESET NTF...", post_signature_delay); } else if (nfc_hal_cb.nvm_cb.flags & NFC_HAL_NVM_FLAGS_NO_NVM) { /* No NVM. Wait for NFCC to restart */ post_signature_delay = NFC_HAL_PRM_END_DELAY; HAL_TRACE_DEBUG1 ("Patch downloaded and authenticated. Waiting %i ms for NFCC to restart...", post_signature_delay); } else { /* Wait for NFCC to save the patch to NVM (need about 1 ms per byte) */ post_signature_delay = nfc_hal_cb.prm.spd_patch_desc[nfc_hal_cb.prm.spd_cur_patch_idx].len; if (post_signature_delay < nfc_hal_cb.prm.patchram_delay) post_signature_delay = nfc_hal_cb.prm.patchram_delay; HAL_TRACE_DEBUG1 ("Patch downloaded and authenticated. Waiting %i ms for NVM update to complete...", post_signature_delay); } nfc_hal_cb.prm.state = NFC_HAL_PRM_ST_SPD_AUTH_DONE; nfc_hal_main_start_quick_timer (&nfc_hal_cb.prm.timer, 0x00, (post_signature_delay * QUICK_TIMER_TICKS_PER_SEC) / 1000); } else { HAL_TRACE_ERROR0 ("Got unexpected SECURE_PATCH_DOWNLOAD NTF"); nfc_hal_prm_spd_handle_download_complete (NFC_HAL_PRM_ABORT_EVT); } } /* Handle NCI_MSG_GET_PATCH_VERSION RSP */ else if (event == NFC_VS_GET_PATCH_VERSION_EVT) { nfc_hal_prm_spd_handle_download_complete (NFC_HAL_PRM_COMPLETE_EVT); } else { /* Invalid response from NFCC during patch download */ HAL_TRACE_ERROR1 ("Invalid response from NFCC during patch download (opcode=0x%02X)", event); nfc_hal_prm_spd_handle_download_complete (NFC_HAL_PRM_ABORT_INVALID_PATCH_EVT); } NFC_HAL_PRM_STATE ("prm_nci_command_complete_cback"); }
/******************************************************************************* ** ** Function nfc_hal_main_task ** ** Description NFC HAL NCI transport event processing task ** ** Returns 0 ** *******************************************************************************/ UINT32 nfc_hal_main_task (UINT32 param) { UINT16 event; UINT8 byte; UINT8 num_interfaces; UINT8 *p; NFC_HDR *p_msg; BOOLEAN 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_handle_terminate (); /* Close uart */ USERIAL_Close (USERIAL_NFC_PORT); if (nfc_hal_cb.p_stack_cback) { nfc_hal_cb.p_stack_cback (HAL_NFC_CLOSE_CPLT_EVT, HAL_NFC_STATUS_OK); nfc_hal_cb.p_stack_cback = NULL; } 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 *) (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 nfc_hal_dm_proc_msg_during_init ** ** Description Process NCI message while initializing NFCC ** ** Returns void ** *******************************************************************************/ void nfc_hal_dm_proc_msg_during_init (NFC_HDR *p_msg) { UINT8 *p; UINT8 reset_reason, reset_type; UINT8 mt, pbf, gid, op_code; UINT8 *p_old, old_gid, old_oid, old_mt; UINT8 u8; tNFC_HAL_NCI_CBACK *p_cback = NULL; UINT8 chipverlen; UINT8 chipverstr[NCI_SPD_HEADER_CHIPVER_LEN]; UINT32 hw_id = 0; HAL_TRACE_DEBUG1 ("nfc_hal_dm_proc_msg_during_init(): init state:%d", nfc_hal_cb.dev_cb.initializing_state); p = (UINT8 *) (p_msg + 1) + p_msg->offset; NCI_MSG_PRS_HDR0 (p, mt, pbf, gid); NCI_MSG_PRS_HDR1 (p, op_code); /* check if waiting for this response */ if ( (nfc_hal_cb.ncit_cb.nci_wait_rsp == NFC_HAL_WAIT_RSP_CMD) ||(nfc_hal_cb.ncit_cb.nci_wait_rsp == NFC_HAL_WAIT_RSP_VSC) ) { if (mt == NCI_MT_RSP) { p_old = nfc_hal_cb.ncit_cb.last_hdr; NCI_MSG_PRS_HDR0 (p_old, old_mt, pbf, old_gid); old_oid = ((*p_old) & NCI_OID_MASK); /* make sure this is the RSP we are waiting for before updating the command window */ if ((old_gid == gid) && (old_oid == op_code)) { nfc_hal_cb.ncit_cb.nci_wait_rsp = NFC_HAL_WAIT_RSP_NONE; p_cback = (tNFC_HAL_NCI_CBACK *)nfc_hal_cb.ncit_cb.p_vsc_cback; nfc_hal_cb.ncit_cb.p_vsc_cback = NULL; nfc_hal_main_stop_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer); } } } if (gid == NCI_GID_CORE) { if (op_code == NCI_MSG_CORE_RESET) { if (mt == NCI_MT_NTF) { if ( (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_NFCC_ENABLE) ||(nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_POST_XTAL_SET) ) { /* ** Core reset ntf in the following cases; ** 1) after power up (raising REG_PU) ** 2) after setting xtal index ** Start pre-initializing NFCC */ nfc_hal_main_stop_quick_timer (&nfc_hal_cb.timer); nfc_hal_dm_pre_init_nfcc (); } else { /* Core reset ntf after post-patch download, Call reset notification callback */ p++; /* Skip over param len */ STREAM_TO_UINT8 (reset_reason, p); STREAM_TO_UINT8 (reset_type, p); nfc_hal_prm_spd_reset_ntf (reset_reason, reset_type); } } } else if (p_cback) { (*p_cback) ((tNFC_HAL_NCI_EVT) (op_code), p_msg->len, (UINT8 *) (p_msg + 1) + p_msg->offset); } } else if (gid == NCI_GID_PROP) /* this is for download patch */ { if (mt == NCI_MT_NTF) op_code |= NCI_NTF_BIT; else op_code |= NCI_RSP_BIT; if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_XTAL_SET) { if (op_code == (NCI_RSP_BIT|NCI_MSG_GET_XTAL_INDEX_FROM_DH)) { /* start timer in case that NFCC doesn't send RESET NTF after loading patch from NVM */ NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_POST_XTAL_SET); nfc_hal_main_start_quick_timer (&nfc_hal_cb.timer, NFC_HAL_TTYPE_NFCC_ENABLE, ((p_nfc_hal_cfg->nfc_hal_post_xtal_timeout)*QUICK_TIMER_TICKS_PER_SEC)/1000); } } else if ( (op_code == NFC_VS_GET_BUILD_INFO_EVT) &&(nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_BUILD_INFO) ) { p += NCI_BUILD_INFO_OFFSET_HWID; STREAM_TO_UINT32 (hw_id, p); nfc_hal_cb.dev_cb.brcm_hw_id = nfc_hal_dm_adjust_hw_id (hw_id); HAL_TRACE_DEBUG2 ("brcm_hw_id: 0x%x -> 0x%x", hw_id, nfc_hal_cb.dev_cb.brcm_hw_id); STREAM_TO_UINT8 (chipverlen, p); memset (chipverstr, 0, NCI_SPD_HEADER_CHIPVER_LEN); STREAM_TO_ARRAY (chipverstr, p, chipverlen); nfc_hal_hci_handle_build_info (chipverlen, chipverstr); nfc_hal_cb.pre_set_mem_idx = 0; if (!nfc_hal_dm_check_pre_set_mem()) { /* pre-set mem started */ return; } nfc_hal_dm_check_xtal(); } else if ( (op_code == NFC_VS_GET_PATCH_VERSION_EVT) &&(nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_PATCH_INFO) ) { /* Store NVM info to control block */ /* Skip over rsp len */ p++; /* Get project id */ STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.project_id, p); /* RFU */ p++; /* Get chip version string */ STREAM_TO_UINT8 (u8, p); if (u8 > NFC_HAL_PRM_MAX_CHIP_VER_LEN) u8 = NFC_HAL_PRM_MAX_CHIP_VER_LEN; memcpy (nfc_hal_cb.nvm_cb.chip_ver, p, u8); p += NCI_PATCH_INFO_VERSION_LEN; /* Get major/minor version */ STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.ver_major, p); STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.ver_minor, p); /* Skip over max_size and patch_max_size */ p += 4; /* Get current lpm patch size */ STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.lpm_size, p); STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.fpm_size, p); /* clear all flags which may be set during previous initialization */ nfc_hal_cb.nvm_cb.flags = 0; /* Set patch present flag */ if ((nfc_hal_cb.nvm_cb.fpm_size) || (nfc_hal_cb.nvm_cb.lpm_size)) nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_PATCH_PRESENT; /* LPMPatchCodeHasBadCRC (if not bad crc, then indicate LPM patch is present in nvm) */ STREAM_TO_UINT8 (u8, p); if (u8) { /* LPM patch in NVM fails CRC check */ nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_LPM_BAD; } /* FPMPatchCodeHasBadCRC (if not bad crc, then indicate LPM patch is present in nvm) */ STREAM_TO_UINT8 (u8, p); if (u8) { /* FPM patch in NVM fails CRC check */ nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_FPM_BAD; } /* Check if downloading patch to RAM only (no NVM) */ STREAM_TO_UINT8 (nfc_hal_cb.nvm_cb.nvm_type, p); if (nfc_hal_cb.nvm_cb.nvm_type == NCI_SPD_NVM_TYPE_NONE) { nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_NO_NVM; } /* let platform update baudrate or download patch */ NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_APP_COMPLETE); nfc_hal_post_reset_init (nfc_hal_cb.dev_cb.brcm_hw_id, nfc_hal_cb.nvm_cb.nvm_type); } else if (p_cback) { (*p_cback) ((tNFC_HAL_NCI_EVT) (op_code), p_msg->len, (UINT8 *) (p_msg + 1) + p_msg->offset); } else if (op_code == NFC_VS_SEC_PATCH_AUTH_EVT) { HAL_TRACE_DEBUG0 ("signature!!"); nfc_hal_prm_nci_command_complete_cback ((tNFC_HAL_NCI_EVT) (op_code), p_msg->len, (UINT8 *) (p_msg + 1) + p_msg->offset); } } }