1 /****************************************************************************** 2 * 3 * Copyright 2018 NXP 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 #define LOG_TAG "NxpEseHal" 19 #include <log/log.h> 20 21 #include <cutils/properties.h> 22 #include <ese_config.h> 23 #include <phNxpEseFeatures.h> 24 #include <phNxpEsePal.h> 25 #include <phNxpEsePal_spi.h> 26 #include <phNxpEseProto7816_3.h> 27 #include <phNxpEse_Internal.h> 28 29 #define RECIEVE_PACKET_SOF 0xA5 30 #define PH_PAL_ESE_PRINT_PACKET_TX(data, len) \ 31 ({ phPalEse_print_packet("SEND", data, len); }) 32 #define PH_PAL_ESE_PRINT_PACKET_RX(data, len) \ 33 ({ phPalEse_print_packet("RECV", data, len); }) 34 static int phNxpEse_readPacket(void* pDevHandle, uint8_t* pBuffer, 35 int nNbBytesToRead); 36 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 37 static ESESTATUS phNxpEse_checkJcopDwnldState(void); 38 static ESESTATUS phNxpEse_setJcopDwnldState(phNxpEse_JcopDwnldState state); 39 #endif 40 #ifdef NXP_NFCC_SPI_FW_DOWNLOAD_SYNC 41 static ESESTATUS phNxpEse_checkFWDwnldStatus(void); 42 #endif 43 static void phNxpEse_GetMaxTimer(unsigned long* pMaxTimer); 44 #ifdef NXP_SECURE_TIMER_SESSION 45 static unsigned char* phNxpEse_GgetTimerTlvBuffer(unsigned char* timer_buffer, 46 unsigned int value); 47 #endif 48 /*********************** Global Variables *************************************/ 49 50 /* ESE Context structure */ 51 phNxpEse_Context_t nxpese_ctxt; 52 bool ese_debug_enabled = true; 53 54 /****************************************************************************** 55 * Function phNxpLog_InitializeLogLevel 56 * 57 * Description This function is called during phNxpEse_init to initialize 58 * debug log level. 59 * 60 * Returns None 61 * 62 ******************************************************************************/ 63 64 void phNxpLog_InitializeLogLevel() { 65 ese_debug_enabled = 66 (EseConfig::getUnsigned(NAME_SE_DEBUG_ENABLED, 0) != 0) ? true : false; 67 68 char valueStr[PROPERTY_VALUE_MAX] = {0}; 69 int len = property_get("vendor.ese.debug_enabled", valueStr, ""); 70 if (len > 0) { 71 // let Android property override .conf variable 72 unsigned debug_enabled = 0; 73 sscanf(valueStr, "%u", &debug_enabled); 74 ese_debug_enabled = (debug_enabled == 0) ? false : true; 75 } 76 77 ALOGD_IF(ese_debug_enabled, "%s: level=%u", __func__, ese_debug_enabled); 78 } 79 80 /****************************************************************************** 81 * Function phNxpEse_init 82 * 83 * Description This function is called by Jni/phNxpEse_open during the 84 * initialization of the ESE. It initializes protocol stack 85 *instance variable 86 * 87 * Returns This function return ESESTATUS_SUCCES (0) in case of success 88 * In case of failure returns other failure value. 89 * 90 ******************************************************************************/ 91 ESESTATUS phNxpEse_init(phNxpEse_initParams initParams) { 92 ESESTATUS wConfigStatus = ESESTATUS_FAILED; 93 unsigned long int num; 94 unsigned long maxTimer = 0; 95 phNxpEseProto7816InitParam_t protoInitParam; 96 phNxpEse_memset(&protoInitParam, 0x00, sizeof(phNxpEseProto7816InitParam_t)); 97 /* STATUS_OPEN */ 98 nxpese_ctxt.EseLibStatus = ESE_STATUS_OPEN; 99 100 if (EseConfig::hasKey(NAME_NXP_WTX_COUNT_VALUE)) { 101 num = EseConfig::getUnsigned(NAME_NXP_WTX_COUNT_VALUE); 102 protoInitParam.wtx_counter_limit = num; 103 ALOGD_IF(ese_debug_enabled, "Wtx_counter read from config file - %lu", 104 protoInitParam.wtx_counter_limit); 105 } else { 106 protoInitParam.wtx_counter_limit = PH_PROTO_WTX_DEFAULT_COUNT; 107 } 108 if (EseConfig::hasKey(NAME_NXP_MAX_RNACK_RETRY)) { 109 protoInitParam.rnack_retry_limit = 110 EseConfig::getUnsigned(NAME_NXP_MAX_RNACK_RETRY); 111 } else { 112 protoInitParam.rnack_retry_limit = MAX_RNACK_RETRY_LIMIT; 113 } 114 if (ESE_MODE_NORMAL == 115 initParams.initMode) /* TZ/Normal wired mode should come here*/ 116 { 117 if (EseConfig::hasKey(NAME_NXP_SPI_INTF_RST_ENABLE)) { 118 protoInitParam.interfaceReset = 119 (EseConfig::getUnsigned(NAME_NXP_SPI_INTF_RST_ENABLE) == 1) ? true 120 : false; 121 } else { 122 protoInitParam.interfaceReset = true; 123 } 124 } else /* OSU mode, no interface reset is required */ 125 { 126 protoInitParam.interfaceReset = false; 127 } 128 /* Sharing lib context for fetching secure timer values */ 129 protoInitParam.pSecureTimerParams = 130 (phNxpEseProto7816SecureTimer_t*)&nxpese_ctxt.secureTimerParams; 131 132 ALOGD_IF(ese_debug_enabled, 133 "%s secureTimer1 0x%x secureTimer2 0x%x secureTimer3 0x%x", 134 __FUNCTION__, nxpese_ctxt.secureTimerParams.secureTimer1, 135 nxpese_ctxt.secureTimerParams.secureTimer2, 136 nxpese_ctxt.secureTimerParams.secureTimer3); 137 138 phNxpEse_GetMaxTimer(&maxTimer); 139 140 /* T=1 Protocol layer open */ 141 wConfigStatus = phNxpEseProto7816_Open(protoInitParam); 142 if (ESESTATUS_FAILED == wConfigStatus) { 143 wConfigStatus = ESESTATUS_FAILED; 144 ALOGE("phNxpEseProto7816_Open failed"); 145 } 146 return wConfigStatus; 147 } 148 149 /****************************************************************************** 150 * Function phNxpEse_open 151 * 152 * Description This function is called by Jni during the 153 * initialization of the ESE. It opens the physical connection 154 * with ESE and creates required client thread for 155 * operation. 156 * Returns This function return ESESTATUS_SUCCES (0) in case of success 157 * In case of failure returns other failure value. 158 * 159 ******************************************************************************/ 160 ESESTATUS phNxpEse_open(phNxpEse_initParams initParams) { 161 phPalEse_Config_t tPalConfig; 162 ESESTATUS wConfigStatus = ESESTATUS_SUCCESS; 163 unsigned long int tpm_enable = 0; 164 char ese_dev_node[64]; 165 std::string ese_node; 166 #ifdef SPM_INTEGRATED 167 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 168 spm_state_t current_spm_state = SPM_STATE_INVALID; 169 #endif 170 171 ALOGE("phNxpEse_open Enter"); 172 /*When spi channel is already opened return status as FAILED*/ 173 if (nxpese_ctxt.EseLibStatus != ESE_STATUS_CLOSE) { 174 ALOGD_IF(ese_debug_enabled, "already opened\n"); 175 return ESESTATUS_BUSY; 176 } 177 178 phNxpEse_memset(&nxpese_ctxt, 0x00, sizeof(nxpese_ctxt)); 179 phNxpEse_memset(&tPalConfig, 0x00, sizeof(tPalConfig)); 180 181 ALOGE("MW SEAccessKit Version"); 182 ALOGE("Android Version:0x%x", NXP_ANDROID_VER); 183 ALOGE("Major Version:0x%x", ESELIB_MW_VERSION_MAJ); 184 ALOGE("Minor Version:0x%x", ESELIB_MW_VERSION_MIN); 185 186 if (EseConfig::hasKey(NAME_NXP_TP_MEASUREMENT)) { 187 tpm_enable = EseConfig::getUnsigned(NAME_NXP_TP_MEASUREMENT); 188 ALOGE( 189 "SPI Throughput measurement enable/disable read from config file - %lu", 190 tpm_enable); 191 } else { 192 ALOGE("SPI Throughput not defined in config file - %lu", tpm_enable); 193 } 194 #ifdef NXP_POWER_SCHEME_SUPPORT 195 unsigned long int num = 0; 196 if (EseConfig::hasKey(NAME_NXP_POWER_SCHEME)) { 197 num = EseConfig::getUnsigned(NAME_NXP_POWER_SCHEME); 198 nxpese_ctxt.pwr_scheme = num; 199 ALOGE("Power scheme read from config file - %lu", num); 200 } else { 201 nxpese_ctxt.pwr_scheme = PN67T_POWER_SCHEME; 202 ALOGE("Power scheme not defined in config file - %lu", num); 203 } 204 #else 205 nxpese_ctxt.pwr_scheme = PN67T_POWER_SCHEME; 206 tpm_enable = 0x00; 207 #endif 208 /* initialize trace level */ 209 phNxpLog_InitializeLogLevel(); 210 211 /*Read device node path*/ 212 ese_node = EseConfig::getString(NAME_NXP_ESE_DEV_NODE, "/dev/pn81a"); 213 strcpy(ese_dev_node, ese_node.c_str()); 214 tPalConfig.pDevName = (int8_t*)ese_dev_node; 215 216 /* Initialize PAL layer */ 217 wConfigStatus = phPalEse_open_and_configure(&tPalConfig); 218 if (wConfigStatus != ESESTATUS_SUCCESS) { 219 ALOGE("phPalEse_Init Failed"); 220 goto clean_and_return; 221 } 222 /* Copying device handle to ESE Lib context*/ 223 nxpese_ctxt.pDevHandle = tPalConfig.pDevHandle; 224 225 #ifdef SPM_INTEGRATED 226 /* Get the Access of ESE*/ 227 wSpmStatus = phNxpEse_SPM_Init(nxpese_ctxt.pDevHandle); 228 if (wSpmStatus != ESESTATUS_SUCCESS) { 229 ALOGE("phNxpEse_SPM_Init Failed"); 230 wConfigStatus = ESESTATUS_FAILED; 231 goto clean_and_return_2; 232 } 233 wSpmStatus = phNxpEse_SPM_SetPwrScheme(nxpese_ctxt.pwr_scheme); 234 if (wSpmStatus != ESESTATUS_SUCCESS) { 235 ALOGE(" %s : phNxpEse_SPM_SetPwrScheme Failed", __FUNCTION__); 236 wConfigStatus = ESESTATUS_FAILED; 237 goto clean_and_return_1; 238 } 239 #ifdef NXP_NFCC_SPI_FW_DOWNLOAD_SYNC 240 wConfigStatus = phNxpEse_checkFWDwnldStatus(); 241 if (wConfigStatus != ESESTATUS_SUCCESS) { 242 ALOGD_IF(ese_debug_enabled, 243 "Failed to open SPI due to VEN pin used by FW download \n"); 244 wConfigStatus = ESESTATUS_FAILED; 245 goto clean_and_return_1; 246 } 247 #endif 248 wSpmStatus = phNxpEse_SPM_GetState(¤t_spm_state); 249 if (wSpmStatus != ESESTATUS_SUCCESS) { 250 ALOGE(" %s : phNxpEse_SPM_GetPwrState Failed", __FUNCTION__); 251 wConfigStatus = ESESTATUS_FAILED; 252 goto clean_and_return_1; 253 } else { 254 if ((current_spm_state & SPM_STATE_SPI) | 255 (current_spm_state & SPM_STATE_SPI_PRIO)) { 256 ALOGE(" %s : SPI is already opened...second instance not allowed", 257 __FUNCTION__); 258 wConfigStatus = ESESTATUS_FAILED; 259 goto clean_and_return_1; 260 } 261 } 262 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 263 if (current_spm_state & SPM_STATE_JCOP_DWNLD) { 264 ALOGE(" %s : Denying to open JCOP Download in progress", __FUNCTION__); 265 wConfigStatus = ESESTATUS_FAILED; 266 goto clean_and_return_1; 267 } 268 #endif 269 phNxpEse_memcpy(&nxpese_ctxt.initParams, &initParams, 270 sizeof(phNxpEse_initParams)); 271 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 272 /* Updating ESE power state based on the init mode */ 273 if (ESE_MODE_OSU == nxpese_ctxt.initParams.initMode) { 274 ALOGE("%s Init mode ---->OSU", __FUNCTION__); 275 wConfigStatus = phNxpEse_checkJcopDwnldState(); 276 if (wConfigStatus != ESESTATUS_SUCCESS) { 277 ALOGE("phNxpEse_checkJcopDwnldState failed"); 278 goto clean_and_return_1; 279 } 280 } 281 #endif 282 wSpmStatus = phNxpEse_SPM_ConfigPwr(SPM_POWER_ENABLE); 283 if (wSpmStatus != ESESTATUS_SUCCESS) { 284 ALOGE("phNxpEse_SPM_ConfigPwr: enabling power Failed"); 285 if (wSpmStatus == ESESTATUS_BUSY) { 286 wConfigStatus = ESESTATUS_BUSY; 287 } else if (wSpmStatus == ESESTATUS_DWNLD_BUSY) { 288 wConfigStatus = ESESTATUS_DWNLD_BUSY; 289 } else { 290 wConfigStatus = ESESTATUS_FAILED; 291 } 292 goto clean_and_return; 293 } else { 294 ALOGD_IF(ese_debug_enabled, "nxpese_ctxt.spm_power_state true"); 295 nxpese_ctxt.spm_power_state = true; 296 } 297 #endif 298 299 ALOGD_IF(ese_debug_enabled, "wConfigStatus %x", wConfigStatus); 300 return wConfigStatus; 301 302 clean_and_return: 303 #ifdef SPM_INTEGRATED 304 wSpmStatus = phNxpEse_SPM_ConfigPwr(SPM_POWER_DISABLE); 305 if (wSpmStatus != ESESTATUS_SUCCESS) { 306 ALOGE("phNxpEse_SPM_ConfigPwr: disabling power Failed"); 307 } 308 clean_and_return_1: 309 phNxpEse_SPM_DeInit(); 310 clean_and_return_2: 311 #endif 312 if (NULL != nxpese_ctxt.pDevHandle) { 313 phPalEse_close(nxpese_ctxt.pDevHandle); 314 phNxpEse_memset(&nxpese_ctxt, 0x00, sizeof(nxpese_ctxt)); 315 } 316 nxpese_ctxt.EseLibStatus = ESE_STATUS_CLOSE; 317 nxpese_ctxt.spm_power_state = false; 318 return ESESTATUS_FAILED; 319 } 320 321 /****************************************************************************** 322 * \ingroup spi_libese 323 * 324 * \brief Check if libese has opened 325 * 326 * \retval return false if it is close, otherwise true. 327 * 328 ******************************************************************************/ 329 bool phNxpEse_isOpen() { return nxpese_ctxt.EseLibStatus != ESE_STATUS_CLOSE; } 330 331 /****************************************************************************** 332 * Function phNxpEse_openPrioSession 333 * 334 * Description This function is called by Jni during the 335 * initialization of the ESE. It opens the physical connection 336 * with ESE () and creates required client thread for 337 * operation. This will get priority access to ESE for timeout 338 duration. 339 340 * Returns This function return ESESTATUS_SUCCES (0) in case of success 341 * In case of failure returns other failure value. 342 * 343 ******************************************************************************/ 344 ESESTATUS phNxpEse_openPrioSession(phNxpEse_initParams initParams) { 345 phPalEse_Config_t tPalConfig; 346 ESESTATUS wConfigStatus = ESESTATUS_SUCCESS; 347 unsigned long int num = 0, tpm_enable = 0; 348 349 ALOGE("phNxpEse_openPrioSession Enter"); 350 #ifdef SPM_INTEGRATED 351 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 352 spm_state_t current_spm_state = SPM_STATE_INVALID; 353 #endif 354 phNxpEse_memset(&nxpese_ctxt, 0x00, sizeof(nxpese_ctxt)); 355 phNxpEse_memset(&tPalConfig, 0x00, sizeof(tPalConfig)); 356 357 ALOGE("MW SEAccessKit Version"); 358 ALOGE("Android Version:0x%x", NXP_ANDROID_VER); 359 ALOGE("Major Version:0x%x", ESELIB_MW_VERSION_MAJ); 360 ALOGE("Minor Version:0x%x", ESELIB_MW_VERSION_MIN); 361 362 #ifdef NXP_POWER_SCHEME_SUPPORT 363 if (EseConfig::hasKey(NAME_NXP_POWER_SCHEME)) { 364 num = EseConfig::getUnsigned(NAME_NXP_POWER_SCHEME); 365 nxpese_ctxt.pwr_scheme = num; 366 ALOGE("Power scheme read from config file - %lu", num); 367 } else 368 #endif 369 { 370 nxpese_ctxt.pwr_scheme = PN67T_POWER_SCHEME; 371 ALOGE("Power scheme not defined in config file - %lu", num); 372 } 373 if (EseConfig::hasKey(NAME_NXP_TP_MEASUREMENT)) { 374 num = EseConfig::getUnsigned(NAME_NXP_TP_MEASUREMENT); 375 ALOGE( 376 "SPI Throughput measurement enable/disable read from config file - %lu", 377 num); 378 } else { 379 ALOGE("SPI Throughput not defined in config file - %lu", num); 380 } 381 /* initialize trace level */ 382 phNxpLog_InitializeLogLevel(); 383 384 tPalConfig.pDevName = (int8_t*)"/dev/p73"; 385 386 /* Initialize PAL layer */ 387 wConfigStatus = phPalEse_open_and_configure(&tPalConfig); 388 if (wConfigStatus != ESESTATUS_SUCCESS) { 389 ALOGE("phPalEse_Init Failed"); 390 goto clean_and_return; 391 } 392 /* Copying device handle to hal context*/ 393 nxpese_ctxt.pDevHandle = tPalConfig.pDevHandle; 394 395 #ifdef SPM_INTEGRATED 396 /* Get the Access of ESE*/ 397 wSpmStatus = phNxpEse_SPM_Init(nxpese_ctxt.pDevHandle); 398 if (wSpmStatus != ESESTATUS_SUCCESS) { 399 ALOGE("phNxpEse_SPM_Init Failed"); 400 wConfigStatus = ESESTATUS_FAILED; 401 goto clean_and_return_2; 402 } 403 wSpmStatus = phNxpEse_SPM_SetPwrScheme(nxpese_ctxt.pwr_scheme); 404 if (wSpmStatus != ESESTATUS_SUCCESS) { 405 ALOGE(" %s : phNxpEse_SPM_SetPwrScheme Failed", __FUNCTION__); 406 wConfigStatus = ESESTATUS_FAILED; 407 goto clean_and_return_1; 408 } 409 wSpmStatus = phNxpEse_SPM_GetState(¤t_spm_state); 410 if (wSpmStatus != ESESTATUS_SUCCESS) { 411 ALOGE(" %s : phNxpEse_SPM_GetPwrState Failed", __FUNCTION__); 412 wConfigStatus = ESESTATUS_FAILED; 413 goto clean_and_return_1; 414 } else { 415 if ((current_spm_state & SPM_STATE_SPI) | 416 (current_spm_state & SPM_STATE_SPI_PRIO)) { 417 ALOGE(" %s : SPI is already opened...second instance not allowed", 418 __FUNCTION__); 419 wConfigStatus = ESESTATUS_FAILED; 420 goto clean_and_return_1; 421 } 422 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 423 if (current_spm_state & SPM_STATE_JCOP_DWNLD) { 424 ALOGE(" %s : Denying to open JCOP Download in progress", __FUNCTION__); 425 wConfigStatus = ESESTATUS_FAILED; 426 goto clean_and_return_1; 427 } 428 #endif 429 #ifdef NXP_NFCC_SPI_FW_DOWNLOAD_SYNC 430 wConfigStatus = phNxpEse_checkFWDwnldStatus(); 431 if (wConfigStatus != ESESTATUS_SUCCESS) { 432 ALOGD_IF(ese_debug_enabled, 433 "Failed to open SPI due to VEN pin used by FW download \n"); 434 wConfigStatus = ESESTATUS_FAILED; 435 goto clean_and_return_1; 436 } 437 #endif 438 } 439 phNxpEse_memcpy(&nxpese_ctxt.initParams, &initParams.initMode, 440 sizeof(phNxpEse_initParams)); 441 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 442 /* Updating ESE power state based on the init mode */ 443 if (ESE_MODE_OSU == nxpese_ctxt.initParams.initMode) { 444 wConfigStatus = phNxpEse_checkJcopDwnldState(); 445 if (wConfigStatus != ESESTATUS_SUCCESS) { 446 ALOGE("phNxpEse_checkJcopDwnldState failed"); 447 goto clean_and_return_1; 448 } 449 } 450 #endif 451 wSpmStatus = phNxpEse_SPM_ConfigPwr(SPM_POWER_PRIO_ENABLE); 452 if (wSpmStatus != ESESTATUS_SUCCESS) { 453 ALOGE("phNxpEse_SPM_ConfigPwr: enabling power for spi prio Failed"); 454 if (wSpmStatus == ESESTATUS_BUSY) { 455 wConfigStatus = ESESTATUS_BUSY; 456 } else if (wSpmStatus == ESESTATUS_DWNLD_BUSY) { 457 wConfigStatus = ESESTATUS_DWNLD_BUSY; 458 } else { 459 wConfigStatus = ESESTATUS_FAILED; 460 } 461 goto clean_and_return; 462 } else { 463 ALOGE("nxpese_ctxt.spm_power_state true"); 464 nxpese_ctxt.spm_power_state = true; 465 } 466 #endif 467 468 #ifndef SPM_INTEGRATED 469 wConfigStatus = 470 phPalEse_ioctl(phPalEse_e_ResetDevice, nxpese_ctxt.pDevHandle, 2); 471 if (wConfigStatus != ESESTATUS_SUCCESS) { 472 ALOGE("phPalEse_IoCtl Failed"); 473 goto clean_and_return; 474 } 475 #endif 476 wConfigStatus = 477 phPalEse_ioctl(phPalEse_e_EnableLog, nxpese_ctxt.pDevHandle, 0); 478 if (wConfigStatus != ESESTATUS_SUCCESS) { 479 ALOGE("phPalEse_IoCtl Failed"); 480 goto clean_and_return; 481 } 482 wConfigStatus = 483 phPalEse_ioctl(phPalEse_e_EnablePollMode, nxpese_ctxt.pDevHandle, 1); 484 if (tpm_enable) { 485 wConfigStatus = phPalEse_ioctl(phPalEse_e_EnableThroughputMeasurement, 486 nxpese_ctxt.pDevHandle, 0); 487 if (wConfigStatus != ESESTATUS_SUCCESS) { 488 ALOGE("phPalEse_IoCtl Failed"); 489 goto clean_and_return; 490 } 491 } 492 if (wConfigStatus != ESESTATUS_SUCCESS) { 493 ALOGE("phPalEse_IoCtl Failed"); 494 goto clean_and_return; 495 } 496 497 ALOGE("wConfigStatus %x", wConfigStatus); 498 499 return wConfigStatus; 500 501 clean_and_return: 502 #ifdef SPM_INTEGRATED 503 wSpmStatus = phNxpEse_SPM_ConfigPwr(SPM_POWER_DISABLE); 504 if (wSpmStatus != ESESTATUS_SUCCESS) { 505 ALOGE("phNxpEse_SPM_ConfigPwr: disabling power Failed"); 506 } 507 clean_and_return_1: 508 phNxpEse_SPM_DeInit(); 509 clean_and_return_2: 510 #endif 511 if (NULL != nxpese_ctxt.pDevHandle) { 512 phPalEse_close(nxpese_ctxt.pDevHandle); 513 phNxpEse_memset(&nxpese_ctxt, 0x00, sizeof(nxpese_ctxt)); 514 } 515 nxpese_ctxt.EseLibStatus = ESE_STATUS_CLOSE; 516 nxpese_ctxt.spm_power_state = false; 517 return ESESTATUS_FAILED; 518 } 519 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 520 /****************************************************************************** 521 * Function phNxpEse_setJcopDwnldState 522 * 523 * Description This function is used to check whether JCOP OS 524 * download can be started or not. 525 * 526 * Returns returns ESESTATUS_SUCCESS or ESESTATUS_FAILED 527 * 528 ******************************************************************************/ 529 static ESESTATUS phNxpEse_setJcopDwnldState(phNxpEse_JcopDwnldState state) { 530 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 531 ESESTATUS wConfigStatus = ESESTATUS_FAILED; 532 ALOGE("phNxpEse_setJcopDwnldState Enter"); 533 534 wSpmStatus = phNxpEse_SPM_SetJcopDwnldState(state); 535 if (wSpmStatus == ESESTATUS_SUCCESS) { 536 wConfigStatus = ESESTATUS_SUCCESS; 537 } 538 539 return wConfigStatus; 540 } 541 542 /****************************************************************************** 543 * Function phNxpEse_checkJcopDwnldState 544 * 545 * Description This function is used to check whether JCOP OS 546 * download can be started or not. 547 * 548 * Returns returns ESESTATUS_SUCCESS or ESESTATUS_BUSY 549 * 550 ******************************************************************************/ 551 static ESESTATUS phNxpEse_checkJcopDwnldState(void) { 552 ALOGE("phNxpEse_checkJcopDwnld Enter"); 553 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 554 spm_state_t current_spm_state = SPM_STATE_INVALID; 555 uint8_t ese_dwnld_retry = 0x00; 556 ESESTATUS status = ESESTATUS_FAILED; 557 558 wSpmStatus = phNxpEse_SPM_GetState(¤t_spm_state); 559 if (wSpmStatus == ESESTATUS_SUCCESS) { 560 /* Check current_spm_state and update config/Spm status*/ 561 if ((current_spm_state & SPM_STATE_JCOP_DWNLD) || 562 (current_spm_state & SPM_STATE_WIRED)) 563 return ESESTATUS_BUSY; 564 565 status = phNxpEse_setJcopDwnldState(JCP_DWNLD_INIT); 566 if (status == ESESTATUS_SUCCESS) { 567 while (ese_dwnld_retry < ESE_JCOP_OS_DWNLD_RETRY_CNT) { 568 ALOGE("ESE_JCOP_OS_DWNLD_RETRY_CNT retry count"); 569 wSpmStatus = phNxpEse_SPM_GetState(¤t_spm_state); 570 if (wSpmStatus == ESESTATUS_SUCCESS) { 571 if ((current_spm_state & SPM_STATE_JCOP_DWNLD)) { 572 status = ESESTATUS_SUCCESS; 573 break; 574 } 575 } else { 576 status = ESESTATUS_FAILED; 577 break; 578 } 579 phNxpEse_Sleep( 580 200000); /*sleep for 200 ms checking for jcop dwnld status*/ 581 ese_dwnld_retry++; 582 } 583 } 584 } 585 586 ALOGE("phNxpEse_checkJcopDwnldState status %x", status); 587 return status; 588 } 589 #endif 590 /****************************************************************************** 591 * Function phNxpEse_Transceive 592 * 593 * Description This function update the len and provided buffer 594 * 595 * Returns On Success ESESTATUS_SUCCESS else proper error code 596 * 597 ******************************************************************************/ 598 ESESTATUS phNxpEse_Transceive(phNxpEse_data* pCmd, phNxpEse_data* pRsp) { 599 ESESTATUS status = ESESTATUS_FAILED; 600 601 if ((NULL == pCmd) || (NULL == pRsp)) return ESESTATUS_INVALID_PARAMETER; 602 603 if ((pCmd->len == 0) || pCmd->p_data == NULL) { 604 ALOGE(" phNxpEse_Transceive - Invalid Parameter no data\n"); 605 return ESESTATUS_INVALID_PARAMETER; 606 } else if ((ESE_STATUS_CLOSE == nxpese_ctxt.EseLibStatus)) { 607 ALOGE(" %s ESE Not Initialized \n", __FUNCTION__); 608 return ESESTATUS_NOT_INITIALISED; 609 } else if ((ESE_STATUS_BUSY == nxpese_ctxt.EseLibStatus)) { 610 ALOGE(" %s ESE - BUSY \n", __FUNCTION__); 611 return ESESTATUS_BUSY; 612 } else { 613 nxpese_ctxt.EseLibStatus = ESE_STATUS_BUSY; 614 status = phNxpEseProto7816_Transceive((phNxpEse_data*)pCmd, 615 (phNxpEse_data*)pRsp); 616 if (ESESTATUS_SUCCESS != status) { 617 ALOGE(" %s phNxpEseProto7816_Transceive- Failed \n", __FUNCTION__); 618 } 619 nxpese_ctxt.EseLibStatus = ESE_STATUS_IDLE; 620 621 ALOGD_IF(ese_debug_enabled, " %s Exit status 0x%x \n", __FUNCTION__, 622 status); 623 return status; 624 } 625 } 626 627 /****************************************************************************** 628 * Function phNxpEse_reset 629 * 630 * Description This function reset the ESE interface and free all 631 * 632 * Returns It returns ESESTATUS_SUCCESS (0) if the operation is 633 *successful else 634 * ESESTATUS_FAILED(1) 635 ******************************************************************************/ 636 ESESTATUS phNxpEse_reset(void) { 637 ESESTATUS status = ESESTATUS_SUCCESS; 638 unsigned long maxTimer = 0; 639 #ifdef SPM_INTEGRATED 640 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 641 #endif 642 643 /* TBD : Call the ioctl to reset the ESE */ 644 ALOGD_IF(ese_debug_enabled, " %s Enter \n", __FUNCTION__); 645 /* Do an interface reset, don't wait to see if JCOP went through a full power 646 * cycle or not */ 647 ESESTATUS bStatus = phNxpEseProto7816_IntfReset( 648 (phNxpEseProto7816SecureTimer_t*)&nxpese_ctxt.secureTimerParams); 649 if (!bStatus) status = ESESTATUS_FAILED; 650 ALOGD_IF(ese_debug_enabled, 651 "%s secureTimer1 0x%x secureTimer2 0x%x secureTimer3 0x%x", 652 __FUNCTION__, nxpese_ctxt.secureTimerParams.secureTimer1, 653 nxpese_ctxt.secureTimerParams.secureTimer2, 654 nxpese_ctxt.secureTimerParams.secureTimer3); 655 phNxpEse_GetMaxTimer(&maxTimer); 656 #ifdef SPM_INTEGRATED 657 #ifdef NXP_SECURE_TIMER_SESSION 658 status = phNxpEse_SPM_DisablePwrControl(maxTimer); 659 if (status != ESESTATUS_SUCCESS) { 660 ALOGE("%s phNxpEse_SPM_DisablePwrControl: failed", __FUNCTION__); 661 } 662 #endif 663 if ((nxpese_ctxt.pwr_scheme == PN67T_POWER_SCHEME) || 664 (nxpese_ctxt.pwr_scheme == PN80T_LEGACY_SCHEME)) { 665 wSpmStatus = phNxpEse_SPM_ConfigPwr(SPM_POWER_RESET); 666 if (wSpmStatus != ESESTATUS_SUCCESS) { 667 ALOGE("phNxpEse_SPM_ConfigPwr: reset Failed"); 668 } 669 } 670 #else 671 /* if arg ==2 (hard reset) 672 * if arg ==1 (soft reset) 673 */ 674 status = phPalEse_ioctl(phPalEse_e_ResetDevice, nxpese_ctxt.pDevHandle, 2); 675 if (status != ESESTATUS_SUCCESS) { 676 ALOGE("phNxpEse_reset Failed"); 677 } 678 #endif 679 ALOGD_IF(ese_debug_enabled, " %s Exit \n", __FUNCTION__); 680 return status; 681 } 682 683 /****************************************************************************** 684 * Function phNxpEse_resetJcopUpdate 685 * 686 * Description This function reset the ESE interface during JCOP Update 687 * 688 * Returns It returns ESESTATUS_SUCCESS (0) if the operation is 689 *successful else 690 * ESESTATUS_FAILED(1) 691 ******************************************************************************/ 692 ESESTATUS phNxpEse_resetJcopUpdate(void) { 693 ESESTATUS status = ESESTATUS_SUCCESS; 694 695 #ifdef SPM_INTEGRATED 696 #ifdef NXP_POWER_SCHEME_SUPPORT 697 unsigned long int num = 0; 698 #endif 699 #endif 700 701 /* TBD : Call the ioctl to reset the */ 702 ALOGD_IF(ese_debug_enabled, " %s Enter \n", __FUNCTION__); 703 704 /* Reset interface after every reset irrespective of 705 whether JCOP did a full power cycle or not. */ 706 status = phNxpEseProto7816_Reset(); 707 708 #ifdef SPM_INTEGRATED 709 #ifdef NXP_POWER_SCHEME_SUPPORT 710 if (EseConfig::hasKey(NAME_NXP_POWER_SCHEME)) { 711 num = EseConfig::getUnsigned(NAME_NXP_POWER_SCHEME); 712 if ((num == 1) || (num == 2)) { 713 ALOGD_IF(ese_debug_enabled, " %s Call Config Pwr Reset \n", __FUNCTION__); 714 status = phNxpEse_SPM_ConfigPwr(SPM_POWER_RESET); 715 if (status != ESESTATUS_SUCCESS) { 716 ALOGE("phNxpEse_resetJcopUpdate: reset Failed"); 717 status = ESESTATUS_FAILED; 718 } 719 } else if (num == 3) { 720 ALOGD_IF(ese_debug_enabled, " %s Call eSE Chip Reset \n", __FUNCTION__); 721 status = phNxpEse_chipReset(); 722 if (status != ESESTATUS_SUCCESS) { 723 ALOGE("phNxpEse_resetJcopUpdate: chip reset Failed"); 724 status = ESESTATUS_FAILED; 725 } 726 } else { 727 ALOGD_IF(ese_debug_enabled, " %s Invalid Power scheme \n", __FUNCTION__); 728 } 729 } 730 #else 731 { 732 status = phNxpEse_SPM_ConfigPwr(SPM_POWER_RESET); 733 if (status != ESESTATUS_SUCCESS) { 734 ALOGE("phNxpEse_SPM_ConfigPwr: reset Failed"); 735 status = ESESTATUS_FAILED; 736 } 737 } 738 #endif 739 #else 740 /* if arg ==2 (hard reset) 741 * if arg ==1 (soft reset) 742 */ 743 status = phPalEse_ioctl(phPalEse_e_ResetDevice, nxpese_ctxt.pDevHandle, 2); 744 if (status != ESESTATUS_SUCCESS) { 745 ALOGE("phNxpEse_resetJcopUpdate Failed"); 746 } 747 #endif 748 749 ALOGD_IF(ese_debug_enabled, " %s Exit \n", __FUNCTION__); 750 return status; 751 } 752 /****************************************************************************** 753 * Function phNxpEse_EndOfApdu 754 * 755 * Description This function is used to send S-frame to indicate 756 *END_OF_APDU 757 * 758 * Returns It returns ESESTATUS_SUCCESS (0) if the operation is 759 *successful else 760 * ESESTATUS_FAILED(1) 761 * 762 ******************************************************************************/ 763 ESESTATUS phNxpEse_EndOfApdu(void) { 764 ESESTATUS status = ESESTATUS_SUCCESS; 765 #ifdef NXP_ESE_END_OF_SESSION 766 status = phNxpEseProto7816_Close( 767 (phNxpEseProto7816SecureTimer_t*)&nxpese_ctxt.secureTimerParams); 768 #endif 769 return status; 770 } 771 772 /****************************************************************************** 773 * Function phNxpEse_chipReset 774 * 775 * Description This function is used to reset the ESE. 776 * 777 * Returns Always return ESESTATUS_SUCCESS (0). 778 * 779 ******************************************************************************/ 780 ESESTATUS phNxpEse_chipReset(void) { 781 ESESTATUS status = ESESTATUS_SUCCESS; 782 ESESTATUS bStatus = ESESTATUS_FAILED; 783 if (nxpese_ctxt.pwr_scheme == PN80T_EXT_PMU_SCHEME) { 784 bStatus = phNxpEseProto7816_Reset(); 785 if (!bStatus) { 786 status = ESESTATUS_FAILED; 787 ALOGE("Inside phNxpEse_chipReset, phNxpEseProto7816_Reset Failed"); 788 } 789 status = phPalEse_ioctl(phPalEse_e_ChipRst, nxpese_ctxt.pDevHandle, 6); 790 if (status != ESESTATUS_SUCCESS) { 791 ALOGE("phNxpEse_chipReset Failed"); 792 } 793 } else { 794 ALOGE("phNxpEse_chipReset is not supported in legacy power scheme"); 795 status = ESESTATUS_FAILED; 796 } 797 return status; 798 } 799 800 /****************************************************************************** 801 * Function phNxpEse_deInit 802 * 803 * Description This function de-initializes all the ESE protocol params 804 * 805 * Returns Always return ESESTATUS_SUCCESS (0). 806 * 807 ******************************************************************************/ 808 ESESTATUS phNxpEse_deInit(void) { 809 ESESTATUS status = ESESTATUS_SUCCESS; 810 unsigned long maxTimer = 0; 811 status = phNxpEseProto7816_Close( 812 (phNxpEseProto7816SecureTimer_t*)&nxpese_ctxt.secureTimerParams); 813 if (status == ESESTATUS_FAILED) { 814 status = ESESTATUS_FAILED; 815 } else { 816 ALOGD_IF(ese_debug_enabled, 817 "%s secureTimer1 0x%x secureTimer2 0x%x secureTimer3 0x%x", 818 __FUNCTION__, nxpese_ctxt.secureTimerParams.secureTimer1, 819 nxpese_ctxt.secureTimerParams.secureTimer2, 820 nxpese_ctxt.secureTimerParams.secureTimer3); 821 phNxpEse_GetMaxTimer(&maxTimer); 822 #ifdef SPM_INTEGRATED 823 #ifdef NXP_SECURE_TIMER_SESSION 824 status = phNxpEse_SPM_DisablePwrControl(maxTimer); 825 if (status != ESESTATUS_SUCCESS) { 826 ALOGE("%s phNxpEseP61_DisablePwrCntrl: failed", __FUNCTION__); 827 } 828 #endif 829 #endif 830 } 831 return status; 832 } 833 834 /****************************************************************************** 835 * Function phNxpEse_close 836 * 837 * Description This function close the ESE interface and free all 838 * resources. 839 * 840 * Returns Always return ESESTATUS_SUCCESS (0). 841 * 842 ******************************************************************************/ 843 ESESTATUS phNxpEse_close(void) { 844 ESESTATUS status = ESESTATUS_SUCCESS; 845 846 if ((ESE_STATUS_CLOSE == nxpese_ctxt.EseLibStatus)) { 847 ALOGE(" %s ESE Not Initialized \n", __FUNCTION__); 848 return ESESTATUS_NOT_INITIALISED; 849 } 850 851 #ifdef SPM_INTEGRATED 852 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 853 #endif 854 855 #ifdef SPM_INTEGRATED 856 /* Release the Access of */ 857 wSpmStatus = phNxpEse_SPM_ConfigPwr(SPM_POWER_DISABLE); 858 if (wSpmStatus != ESESTATUS_SUCCESS) { 859 ALOGE("phNxpEse_SPM_ConfigPwr: disabling power Failed"); 860 } else { 861 nxpese_ctxt.spm_power_state = false; 862 } 863 #ifdef NXP_ESE_JCOP_DWNLD_PROTECTION 864 if (ESE_MODE_OSU == nxpese_ctxt.initParams.initMode) { 865 status = phNxpEse_setJcopDwnldState(JCP_SPI_DWNLD_COMPLETE); 866 if (status != ESESTATUS_SUCCESS) { 867 ALOGE("%s: phNxpEse_setJcopDwnldState failed", __FUNCTION__); 868 } 869 } 870 #endif 871 wSpmStatus = phNxpEse_SPM_DeInit(); 872 if (wSpmStatus != ESESTATUS_SUCCESS) { 873 ALOGE("phNxpEse_SPM_DeInit Failed"); 874 } 875 876 #endif 877 if (NULL != nxpese_ctxt.pDevHandle) { 878 phPalEse_close(nxpese_ctxt.pDevHandle); 879 phNxpEse_memset(&nxpese_ctxt, 0x00, sizeof(nxpese_ctxt)); 880 ALOGD_IF(ese_debug_enabled, 881 "phNxpEse_close - ESE Context deinit completed"); 882 } 883 /* Return success always */ 884 return status; 885 } 886 887 /****************************************************************************** 888 * Function phNxpEse_read 889 * 890 * Description This function write the data to ESE through physical 891 * interface (e.g. I2C) using the driver interface. 892 * Before sending the data to ESE, phNxpEse_write_ext 893 * is called to check if there is any extension processing 894 * is required for the SPI packet being sent out. 895 * 896 * Returns It returns ESESTATUS_SUCCESS (0) if read successful else 897 * ESESTATUS_FAILED(1) 898 * 899 ******************************************************************************/ 900 ESESTATUS phNxpEse_read(uint32_t* data_len, uint8_t** pp_data) { 901 ESESTATUS status = ESESTATUS_SUCCESS; 902 int ret = -1; 903 904 ALOGD_IF(ese_debug_enabled, "%s Enter ..", __FUNCTION__); 905 906 ret = phNxpEse_readPacket(nxpese_ctxt.pDevHandle, nxpese_ctxt.p_read_buff, 907 MAX_DATA_LEN); 908 if (ret < 0) { 909 ALOGE("PAL Read status error status = %x", status); 910 *data_len = 2; 911 *pp_data = nxpese_ctxt.p_read_buff; 912 status = ESESTATUS_FAILED; 913 } else { 914 PH_PAL_ESE_PRINT_PACKET_RX(nxpese_ctxt.p_read_buff, ret); 915 *data_len = ret; 916 *pp_data = nxpese_ctxt.p_read_buff; 917 status = ESESTATUS_SUCCESS; 918 } 919 920 ALOGD_IF(ese_debug_enabled, "%s Exit", __FUNCTION__); 921 return status; 922 } 923 924 /****************************************************************************** 925 * Function phNxpEse_readPacket 926 * 927 * Description This function Reads requested number of bytes from 928 * pn547 device into given buffer. 929 * 930 * Returns nNbBytesToRead- number of successfully read bytes 931 * -1 - read operation failure 932 * 933 ******************************************************************************/ 934 static int phNxpEse_readPacket(void* pDevHandle, uint8_t* pBuffer, 935 int nNbBytesToRead) { 936 int ret = -1; 937 int sof_counter = 0; /* one read may take 1 ms*/ 938 int total_count = 0, numBytesToRead = 0, headerIndex = 0; 939 940 ALOGD_IF(ese_debug_enabled, "%s Enter", __FUNCTION__); 941 do { 942 sof_counter++; 943 ret = -1; 944 ret = phPalEse_read(pDevHandle, pBuffer, 2); 945 if (ret < 0) { 946 /*Polling for read on spi, hence Debug log*/ 947 ALOGD_IF(ese_debug_enabled, "_spi_read() [HDR]errno : %x ret : %X", errno, 948 ret); 949 } 950 if (pBuffer[0] == RECIEVE_PACKET_SOF) { 951 /* Read the HEADR of one byte*/ 952 ALOGD_IF(ese_debug_enabled, "%s Read HDR", __FUNCTION__); 953 numBytesToRead = 1; 954 headerIndex = 1; 955 break; 956 } else if (pBuffer[1] == RECIEVE_PACKET_SOF) { 957 /* Read the HEADR of Two bytes*/ 958 ALOGD_IF(ese_debug_enabled, "%s Read HDR", __FUNCTION__); 959 pBuffer[0] = RECIEVE_PACKET_SOF; 960 numBytesToRead = 2; 961 headerIndex = 0; 962 break; 963 } 964 ALOGD_IF(ese_debug_enabled, "%s Normal Pkt, delay read %dus", __FUNCTION__, 965 READ_WAKE_UP_DELAY * NAD_POLLING_SCALER); 966 phPalEse_sleep(READ_WAKE_UP_DELAY * NAD_POLLING_SCALER); 967 } while (sof_counter < ESE_NAD_POLLING_MAX); 968 if (pBuffer[0] == RECIEVE_PACKET_SOF) { 969 ALOGD_IF(ese_debug_enabled, "%s SOF FOUND", __FUNCTION__); 970 /* Read the HEADR of one/Two bytes based on how two bytes read A5 PCB or 00 971 * A5*/ 972 ret = phPalEse_read(pDevHandle, &pBuffer[1 + headerIndex], numBytesToRead); 973 if (ret < 0) { 974 ALOGE("_spi_read() [HDR]errno : %x ret : %X", errno, ret); 975 } 976 total_count = 3; 977 nNbBytesToRead = pBuffer[2]; 978 /* Read the Complete data + one byte CRC*/ 979 ret = phPalEse_read(pDevHandle, &pBuffer[3], (nNbBytesToRead + 1)); 980 if (ret < 0) { 981 ALOGE("_spi_read() [HDR]errno : %x ret : %X", errno, ret); 982 ret = -1; 983 } else { 984 ret = (total_count + (nNbBytesToRead + 1)); 985 } 986 } else if (ret < 0) { 987 /*In case of IO Error*/ 988 ret = -2; 989 pBuffer[0] = 0x64; 990 pBuffer[1] = 0xFF; 991 } else { 992 ret = -1; 993 } 994 ALOGD_IF(ese_debug_enabled, "%s Exit ret = %d", __FUNCTION__, ret); 995 return ret; 996 } 997 /****************************************************************************** 998 * Function phNxpEse_WriteFrame 999 * 1000 * Description This is the actual function which is being called by 1001 * phNxpEse_write. This function writes the data to ESE. 1002 * It waits till write callback provide the result of write 1003 * process. 1004 * 1005 * Returns It returns ESESTATUS_SUCCESS (0) if write successful else 1006 * ESESTATUS_FAILED(1) 1007 * 1008 ******************************************************************************/ 1009 ESESTATUS phNxpEse_WriteFrame(uint32_t data_len, const uint8_t* p_data) { 1010 ESESTATUS status = ESESTATUS_INVALID_PARAMETER; 1011 int32_t dwNoBytesWrRd = 0; 1012 ALOGD_IF(ese_debug_enabled, "Enter %s ", __FUNCTION__); 1013 1014 /* Create local copy of cmd_data */ 1015 phNxpEse_memcpy(nxpese_ctxt.p_cmd_data, p_data, data_len); 1016 nxpese_ctxt.cmd_len = data_len; 1017 1018 dwNoBytesWrRd = phPalEse_write(nxpese_ctxt.pDevHandle, nxpese_ctxt.p_cmd_data, 1019 nxpese_ctxt.cmd_len); 1020 if (-1 == dwNoBytesWrRd) { 1021 ALOGE(" - Error in SPI Write.....\n"); 1022 status = ESESTATUS_FAILED; 1023 } else { 1024 status = ESESTATUS_SUCCESS; 1025 PH_PAL_ESE_PRINT_PACKET_TX(nxpese_ctxt.p_cmd_data, nxpese_ctxt.cmd_len); 1026 } 1027 1028 ALOGD_IF(ese_debug_enabled, "Exit %s status %x\n", __FUNCTION__, status); 1029 return status; 1030 } 1031 1032 /****************************************************************************** 1033 * Function phNxpEse_setIfsc 1034 * 1035 * Description This function sets the IFSC size to 240/254 support JCOP OS 1036 *Update. 1037 * 1038 * Returns Always return ESESTATUS_SUCCESS (0). 1039 * 1040 ******************************************************************************/ 1041 ESESTATUS phNxpEse_setIfsc(uint16_t IFSC_Size) { 1042 /*SET the IFSC size to 240 bytes*/ 1043 phNxpEseProto7816_SetIfscSize(IFSC_Size); 1044 return ESESTATUS_SUCCESS; 1045 } 1046 1047 /****************************************************************************** 1048 * Function phNxpEse_Sleep 1049 * 1050 * Description This function suspends execution of the calling thread for 1051 * (at least) usec microseconds 1052 * 1053 * Returns Always return ESESTATUS_SUCCESS (0). 1054 * 1055 ******************************************************************************/ 1056 ESESTATUS phNxpEse_Sleep(uint32_t usec) { 1057 phPalEse_sleep(usec); 1058 return ESESTATUS_SUCCESS; 1059 } 1060 1061 /****************************************************************************** 1062 * Function phNxpEse_memset 1063 * 1064 * Description This function updates destination buffer with val 1065 * data in len size 1066 * 1067 * Returns Always return ESESTATUS_SUCCESS (0). 1068 * 1069 ******************************************************************************/ 1070 void* phNxpEse_memset(void* buff, int val, size_t len) { 1071 return phPalEse_memset(buff, val, len); 1072 } 1073 1074 /****************************************************************************** 1075 * Function phNxpEse_memcpy 1076 * 1077 * Description This function copies source buffer to destination buffer 1078 * data in len size 1079 * 1080 * Returns Return pointer to allocated memory location. 1081 * 1082 ******************************************************************************/ 1083 void* phNxpEse_memcpy(void* dest, const void* src, size_t len) { 1084 return phPalEse_memcpy(dest, src, len); 1085 } 1086 1087 /****************************************************************************** 1088 * Function phNxpEse_Memalloc 1089 * 1090 * Description This function allocation memory 1091 * 1092 * Returns Return pointer to allocated memory or NULL. 1093 * 1094 ******************************************************************************/ 1095 void* phNxpEse_memalloc(uint32_t size) { 1096 return phPalEse_memalloc(size); 1097 ; 1098 } 1099 1100 /****************************************************************************** 1101 * Function phNxpEse_calloc 1102 * 1103 * Description This is utility function for runtime heap memory allocation 1104 * 1105 * Returns Return pointer to allocated memory or NULL. 1106 * 1107 ******************************************************************************/ 1108 void* phNxpEse_calloc(size_t datatype, size_t size) { 1109 return phPalEse_calloc(datatype, size); 1110 } 1111 1112 /****************************************************************************** 1113 * Function phNxpEse_free 1114 * 1115 * Description This function de-allocation memory 1116 * 1117 * Returns void. 1118 * 1119 ******************************************************************************/ 1120 void phNxpEse_free(void* ptr) { 1121 if (ptr != NULL) { 1122 free(ptr); 1123 ptr = NULL; 1124 } 1125 return; 1126 } 1127 1128 /****************************************************************************** 1129 * Function phNxpEse_GetMaxTimer 1130 * 1131 * Description This function finds out the max. timer value returned from 1132 *JCOP 1133 * 1134 * Returns void. 1135 * 1136 ******************************************************************************/ 1137 static void phNxpEse_GetMaxTimer(unsigned long* pMaxTimer) { 1138 /* Finding the max. of the timer value */ 1139 *pMaxTimer = nxpese_ctxt.secureTimerParams.secureTimer1; 1140 if (*pMaxTimer < nxpese_ctxt.secureTimerParams.secureTimer2) 1141 *pMaxTimer = nxpese_ctxt.secureTimerParams.secureTimer2; 1142 *pMaxTimer = (*pMaxTimer < nxpese_ctxt.secureTimerParams.secureTimer3) 1143 ? (nxpese_ctxt.secureTimerParams.secureTimer3) 1144 : *pMaxTimer; 1145 1146 /* Converting timer to millisecond from sec */ 1147 *pMaxTimer = SECOND_TO_MILLISECOND(*pMaxTimer); 1148 /* Add extra 5% to the timer */ 1149 *pMaxTimer += 1150 CONVERT_TO_PERCENTAGE(*pMaxTimer, ADDITIONAL_SECURE_TIME_PERCENTAGE); 1151 ALOGE("%s Max timer value = %lu", __FUNCTION__, *pMaxTimer); 1152 return; 1153 } 1154 1155 /****************************************************************************** 1156 * Function phNxpEseP61_DisablePwrCntrl 1157 * 1158 * Description This function disables eSE GPIO power off/on control 1159 * when enabled 1160 * 1161 * Returns SUCCESS/FAIL. 1162 * 1163 ******************************************************************************/ 1164 ESESTATUS phNxpEse_DisablePwrCntrl(void) { 1165 ESESTATUS status = ESESTATUS_SUCCESS; 1166 unsigned long maxTimer = 0; 1167 ALOGE("%s Enter", __FUNCTION__); 1168 phNxpEse_GetMaxTimer(&maxTimer); 1169 #ifdef NXP_SECURE_TIMER_SESSION 1170 status = phNxpEse_SPM_DisablePwrControl(maxTimer); 1171 if (status != ESESTATUS_SUCCESS) { 1172 ALOGE("%s phNxpEseP61_DisablePwrCntrl: failed", __FUNCTION__); 1173 } 1174 #else 1175 ALOGE("%s phNxpEseP61_DisablePwrCntrl: not supported", __FUNCTION__); 1176 status = ESESTATUS_FAILED; 1177 #endif 1178 return status; 1179 } 1180 1181 #ifdef NXP_NFCC_SPI_FW_DOWNLOAD_SYNC 1182 /****************************************************************************** 1183 * Function phNxpEse_checkFWDwnldStatus 1184 * 1185 * Description This function is used to check whether FW download 1186 * is completed or not. 1187 * 1188 * Returns returns ESESTATUS_SUCCESS or ESESTATUS_BUSY 1189 * 1190 ******************************************************************************/ 1191 static ESESTATUS phNxpEse_checkFWDwnldStatus(void) { 1192 ALOGE("phNxpEse_checkFWDwnldStatus Enter"); 1193 ESESTATUS wSpmStatus = ESESTATUS_SUCCESS; 1194 spm_state_t current_spm_state = SPM_STATE_INVALID; 1195 uint8_t ese_dwnld_retry = 0x00; 1196 ESESTATUS status = ESESTATUS_FAILED; 1197 1198 wSpmStatus = phNxpEse_SPM_GetState(¤t_spm_state); 1199 if (wSpmStatus == ESESTATUS_SUCCESS) { 1200 /* Check current_spm_state and update config/Spm status*/ 1201 while (ese_dwnld_retry < ESE_FW_DWNLD_RETRY_CNT) { 1202 ALOGE("ESE_FW_DWNLD_RETRY_CNT retry count"); 1203 wSpmStatus = phNxpEse_SPM_GetState(¤t_spm_state); 1204 if (wSpmStatus == ESESTATUS_SUCCESS) { 1205 if ((current_spm_state & SPM_STATE_DWNLD)) { 1206 status = ESESTATUS_FAILED; 1207 } else { 1208 ALOGE("Exit polling no FW Download .."); 1209 status = ESESTATUS_SUCCESS; 1210 break; 1211 } 1212 } else { 1213 status = ESESTATUS_FAILED; 1214 break; 1215 } 1216 phNxpEse_Sleep(500000); /*sleep for 500 ms checking for fw dwnld status*/ 1217 ese_dwnld_retry++; 1218 } 1219 } 1220 1221 ALOGE("phNxpEse_checkFWDwnldStatus status %x", status); 1222 return status; 1223 } 1224 #endif 1225 /****************************************************************************** 1226 * Function phNxpEse_GetEseStatus(unsigned char *timer_buffer) 1227 * 1228 * Description This function returns the all three timer 1229 * Timeout buffer length should be minimum 18 bytes. Response will be in below 1230 format: 1231 * <0xF1><Len><Timer Value><0xF2><Len><Timer Value><0xF3><Len><Timer Value> 1232 * 1233 * Returns SUCCESS/FAIL. 1234 * ESESTATUS_SUCCESS if 0xF1 or 0xF2 tag timeout >= 0 & 0xF3 == 0 1235 * ESESTATUS_BUSY if 0xF3 tag timeout > 0 1236 * ESESTATUS_FAILED if any other error 1237 1238 ******************************************************************************/ 1239 ESESTATUS phNxpEse_GetEseStatus(phNxpEse_data* timer_buffer) { 1240 ESESTATUS status = ESESTATUS_FAILED; 1241 1242 phNxpEse_SecureTimer_t secureTimerParams; 1243 uint8_t* temp_timer_buffer = NULL; 1244 ALOGD_IF(ese_debug_enabled, "%s Enter", __FUNCTION__); 1245 1246 if (timer_buffer != NULL) { 1247 timer_buffer->len = 1248 (sizeof(secureTimerParams.secureTimer1) + 1249 sizeof(secureTimerParams.secureTimer2) + 1250 sizeof(secureTimerParams.secureTimer3)) + 1251 PH_PROPTO_7816_FRAME_LENGTH_OFFSET * PH_PROPTO_7816_FRAME_LENGTH_OFFSET; 1252 temp_timer_buffer = (uint8_t*)phNxpEse_memalloc(timer_buffer->len); 1253 timer_buffer->p_data = temp_timer_buffer; 1254 1255 #ifdef NXP_SECURE_TIMER_SESSION 1256 phNxpEse_memcpy(&secureTimerParams, &nxpese_ctxt.secureTimerParams, 1257 sizeof(phNxpEse_SecureTimer_t)); 1258 1259 ALOGD_IF( 1260 ese_debug_enabled, 1261 "%s secureTimer1 0x%x secureTimer2 0x%x secureTimer3 0x%x len = %d", 1262 __FUNCTION__, secureTimerParams.secureTimer1, 1263 secureTimerParams.secureTimer2, secureTimerParams.secureTimer3, 1264 timer_buffer->len); 1265 1266 *temp_timer_buffer++ = PH_PROPTO_7816_SFRAME_TIMER1; 1267 *temp_timer_buffer++ = sizeof(secureTimerParams.secureTimer1); 1268 temp_timer_buffer = phNxpEse_GgetTimerTlvBuffer( 1269 temp_timer_buffer, secureTimerParams.secureTimer1); 1270 if (temp_timer_buffer != NULL) { 1271 *temp_timer_buffer++ = PH_PROPTO_7816_SFRAME_TIMER2; 1272 *temp_timer_buffer++ = sizeof(secureTimerParams.secureTimer2); 1273 temp_timer_buffer = phNxpEse_GgetTimerTlvBuffer( 1274 temp_timer_buffer, secureTimerParams.secureTimer2); 1275 if (temp_timer_buffer != NULL) { 1276 *temp_timer_buffer++ = PH_PROPTO_7816_SFRAME_TIMER3; 1277 *temp_timer_buffer++ = sizeof(secureTimerParams.secureTimer3); 1278 temp_timer_buffer = phNxpEse_GgetTimerTlvBuffer( 1279 temp_timer_buffer, secureTimerParams.secureTimer3); 1280 if (temp_timer_buffer != NULL) { 1281 if (secureTimerParams.secureTimer3 > 0) { 1282 status = ESESTATUS_BUSY; 1283 } else { 1284 status = ESESTATUS_SUCCESS; 1285 } 1286 } 1287 } 1288 } 1289 #endif 1290 } else { 1291 ALOGE("%s Invalid timer buffer ", __FUNCTION__); 1292 } 1293 1294 ALOGD_IF(ese_debug_enabled, "%s Exit status = 0x%x", __FUNCTION__, status); 1295 return status; 1296 } 1297 #ifdef NXP_SECURE_TIMER_SESSION 1298 static unsigned char* phNxpEse_GgetTimerTlvBuffer(uint8_t* timer_buffer, 1299 unsigned int value) { 1300 short int count = 0, shift = 3; 1301 unsigned int mask = 0x000000FF; 1302 ALOGD_IF(ese_debug_enabled, "value = %x \n", value); 1303 for (count = 0; count < 4; count++) { 1304 if (timer_buffer != NULL) { 1305 *timer_buffer = (value >> (shift * 8) & mask); 1306 ALOGD_IF(ese_debug_enabled, "*timer_buffer=0x%x shift=0x%x", 1307 *timer_buffer, shift); 1308 timer_buffer++; 1309 shift--; 1310 } else { 1311 break; 1312 } 1313 } 1314 return timer_buffer; 1315 } 1316 #endif 1317
