/******************************************************************************* ** ** Function nfc_hal_prm_spd_reset_ntf ** ** Description Received RESET NTF from NFCC, indicating it has completed ** reset after patch download. ** ** Returns void ** *******************************************************************************/ void nfc_hal_prm_spd_reset_ntf (UINT8 reset_reason, UINT8 reset_type) { /* Check if we were expecting a RESET NTF */ if (nfc_hal_cb.prm.state == NFC_HAL_PRM_ST_SPD_AUTH_DONE) { HAL_TRACE_DEBUG2 ("Received RESET NTF after patch download (reset_reason=%i, reset_type=%i)", reset_reason, reset_type); /* Stop waiting for RESET NTF */ nfc_hal_main_stop_quick_timer (&nfc_hal_cb.prm.timer); { /* Continue with patch download */ nfc_hal_prm_nfcc_ready_to_continue (); } } else if (nfc_hal_cb.prm.state == NFC_HAL_PRM_ST_SPD_GET_PATCH_HEADER) { HAL_TRACE_DEBUG0 ("Received RESET NTF after pre-I2C patch download. Proceeding with patch download..."); /* Stop waiting for RESET NTF */ nfc_hal_main_stop_quick_timer (&nfc_hal_cb.prm.timer); nfc_hal_prm_spd_handle_next_patch_start (); } else { HAL_TRACE_ERROR2 ("Received unexpected RESET NTF (reset_reason=%i, reset_type=%i)", reset_reason, reset_type); } }
/******************************************************************************* ** ** Function nfc_hal_dm_check_pre_set_mem ** ** Description Check if need to send the command. ** ** Returns TRUE if done. ** *******************************************************************************/ BOOLEAN nfc_hal_dm_check_pre_set_mem (void) { UINT8 cmd[NFC_HAL_BT_HCI_CMD_HDR_SIZE + HCI_BRCM_PRE_SET_MEM_LENGTH]; UINT8 *p; UINT32 addr = 0; if (p_nfc_hal_dm_pre_set_mem) addr = p_nfc_hal_dm_pre_set_mem[nfc_hal_cb.pre_set_mem_idx].addr; HAL_TRACE_DEBUG2 ("nfc_hal_dm_check_pre_set_mem: %d/0x%x", nfc_hal_cb.pre_set_mem_idx, addr); if (addr == 0) { return TRUE; } p = cmd; /* Add the command */ UINT16_TO_STREAM (p, HCI_BRCM_PRE_SET_MEM); UINT8_TO_STREAM (p, HCI_BRCM_PRE_SET_MEM_LENGTH); UINT8_TO_STREAM (p, HCI_BRCM_PRE_SET_MEM_TYPE); UINT32_TO_STREAM (p, addr); UINT8_TO_STREAM (p, 0); UINT32_TO_STREAM (p, p_nfc_hal_dm_pre_set_mem[nfc_hal_cb.pre_set_mem_idx].data); nfc_hal_cb.pre_set_mem_idx++; nfc_hal_dm_send_bt_cmd (cmd, NFC_HAL_BT_HCI_CMD_HDR_SIZE + HCI_BRCM_PRE_SET_MEM_LENGTH, nfc_hal_dm_pre_set_mem_cback); return FALSE; }
/******************************************************************************* ** ** Function nfc_hal_dm_send_bt_cmd ** ** Description Send BT message to NFCC while initializing BRCM NFCC ** ** Returns void ** *******************************************************************************/ void nfc_hal_dm_send_bt_cmd (const UINT8 *p_data, UINT16 len, tNFC_HAL_BTVSC_CPLT_CBACK *p_cback) { NFC_HDR *p_buf; char buff[300]; char tmp[4]; buff[0] = 0; int i; HAL_TRACE_DEBUG1 ("nfc_hal_dm_send_bt_cmd (): nci_wait_rsp = 0x%x", nfc_hal_cb.ncit_cb.nci_wait_rsp); for (i = 0; i < len; i++) { sprintf (tmp, "%02x ", p_data[i]); strcat(buff, tmp); } HAL_TRACE_DEBUG2 ("nfc_hal_dm_send_bt_cmd (): HCI Write (%d bytes): %s", len, buff); if (nfc_hal_cb.ncit_cb.nci_wait_rsp != NFC_HAL_WAIT_RSP_NONE) { HAL_TRACE_ERROR0 ("nfc_hal_dm_send_bt_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_PROP; p_buf->offset = NFC_HAL_NCI_MSG_OFFSET_SIZE; p_buf->len = len; memcpy ((UINT8*) (p_buf + 1) + p_buf->offset, p_data, len); /* save the callback for NCI VSCs) */ nfc_hal_cb.ncit_cb.p_vsc_cback = (void *)p_cback; nfc_hal_cb.ncit_cb.p_pend_cmd = p_buf; if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_IDLE) { NFC_HAL_SET_INIT_STATE(NFC_HAL_INIT_STATE_W4_CONTROL_DONE); nfc_hal_cb.p_stack_cback (HAL_NFC_REQUEST_CONTROL_EVT, HAL_NFC_STATUS_OK); return; } nfc_hal_dm_send_pend_cmd(); } }
/******************************************************************************* ** ** Function nfc_hal_prm_spd_check_version ** ** Description Check patchfile version with current downloaded version ** ** Returns void ** *******************************************************************************/ void nfc_hal_prm_spd_check_version (void) { UINT8 *p, *p_start, i; UINT32 nvm_patch_present_mask = 0; UINT32 patchfile_patch_present_mask; UINT16 patchfile_project_id = 0; UINT16 patchfile_ver_major = 0; UINT16 patchfile_ver_minor = 0; UINT16 patchfile_patchsize; UINT8 return_code = NFC_HAL_PRM_COMPLETE_EVT; /* Initialize patchfile offset pointers */ p = p_start = NULL; patchfile_patchsize = 0; /* the good patches in NVM */ if (nfc_hal_cb.nvm_cb.lpm_size && !(nfc_hal_cb.nvm_cb.flags & (NFC_HAL_NVM_FLAGS_LPM_BAD))) nvm_patch_present_mask |= (1 << NFC_HAL_PRM_SPD_POWER_MODE_LPM); if (nfc_hal_cb.nvm_cb.fpm_size && !(nfc_hal_cb.nvm_cb.flags & (NFC_HAL_NVM_FLAGS_FPM_BAD))) nvm_patch_present_mask |= (1 << NFC_HAL_PRM_SPD_POWER_MODE_FPM); /* Get patchfile version */ if (nfc_hal_cb.prm.cur_patch_len_remaining >= NFC_HAL_PRM_NCD_PATCHFILE_HDR_LEN) { /* Parse patchfile header */ p = (UINT8 *) nfc_hal_cb.prm.p_cur_patch_data; p_start = p; STREAM_TO_UINT16 (patchfile_project_id, p); STREAM_TO_UINT16 (patchfile_ver_major, p); STREAM_TO_UINT16 (patchfile_ver_minor, p); /* RFU */ p++; /* Check how many patches are in the patch file */ STREAM_TO_UINT8 (nfc_hal_cb.prm.spd_patch_count, p); if (nfc_hal_cb.prm.spd_patch_count > NFC_HAL_PRM_MAX_PATCH_COUNT) { HAL_TRACE_ERROR2 ("Unsupported patchfile (number of patches (%i) exceeds maximum (%i)", nfc_hal_cb.prm.spd_patch_count, NFC_HAL_PRM_MAX_PATCH_COUNT); } /* Mask of patches that are present in the patchfile */ patchfile_patch_present_mask = 0; /* Get lengths for each patch */ for (i = 0; i < nfc_hal_cb.prm.spd_patch_count; i++) { /* Get power mode for this patch */ STREAM_TO_UINT8 (nfc_hal_cb.prm.spd_patch_desc[i].power_mode, p); /* Update mask of power-modes present in the patchfile */ patchfile_patch_present_mask |= ((UINT32) 1 << nfc_hal_cb.prm.spd_patch_desc[i].power_mode); /* Get length of patch */ STREAM_TO_UINT16 (nfc_hal_cb.prm.spd_patch_desc[i].len, p); /* Add total size of patches */ patchfile_patchsize += nfc_hal_cb.prm.spd_patch_desc[i].len; /* 5 byte RFU */ p += 5; } /* Adjust offset to after the patch file header */ nfc_hal_cb.prm.cur_patch_offset += (UINT16) (p - p_start); /* Bytes of patchfile transmitted/processed so far */ nfc_hal_cb.prm.cur_patch_len_remaining -= (UINT16) (p - p_start); /* Adjust size of patchfile */ HAL_TRACE_DEBUG4 ("NVM Patch info: flags=0x%04x, Ver=%i.%i, PatchMask=0x%08x", nfc_hal_cb.nvm_cb.flags, nfc_hal_cb.nvm_cb.ver_major, nfc_hal_cb.nvm_cb.ver_minor, nvm_patch_present_mask ); HAL_TRACE_DEBUG6 ("Patchfile info: ProjID=0x%04x, Ver=%i.%i, Num patches=%i, PatchMask=0x%08x, PatchSize=%i", patchfile_project_id, patchfile_ver_major, patchfile_ver_minor, nfc_hal_cb.prm.spd_patch_count, patchfile_patch_present_mask, patchfile_patchsize); /********************************************************************* * Version check of patchfile against NVM ******************************************************************** /* Download the patchfile if no patches in NVM */ if ((nfc_hal_cb.nvm_cb.project_id == 0) || !(nfc_hal_cb.nvm_cb.flags & NFC_HAL_NVM_FLAGS_PATCH_PRESENT)) { /* No patch in NVM, need to download all */ nfc_hal_cb.prm.spd_patch_needed_mask = patchfile_patch_present_mask; HAL_TRACE_DEBUG2 ("No previous patch detected. Downloading patch %i.%i", patchfile_ver_major, patchfile_ver_minor); } /* Skip download if project ID of patchfile does not match NVM */ else if (nfc_hal_cb.nvm_cb.project_id != patchfile_project_id) { /* Project IDs mismatch */ HAL_TRACE_DEBUG2 ("Patch download skipped: Mismatched Project ID (NVM ProjId: 0x%04x, Patchfile ProjId: 0x%04x)", nfc_hal_cb.nvm_cb.project_id, patchfile_project_id); return_code = NFC_HAL_PRM_ABORT_INVALID_PATCH_EVT; } /* Skip download if version of patchfile is equal to version in NVM */ /* and patches of the power modes are the same as the good patches in NVM */ else if ( (nfc_hal_cb.nvm_cb.ver_major == patchfile_ver_major) &&(nfc_hal_cb.nvm_cb.ver_minor == patchfile_ver_minor) &&((nvm_patch_present_mask | patchfile_patch_present_mask) == nvm_patch_present_mask) ) /* if the NVM patch include all the patched in file */ { HAL_TRACE_DEBUG2 ("Patch download skipped. NVM patch (version %i.%i) is the same than the patchfile ", nfc_hal_cb.nvm_cb.ver_major, nfc_hal_cb.nvm_cb.ver_minor); return_code = NFC_HAL_PRM_COMPLETE_EVT; } /* Remaining cases: Download all patches in the patchfile */ else { nfc_hal_cb.prm.spd_patch_needed_mask = patchfile_patch_present_mask; HAL_TRACE_DEBUG4 ("Downloading patch version: %i.%i (previous version in NVM: %i.%i)...", patchfile_ver_major, patchfile_ver_minor, nfc_hal_cb.nvm_cb.ver_major, nfc_hal_cb.nvm_cb.ver_minor); } } else { /* Invalid patch file header */ HAL_TRACE_ERROR0 ("Invalid patch file header."); return_code = NFC_HAL_PRM_ABORT_INVALID_PATCH_EVT; } /* If we need to download anything, get the first patch to download */ if (nfc_hal_cb.prm.spd_patch_needed_mask) { HAL_TRACE_ERROR4 ("Downloading patch version: %i.%i (previous version in NVM: %i.%i)...", patchfile_ver_major, patchfile_ver_minor, nfc_hal_cb.nvm_cb.ver_major, nfc_hal_cb.nvm_cb.ver_minor); #if (defined (NFC_HAL_PRE_I2C_PATCH_INCLUDED) && (NFC_HAL_PRE_I2C_PATCH_INCLUDED == TRUE)) /* Check if I2C patch is needed: if */ /* - I2C patch file was provided using HAL_NfcPrmSetI2cPatch, and */ /* - current patch in NVM has ProjectID=0, or */ /* FPM is not present or corrupted, or */ /* or patchfile is major-ver 76+ */ /* or patchfile is not for B3 (always download for B4 onward) */ if ( (nfc_hal_cb.prm_i2c.p_patch) &&( (nfc_hal_cb.nvm_cb.project_id == 0) ||(nfc_hal_cb.nvm_cb.fpm_size == 0) ||(nfc_hal_cb.nvm_cb.flags & NFC_HAL_NVM_FLAGS_FPM_BAD) ||(patchfile_ver_major >= 76) ||(!(nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_BCM20791B3)) )) { HAL_TRACE_DEBUG0 ("I2C patch fix required."); nfc_hal_cb.prm.flags |= NFC_HAL_PRM_FLAGS_I2C_FIX_REQUIRED; /* Download i2c fix first */ nfc_hal_prm_spd_download_i2c_fix (); return; } #endif /* NFC_HAL_PRE_I2C_PATCH_INCLUDED */ /* Download first segment */ nfc_hal_cb.prm.state = NFC_HAL_PRM_ST_SPD_GET_PATCH_HEADER; if (!(nfc_hal_cb.prm.flags & NFC_HAL_PRM_FLAGS_USE_PATCHRAM_BUF)) { /* Notify adaptation layer to call HAL_NfcPrmDownloadContinue with the next patch segment */ (nfc_hal_cb.prm.p_cback) (NFC_HAL_PRM_SPD_GET_NEXT_PATCH); } else { nfc_hal_prm_spd_handle_next_patch_start (); } } else { static BOOLEAN firstTime = TRUE; if (firstTime) { HAL_TRACE_ERROR2 ("NVM patch version is %d.%d", nfc_hal_cb.nvm_cb.ver_major, nfc_hal_cb.nvm_cb.ver_minor); firstTime = FALSE; } /* Download complete */ nfc_hal_prm_spd_handle_download_complete (return_code); } }
/******************************************************************************* ** ** 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); } } }