1 /******************************************************************************
2 *
3 * Copyright (C) 2017 ST Microelectronics S.A.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *
18 ******************************************************************************/
19 #define LOG_TAG "NfcNciHalWrapper"
20 #include <cutils/properties.h>
21 #include <errno.h>
22 #include <hardware/nfc.h>
23 #include <log/log.h>
24 #include <string.h>
25 #include <unistd.h>
26
27 #include "android_logmsg.h"
28 #include "hal_fd.h"
29 #include "hal_fwlog.h"
30 #include "halcore.h"
31 #include "st21nfc_dev.h"
32
33 extern void HalCoreCallback(void* context, uint32_t event, const void* d,
34 size_t length);
35 extern bool I2cOpenLayer(void* dev, HAL_CALLBACK callb, HALHANDLE* pHandle);
36 extern void I2cCloseLayer();
37 extern void I2cRecovery();
38
39 static void halWrapperDataCallback(uint16_t data_len, uint8_t* p_data);
40 static void halWrapperCallback(uint8_t event, uint8_t event_status);
41
42 nfc_stack_callback_t* mHalWrapperCallback = NULL;
43 nfc_stack_data_callback_t* mHalWrapperDataCallback = NULL;
44 hal_wrapper_state_e mHalWrapperState = HAL_WRAPPER_STATE_CLOSED;
45 HALHANDLE mHalHandle = NULL;
46
47 uint8_t mClfMode;
48 uint8_t mFwUpdateTaskMask;
49 int mRetryFwDwl;
50 uint8_t mFwUpdateResMask = 0;
51 uint8_t* ConfigBuffer = NULL;
52 uint8_t mError_count = 0;
53 bool mIsActiveRW = false;
54 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
55 pthread_mutex_t mutex_activerw = PTHREAD_MUTEX_INITIALIZER;
56 pthread_cond_t ready_cond = PTHREAD_COND_INITIALIZER;
57
58 static const uint8_t ApduGetAtr[] = {0x2F, 0x04, 0x05, 0x80,
59 0x8A, 0x00, 0x00, 0x04};
60
61 static const uint8_t nciHeaderPropSetConfig[9] = {0x2F, 0x02, 0x98, 0x04, 0x00,
62 0x14, 0x01, 0x00, 0x92};
63 static uint8_t nciPropEnableFwDbgTraces[256];
64 static uint8_t nciPropGetFwDbgTracesConfig[] = {0x2F, 0x02, 0x05, 0x03,
65 0x00, 0x14, 0x01, 0x00};
66 static uint8_t nciAndroidPassiveObserver[256];
67 static bool isDebuggable;
68
69 bool mReadFwConfigDone = false;
70
71 bool mHciCreditLent = false;
72 bool mfactoryReset = false;
73 bool ready_flag = 0;
74 bool mTimerStarted = false;
75 bool mFieldInfoTimerStarted = false;
76 bool forceRecover = false;
77 unsigned long hal_field_timer = 0;
78
79 static bool sEnableFwLog = false;
80 uint8_t mObserverMode = 0;
81 bool mObserverRsp = false;
82
wait_ready()83 void wait_ready() {
84 pthread_mutex_lock(&mutex);
85 while (!ready_flag) {
86 pthread_cond_wait(&ready_cond, &mutex);
87 }
88 pthread_mutex_unlock(&mutex);
89 }
90
set_ready(bool ready)91 void set_ready(bool ready) {
92 pthread_mutex_lock(&mutex);
93 ready_flag = ready;
94 pthread_cond_signal(&ready_cond);
95 pthread_mutex_unlock(&mutex);
96 }
97
hal_wrapper_open(st21nfc_dev_t * dev,nfc_stack_callback_t * p_cback,nfc_stack_data_callback_t * p_data_cback,HALHANDLE * pHandle)98 bool hal_wrapper_open(st21nfc_dev_t* dev, nfc_stack_callback_t* p_cback,
99 nfc_stack_data_callback_t* p_data_cback,
100 HALHANDLE* pHandle) {
101 bool result;
102
103 STLOG_HAL_D("%s", __func__);
104
105 mFwUpdateResMask = hal_fd_init();
106 mRetryFwDwl = 5;
107 mFwUpdateTaskMask = 0;
108
109 mHalWrapperState = HAL_WRAPPER_STATE_OPEN;
110 mHciCreditLent = false;
111 mReadFwConfigDone = false;
112 mError_count = 0;
113
114 mObserverMode = 0;
115 mObserverRsp = false;
116
117 mHalWrapperCallback = p_cback;
118 mHalWrapperDataCallback = p_data_cback;
119
120 dev->p_data_cback = halWrapperDataCallback;
121 dev->p_cback = halWrapperCallback;
122
123 result = I2cOpenLayer(dev, HalCoreCallback, pHandle);
124
125 if (!result || !(*pHandle)) {
126 return -1; // We are doomed, stop it here, NOW !
127 }
128
129 isDebuggable = property_get_int32("ro.debuggable", 0);
130 mHalHandle = *pHandle;
131
132 HalSendDownstreamTimer(mHalHandle, 10000);
133
134 return 1;
135 }
136
hal_wrapper_close(int call_cb,int nfc_mode)137 int hal_wrapper_close(int call_cb, int nfc_mode) {
138 STLOG_HAL_V("%s - Sending PROP_NFC_MODE_SET_CMD(%d)", __func__, nfc_mode);
139 uint8_t propNfcModeSetCmdQb[] = {0x2f, 0x02, 0x02, 0x02, (uint8_t)nfc_mode};
140
141 mHalWrapperState = HAL_WRAPPER_STATE_CLOSING;
142 // Send PROP_NFC_MODE_SET_CMD
143 if (!HalSendDownstreamTimer(mHalHandle, propNfcModeSetCmdQb,
144 sizeof(propNfcModeSetCmdQb), 100)) {
145 STLOG_HAL_E("NFC-NCI HAL: %s HalSendDownstreamTimer failed", __func__);
146 return -1;
147 }
148 // Let the CLF receive and process this
149 usleep(50000);
150
151 I2cCloseLayer();
152 if (call_cb) mHalWrapperCallback(HAL_NFC_CLOSE_CPLT_EVT, HAL_NFC_STATUS_OK);
153
154 return 1;
155 }
156
hal_wrapper_send_core_config_prop()157 void hal_wrapper_send_core_config_prop() {
158 long retlen = 0;
159 int isfound = 0;
160
161 // allocate buffer for setting parameters
162 ConfigBuffer = (uint8_t*)malloc(256 * sizeof(uint8_t));
163 if (ConfigBuffer != NULL) {
164 isfound = GetByteArrayValue(NAME_CORE_CONF_PROP, (char*)ConfigBuffer, 256,
165 &retlen);
166
167 if (isfound > 0) {
168 STLOG_HAL_V("%s - Enter", __func__);
169 set_ready(0);
170
171 if (!HalSendDownstreamTimer(mHalHandle, ConfigBuffer, retlen, 1000)) {
172 STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__);
173 }
174 wait_ready();
175 }
176 free(ConfigBuffer);
177 ConfigBuffer = NULL;
178 }
179 }
180
hal_wrapper_send_vs_config()181 void hal_wrapper_send_vs_config() {
182 STLOG_HAL_V("%s - Enter", __func__);
183 set_ready(0);
184 mHalWrapperState = HAL_WRAPPER_STATE_PROP_CONFIG;
185 mReadFwConfigDone = true;
186 if (!HalSendDownstreamTimer(mHalHandle, nciPropGetFwDbgTracesConfig,
187 sizeof(nciPropGetFwDbgTracesConfig), 1000)) {
188 STLOG_HAL_E("%s - SendDownstream failed", __func__);
189 }
190 wait_ready();
191 }
192
hal_wrapper_send_config()193 void hal_wrapper_send_config() {
194 hal_wrapper_send_vs_config();
195 mHalWrapperState = HAL_WRAPPER_STATE_PROP_CONFIG;
196 hal_wrapper_send_core_config_prop();
197 }
198
hal_wrapper_factoryReset()199 void hal_wrapper_factoryReset() {
200 mfactoryReset = true;
201 STLOG_HAL_V("%s - mfactoryReset = %d", __func__, mfactoryReset);
202 }
203
hal_wrapper_set_observer_mode(uint8_t enable)204 void hal_wrapper_set_observer_mode(uint8_t enable) {
205 mObserverMode = enable;
206 mObserverRsp = true;
207 }
hal_wrapper_get_observer_mode()208 void hal_wrapper_get_observer_mode() { mObserverRsp = true; }
209
hal_wrapper_update_complete()210 void hal_wrapper_update_complete() {
211 STLOG_HAL_V("%s ", __func__);
212 mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_OK);
213 mHalWrapperState = HAL_WRAPPER_STATE_OPEN_CPLT;
214 }
halWrapperDataCallback(uint16_t data_len,uint8_t * p_data)215 void halWrapperDataCallback(uint16_t data_len, uint8_t* p_data) {
216 uint8_t propNfcModeSetCmdOn[] = {0x2f, 0x02, 0x02, 0x02, 0x01};
217 uint8_t coreInitCmd[] = {0x20, 0x01, 0x02, 0x00, 0x00};
218 uint8_t coreResetCmd[] = {0x20, 0x00, 0x01, 0x01};
219 unsigned long num = 0;
220 unsigned long swp_log = 0;
221 unsigned long rf_log = 0;
222 int mObserverLength = 0;
223 int nciPropEnableFwDbgTraces_size = sizeof(nciPropEnableFwDbgTraces);
224
225 if (mObserverMode && (p_data[0] == 0x6f) && (p_data[1] == 0x02)) {
226 // Firmware logs must not be formatted before sending to upper layer.
227 if ((mObserverLength = notifyPollingLoopFrames(
228 p_data, data_len, nciAndroidPassiveObserver)) > 0) {
229 DispHal("RX DATA", (nciAndroidPassiveObserver), mObserverLength);
230 mHalWrapperDataCallback(mObserverLength, nciAndroidPassiveObserver);
231 }
232 }
233 if ((p_data[0] == 0x4f) && (p_data[1] == 0x0c)) {
234 DispHal("RX DATA", (p_data), data_len);
235 }
236
237 switch (mHalWrapperState) {
238 case HAL_WRAPPER_STATE_CLOSED: // 0
239 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_CLOSED", __func__);
240 break;
241 case HAL_WRAPPER_STATE_OPEN: // 1
242 // CORE_RESET_NTF
243 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_OPEN", __func__);
244
245 if ((p_data[0] == 0x60) && (p_data[1] == 0x00)) {
246 mIsActiveRW = false;
247 mFwUpdateTaskMask = ft_cmd_HwReset(p_data, &mClfMode);
248
249 if (mfactoryReset == true) {
250 STLOG_HAL_V(
251 "%s - first boot after factory reset detected - start FW update",
252 __func__);
253 if ((mFwUpdateResMask & FW_PATCH_AVAILABLE) &&
254 (mFwUpdateResMask & FW_CUSTOM_PARAM_AVAILABLE)) {
255 mFwUpdateTaskMask = FW_UPDATE_NEEDED | CONF_UPDATE_NEEDED;
256 mfactoryReset = false;
257 }
258 }
259 STLOG_HAL_V(
260 "%s - mFwUpdateTaskMask = %d, mClfMode = %d, mRetryFwDwl = %d",
261 __func__, mFwUpdateTaskMask, mClfMode, mRetryFwDwl);
262 // CLF in MODE LOADER & Update needed.
263 if (mClfMode == FT_CLF_MODE_LOADER) {
264 HalSendDownstreamStopTimer(mHalHandle);
265 STLOG_HAL_V("%s --- CLF mode is LOADER ---", __func__);
266
267 if (mRetryFwDwl == 0) {
268 STLOG_HAL_V(
269 "%s - Reached maximum nb of retries, FW update failed, exiting",
270 __func__);
271 mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_FAILED);
272 I2cCloseLayer();
273 } else {
274 mHalWrapperState = HAL_WRAPPER_STATE_UPDATE;
275 if (((p_data[3] == 0x01) && (p_data[8] == HW_ST54L)) ||
276 ((p_data[2] == 0x41) && (p_data[3] == 0xA2))) { // ST54L
277 FwUpdateHandler(mHalHandle, data_len, p_data);
278 } else {
279 STLOG_HAL_V("%s - Send APDU_GET_ATR_CMD", __func__);
280 mRetryFwDwl--;
281 if (!HalSendDownstreamTimer(mHalHandle, ApduGetAtr,
282 sizeof(ApduGetAtr),
283 FW_TIMER_DURATION)) {
284 STLOG_HAL_E("%s - SendDownstream failed", __func__);
285 }
286 }
287 }
288 } else if (mFwUpdateTaskMask == 0 || mRetryFwDwl == 0) {
289 STLOG_HAL_V("%s - Proceeding with normal startup", __func__);
290 if (p_data[3] == 0x01) {
291 // Normal mode, start HAL
292 mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_OK);
293 mHalWrapperState = HAL_WRAPPER_STATE_OPEN_CPLT;
294 } else {
295 // No more retries or CLF not in correct mode
296 mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_FAILED);
297 }
298 // CLF in MODE ROUTER & Update needed.
299 } else if (mClfMode == FT_CLF_MODE_ROUTER) {
300 if ((mFwUpdateTaskMask & FW_UPDATE_NEEDED) &&
301 (mFwUpdateResMask & FW_PATCH_AVAILABLE)) {
302 STLOG_HAL_V(
303 "%s - CLF in ROUTER mode, FW update needed, try upgrade FW -",
304 __func__);
305 mRetryFwDwl--;
306
307 if (!HalSendDownstream(mHalHandle, coreResetCmd,
308 sizeof(coreResetCmd))) {
309 STLOG_HAL_E("%s - SendDownstream failed", __func__);
310 }
311 mHalWrapperState = HAL_WRAPPER_STATE_EXIT_HIBERNATE_INTERNAL;
312 } else if ((mFwUpdateTaskMask & CONF_UPDATE_NEEDED) &&
313 (mFwUpdateResMask & FW_CUSTOM_PARAM_AVAILABLE)) {
314 if (!HalSendDownstream(mHalHandle, coreResetCmd,
315 sizeof(coreResetCmd))) {
316 STLOG_HAL_E("%s - SendDownstream failed", __func__);
317 }
318 mHalWrapperState = HAL_WRAPPER_STATE_APPLY_CUSTOM_PARAM;
319 } else if ((mFwUpdateTaskMask & UWB_CONF_UPDATE_NEEDED) &&
320 (mFwUpdateResMask & FW_UWB_PARAM_AVAILABLE)) {
321 if (!HalSendDownstream(mHalHandle, coreResetCmd,
322 sizeof(coreResetCmd))) {
323 STLOG_HAL_E("%s - SendDownstream failed", __func__);
324 }
325 mHalWrapperState = HAL_WRAPPER_STATE_APPLY_UWB_PARAM;
326 }
327 }
328 } else {
329 mHalWrapperDataCallback(data_len, p_data);
330 }
331 break;
332 case HAL_WRAPPER_STATE_OPEN_CPLT: // 2
333 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_OPEN_CPLT",
334 __func__);
335 // CORE_INIT_RSP
336 if ((p_data[0] == 0x40) && (p_data[1] == 0x01)) {
337 } else if ((p_data[0] == 0x60) && (p_data[1] == 0x06)) {
338 STLOG_HAL_V("%s - Sending PROP_NFC_MODE_SET_CMD", __func__);
339 // Send PROP_NFC_MODE_SET_CMD(ON)
340 mHalWrapperState = HAL_WRAPPER_STATE_NFC_ENABLE_ON;
341 if (!HalSendDownstreamTimer(mHalHandle, propNfcModeSetCmdOn,
342 sizeof(propNfcModeSetCmdOn), 500)) {
343 STLOG_HAL_E("NFC-NCI HAL: %s HalSendDownstreamTimer failed",
344 __func__);
345 }
346 } else {
347 mHalWrapperDataCallback(data_len, p_data);
348 }
349 break;
350
351 case HAL_WRAPPER_STATE_NFC_ENABLE_ON: // 3
352 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_NFC_ENABLE_ON",
353 __func__);
354 // PROP_NFC_MODE_SET_RSP
355 if ((p_data[0] == 0x4f) && (p_data[1] == 0x02)) {
356 // DO nothing: wait for core_reset_ntf or timer timeout
357 }
358 // CORE_RESET_NTF
359 else if ((p_data[0] == 0x60) && (p_data[1] == 0x00)) {
360 // Stop timer
361 HalSendDownstreamStopTimer(mHalHandle);
362 if (forceRecover == true) {
363 forceRecover = false;
364 mHalWrapperDataCallback(data_len, p_data);
365 break;
366 }
367
368 // Send CORE_INIT_CMD
369 STLOG_HAL_V("%s - Sending CORE_INIT_CMD", __func__);
370 if (!HalSendDownstream(mHalHandle, coreInitCmd, sizeof(coreInitCmd))) {
371 STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__);
372 }
373 }
374 // CORE_INIT_RSP
375 else if ((p_data[0] == 0x40) && (p_data[1] == 0x01)) {
376 STLOG_HAL_D("%s - NFC mode enabled", __func__);
377 // Do we need to lend a credit ?
378 if (p_data[13] == 0x00) {
379 STLOG_HAL_D("%s - 1 credit lent", __func__);
380 p_data[13] = 0x01;
381 mHciCreditLent = true;
382 }
383
384 mHalWrapperState = HAL_WRAPPER_STATE_READY;
385 mHalWrapperDataCallback(data_len, p_data);
386 }
387 break;
388
389 case HAL_WRAPPER_STATE_PROP_CONFIG: // 4
390 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_PROP_CONFIG",
391 __func__);
392 // CORE_SET_CONFIG_RSP
393 if ((p_data[0] == 0x40) && (p_data[1] == 0x02)) {
394 HalSendDownstreamStopTimer(mHalHandle);
395 GetNumValue(NAME_STNFC_REMOTE_FIELD_TIMER, &hal_field_timer,
396 sizeof(hal_field_timer));
397 STLOG_HAL_D("%s - hal_field_timer = %lu", __func__, hal_field_timer);
398 set_ready(1);
399 // Exit state, all processing done
400 mHalWrapperCallback(HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_OK);
401 mHalWrapperState = HAL_WRAPPER_STATE_READY;
402 } else if (mHciCreditLent && (p_data[0] == 0x60) && (p_data[1] == 0x06)) {
403 // CORE_CONN_CREDITS_NTF
404 if (p_data[4] == 0x01) { // HCI connection
405 mHciCreditLent = false;
406 STLOG_HAL_D("%s - credit returned", __func__);
407 if (p_data[5] == 0x01) {
408 // no need to send this.
409 break;
410 } else {
411 if (p_data[5] != 0x00 && p_data[5] != 0xFF) {
412 // send with 1 less
413 p_data[5]--;
414 }
415 }
416 }
417 mHalWrapperDataCallback(data_len, p_data);
418 } else if (p_data[0] == 0x4f) {
419 // PROP_RSP
420 if (mReadFwConfigDone == true) {
421 mReadFwConfigDone = false;
422 HalSendDownstreamStopTimer(mHalHandle);
423 // NFC_STATUS_OK
424 if (p_data[3] == 0x00) {
425 bool confNeeded = false;
426 bool firmware_debug_enabled =
427 property_get_int32("persist.vendor.nfc.firmware_debug_enabled", 0);
428
429 // Check if FW DBG shall be set
430 if (GetNumValue(NAME_STNFC_FW_DEBUG_ENABLED, &num, sizeof(num)) ||
431 isDebuggable || sEnableFwLog) {
432 if (firmware_debug_enabled || sEnableFwLog) {
433 num = 1;
434 swp_log = 30;
435 } else if (isDebuggable) {
436 swp_log = 30;
437 } else {
438 swp_log = 8;
439 }
440 rf_log = 15;
441
442 if (num == 1) {
443 GetNumValue(NAME_STNFC_FW_SWP_LOG_SIZE, &swp_log,
444 sizeof(swp_log));
445 GetNumValue(NAME_STNFC_FW_RF_LOG_SIZE, &rf_log, sizeof(rf_log));
446 }
447 // limit swp and rf payload length between 4 and 30.
448 if (swp_log > 30)
449 swp_log = 30;
450 else if (swp_log < 4)
451 swp_log = 4;
452
453 if (rf_log > 30)
454 rf_log = 30;
455 else if (rf_log < 4)
456 rf_log = 4;
457
458 if ((rf_log || swp_log) &&
459 ((p_data[15] != rf_log) || (p_data[17] != swp_log))) {
460 STLOG_HAL_D("%s - FW DBG payload traces changes needed",
461 __func__);
462 confNeeded = true;
463 }
464
465 // If conf file indicate set needed and not yet enabled
466 if ((num == 1) && (p_data[7] == 0x00)) {
467 STLOG_HAL_D("%s - FW DBG traces enabling needed", __func__);
468 nciPropEnableFwDbgTraces[9] = 0x01;
469 confNeeded = true;
470 } else if ((num == 0) && (p_data[7] == 0x01)) {
471 STLOG_HAL_D("%s - FW DBG traces disabling needed", __func__);
472 nciPropEnableFwDbgTraces[9] = 0x00;
473 confNeeded = true;
474 } else {
475 STLOG_HAL_D(
476 "%s - No FW DBG traces enable/disable change needed",
477 __func__);
478 }
479
480 if (data_len < 9 || p_data[6] == 0 || p_data[6] < (data_len - 7)
481 || p_data[6] > (sizeof(nciPropEnableFwDbgTraces) - 9)) {
482 if (confNeeded) {
483 android_errorWriteLog(0x534e4554, "169328517");
484 confNeeded = false;
485 }
486 }
487
488 if (confNeeded) {
489 memcpy(nciPropEnableFwDbgTraces, nciHeaderPropSetConfig, 9);
490 memcpy(&nciPropEnableFwDbgTraces[10], &p_data[8],
491 p_data[6] - 1);
492 if (rf_log || swp_log) {
493 nciPropEnableFwDbgTraces[9] = (uint8_t)num;
494 nciPropEnableFwDbgTraces[17] = (uint8_t)rf_log;
495 nciPropEnableFwDbgTraces[19] = (uint8_t)swp_log;
496 }
497 if ((9 + p_data[6]) < sizeof(nciPropEnableFwDbgTraces)) {
498 nciPropEnableFwDbgTraces_size = 9 + p_data[6];
499 }
500
501 confNeeded = false;
502
503 if (!HalSendDownstream(mHalHandle, nciPropEnableFwDbgTraces,
504 nciPropEnableFwDbgTraces_size)) {
505 STLOG_HAL_E("%s - SendDownstream failed", __func__);
506 }
507 mHalWrapperState = HAL_WRAPPER_STATE_APPLY_PROP_CONFIG;
508 break;
509 } else {
510 set_ready(1);
511 }
512 }
513 } else {
514 set_ready(1);
515 }
516 } else {
517 set_ready(1);
518 }
519 }
520 break;
521
522 case HAL_WRAPPER_STATE_READY: // 5
523 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_READY", __func__);
524 if (mObserverRsp) {
525 if (((p_data[0] == 0x41) && (p_data[1] == 0x16)) ||
526 ((p_data[0] == 0x40) && (p_data[1] == 0x02))) {
527 uint8_t rsp_status = p_data[3];
528 mObserverRsp = false;
529 p_data[0] = 0x4f;
530 p_data[1] = 0x0c;
531 p_data[2] = 0x02;
532 p_data[3] = 0x02;
533 p_data[4] = rsp_status;
534 data_len = 0x5;
535 } else if (((p_data[0] == 0x41) && (p_data[1] == 0x17) &&
536 (data_len > 4)) ||
537 ((p_data[0] == 0x40) && (p_data[1] == 0x03) &&
538 (data_len > 7))) {
539 uint8_t rsp_status = p_data[3];
540 mObserverRsp = false;
541 if (hal_fd_getFwCap()->ObserveMode == 2) {
542 if (p_data[4] != mObserverMode) {
543 STLOG_HAL_E("mObserverMode got out of sync");
544 mObserverMode = p_data[4];
545 }
546 p_data[5] = p_data[4];
547 } else {
548 if (p_data[7] != mObserverMode) {
549 STLOG_HAL_E("mObserverMode got out of sync");
550 mObserverMode = p_data[7];
551 }
552 p_data[5] = p_data[7];
553 }
554 p_data[0] = 0x4f;
555 p_data[1] = 0x0c;
556 p_data[2] = 0x03;
557 p_data[3] = 0x04;
558 p_data[4] = rsp_status;
559 data_len = 0x6;
560 }
561 }
562 if (!((p_data[0] == 0x60) && (p_data[3] == 0xa0))) {
563 if (mHciCreditLent && (p_data[0] == 0x60) && (p_data[1] == 0x06)) {
564 if (p_data[4] == 0x01) { // HCI connection
565 mHciCreditLent = false;
566 STLOG_HAL_D("%s - credit returned", __func__);
567 if (p_data[5] == 0x01) {
568 // no need to send this.
569 break;
570 } else {
571 if (p_data[5] != 0x00 && p_data[5] != 0xFF) {
572 // send with 1 less
573 p_data[5]--;
574 }
575 }
576 }
577 } else if ((p_data[0] == 0x61) && (p_data[1] == 0x07)) {
578 // RF_FIELD_INFO_NTF
579 if (p_data[3] == 0x01) { // field on
580 // start timer
581 if (hal_field_timer) {
582 mFieldInfoTimerStarted = true;
583 HalSendDownstreamTimer(mHalHandle, 20000);
584 }
585 } else if (p_data[3] == 0x00) {
586 if (mFieldInfoTimerStarted) {
587 HalSendDownstreamStopTimer(mHalHandle);
588 mFieldInfoTimerStarted = false;
589 }
590 }
591 } else if ((p_data[0] == 0x6f) && (p_data[1] == 0x05)) {
592 (void)pthread_mutex_lock(&mutex_activerw);
593 // start timer
594 mTimerStarted = true;
595 mIsActiveRW = true;
596 HalSendDownstreamTimer(mHalHandle, 5000);
597 (void)pthread_mutex_unlock(&mutex_activerw);
598 } else if ((p_data[0] == 0x6f) && (p_data[1] == 0x06)) {
599 (void)pthread_mutex_lock(&mutex_activerw);
600 // stop timer
601 if (mTimerStarted) {
602 HalSendDownstreamStopTimer(mHalHandle);
603 mTimerStarted = false;
604 }
605 if(mIsActiveRW == true) {
606 mIsActiveRW = false;
607 } else {
608 mError_count ++;
609 STLOG_HAL_E("Error Act -> Act count=%d", mError_count);
610 if(mError_count > 20) {
611 mError_count = 0;
612 STLOG_HAL_E("NFC Recovery Start");
613 mTimerStarted = true;
614 HalSendDownstreamTimer(mHalHandle, 1);
615 }
616 }
617 (void)pthread_mutex_unlock(&mutex_activerw);
618 } else if (((p_data[0] == 0x61) && (p_data[1] == 0x05)) ||
619 ((p_data[0] == 0x61) && (p_data[1] == 0x03))) {
620 mError_count = 0;
621 // stop timer
622 if (mFieldInfoTimerStarted) {
623 HalSendDownstreamStopTimer(mHalHandle);
624 mFieldInfoTimerStarted = false;
625 }
626 if (mTimerStarted) {
627 HalSendDownstreamStopTimer(mHalHandle);
628 mTimerStarted = false;
629 }
630 } else if (p_data[0] == 0x60 && p_data[1] == 0x00) {
631 STLOG_HAL_E("%s - Reset trigger from 0x%x to 0x0", __func__, p_data[3]);
632 p_data[3] = 0x0; // Only reset trigger that should be received in
633 // HAL_WRAPPER_STATE_READY is unreocoverable error.
634 mHalWrapperState = HAL_WRAPPER_STATE_RECOVERY;
635 } else if (data_len >= 4 && p_data[0] == 0x60 && p_data[1] == 0x07) {
636 if (p_data[3] == 0xE1) {
637 // Core Generic Error - Buffer Overflow Ntf - Restart all
638 STLOG_HAL_E("Core Generic Error - restart");
639 p_data[0] = 0x60;
640 p_data[1] = 0x00;
641 p_data[2] = 0x03;
642 p_data[3] = 0xE1;
643 p_data[4] = 0x00;
644 p_data[5] = 0x00;
645 data_len = 0x6;
646 mHalWrapperState = HAL_WRAPPER_STATE_RECOVERY;
647 } else if (p_data[3] == 0xE6) {
648 unsigned long hal_ctrl_clk = 0;
649 GetNumValue(NAME_STNFC_CONTROL_CLK, &hal_ctrl_clk,
650 sizeof(hal_ctrl_clk));
651 if (hal_ctrl_clk) {
652 STLOG_HAL_E("%s - Clock Error - restart", __func__);
653 // Core Generic Error
654 p_data[0] = 0x60;
655 p_data[1] = 0x00;
656 p_data[2] = 0x03;
657 p_data[3] = 0xE6;
658 p_data[4] = 0x00;
659 p_data[5] = 0x00;
660 data_len = 0x6;
661 mHalWrapperState = HAL_WRAPPER_STATE_RECOVERY;
662 }
663 } else if (p_data[3] == 0xA1) {
664 if (mFieldInfoTimerStarted) {
665 HalSendDownstreamStopTimer(mHalHandle);
666 mFieldInfoTimerStarted = false;
667 }
668 }
669 }
670 mHalWrapperDataCallback(data_len, p_data);
671 } else {
672 STLOG_HAL_V("%s - Core reset notification - Nfc mode ", __func__);
673 }
674 break;
675
676 case HAL_WRAPPER_STATE_CLOSING: // 6
677 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_CLOSING",
678 __func__);
679 hal_fd_close();
680 if ((p_data[0] == 0x4f) && (p_data[1] == 0x02)) {
681 // intercept this expected message, don t forward.
682 mHalWrapperState = HAL_WRAPPER_STATE_CLOSED;
683 } else {
684 mHalWrapperDataCallback(data_len, p_data);
685 }
686 break;
687
688 case HAL_WRAPPER_STATE_EXIT_HIBERNATE_INTERNAL: // 6
689 STLOG_HAL_V(
690 "%s - mHalWrapperState = HAL_WRAPPER_STATE_EXIT_HIBERNATE_INTERNAL",
691 __func__);
692 ExitHibernateHandler(mHalHandle, data_len, p_data);
693 break;
694
695 case HAL_WRAPPER_STATE_UPDATE: // 7
696 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_UPDATE", __func__);
697 FwUpdateHandler(mHalHandle, data_len, p_data);
698 break;
699 case HAL_WRAPPER_STATE_APPLY_CUSTOM_PARAM: // 8
700 STLOG_HAL_V(
701 "%s - mHalWrapperState = HAL_WRAPPER_STATE_APPLY_CUSTOM_PARAM",
702 __func__);
703 ApplyCustomParamHandler(mHalHandle, data_len, p_data);
704 break;
705 case HAL_WRAPPER_STATE_APPLY_UWB_PARAM: // 9
706 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_APPLY_UWB_PARAM",
707 __func__);
708 ApplyUwbParamHandler(mHalHandle, data_len, p_data);
709 break;
710 case HAL_WRAPPER_STATE_SET_ACTIVERW_TIMER: // 10
711 (void)pthread_mutex_lock(&mutex_activerw);
712 if (mIsActiveRW == true) {
713 STLOG_HAL_D(
714 "%s - mHalWrapperState = "
715 "HAL_WRAPPER_STATE_SET_ACTIVERW_TIMER",
716 __func__);
717 // start timer
718 mTimerStarted = true;
719 HalSendDownstreamTimer(mHalHandle, 5000);
720 // Chip state should back to Active
721 // at screen off state.
722 }
723 (void)pthread_mutex_unlock(&mutex_activerw);
724 mHalWrapperState = HAL_WRAPPER_STATE_READY;
725 mHalWrapperDataCallback(data_len, p_data);
726 break;
727
728 case HAL_WRAPPER_STATE_APPLY_PROP_CONFIG:
729 STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_APPLY_PROP_CONFIG",
730 __func__);
731 if (p_data[0] == 0x4f) {
732 I2cResetPulse();
733 } else if ((p_data[0] == 0x60) && (p_data[1] == 0x00)) {
734 // Send CORE_INIT_CMD
735 STLOG_HAL_D("%s - Sending CORE_INIT_CMD", __func__);
736 if (!HalSendDownstream(mHalHandle, coreInitCmd, sizeof(coreInitCmd))) {
737 STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__);
738 }
739 }
740 // CORE_INIT_RSP
741 else if ((p_data[0] == 0x40) && (p_data[1] == 0x01)) {
742 set_ready(1);
743 }
744 break;
745 case HAL_WRAPPER_STATE_RECOVERY:
746 break;
747 }
748 }
749
halWrapperCallback(uint8_t event,uint8_t event_status)750 static void halWrapperCallback(uint8_t event, __attribute__((unused))uint8_t event_status) {
751 uint8_t coreInitCmd[] = {0x20, 0x01, 0x02, 0x00, 0x00};
752 uint8_t rfDeactivateCmd[] = {0x21, 0x06, 0x01, 0x00};
753 uint8_t p_data[6];
754 uint16_t data_len;
755
756 switch (mHalWrapperState) {
757 case HAL_WRAPPER_STATE_CLOSING:
758 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
759 STLOG_HAL_D("NFC-NCI HAL: %s Timeout. Close anyway", __func__);
760 HalSendDownstreamStopTimer(mHalHandle);
761 hal_fd_close();
762 mHalWrapperState = HAL_WRAPPER_STATE_CLOSED;
763 return;
764 }
765 break;
766
767 case HAL_WRAPPER_STATE_OPEN:
768 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
769 STLOG_HAL_E("NFC-NCI HAL: %s Timeout accessing the CLF.", __func__);
770 HalSendDownstreamStopTimer(mHalHandle);
771 I2cRecovery();
772 abort(); // TODO: fix it when we have a better recovery method.
773 return;
774 }
775 break;
776
777 case HAL_WRAPPER_STATE_CLOSED:
778 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
779 STLOG_HAL_D("NFC-NCI HAL: %s Timeout. Close anyway", __func__);
780 HalSendDownstreamStopTimer(mHalHandle);
781 return;
782 }
783 break;
784
785 case HAL_WRAPPER_STATE_UPDATE:
786 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
787 STLOG_HAL_E("%s - Timer for FW update procedure timeout, retry",
788 __func__);
789 abort(); // TODO: fix it when we have a better recovery method.
790 HalSendDownstreamStopTimer(mHalHandle);
791 resetHandlerState();
792 I2cResetPulse();
793 mHalWrapperState = HAL_WRAPPER_STATE_OPEN;
794 }
795 break;
796
797 case HAL_WRAPPER_STATE_NFC_ENABLE_ON:
798 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
799 // timeout
800 // Send CORE_INIT_CMD
801 STLOG_HAL_V("%s - Sending CORE_INIT_CMD", __func__);
802 if (!HalSendDownstream(mHalHandle, coreInitCmd, sizeof(coreInitCmd))) {
803 STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__);
804 }
805 return;
806 }
807 break;
808 case HAL_WRAPPER_STATE_PROP_CONFIG:
809 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
810 STLOG_HAL_E("%s - Timer when sending conf parameters, retry", __func__);
811 abort(); // TODO: fix it when we have a better recovery method.
812 HalSendDownstreamStopTimer(mHalHandle);
813 resetHandlerState();
814 I2cResetPulse();
815 mHalWrapperState = HAL_WRAPPER_STATE_OPEN;
816 }
817 break;
818
819 case HAL_WRAPPER_STATE_READY:
820 if (event == HAL_WRAPPER_TIMEOUT_EVT) {
821 if (mTimerStarted || mFieldInfoTimerStarted) {
822 STLOG_HAL_E("NFC-NCI HAL: %s Timeout.. Recover!", __func__);
823 STLOG_HAL_E("%s mIsActiveRW = %d", __func__, mIsActiveRW);
824 HalSendDownstreamStopTimer(mHalHandle);
825 mTimerStarted = false;
826 mFieldInfoTimerStarted = false;
827 // forceRecover = true;
828 resetHandlerState();
829 if (!HalSendDownstream(mHalHandle, rfDeactivateCmd,
830 sizeof(rfDeactivateCmd))) {
831 STLOG_HAL_E("%s - SendDownstream failed", __func__);
832 }
833 usleep(10000);
834 // Core Generic Error
835
836 p_data[0] = 0x60;
837 p_data[1] = 0x00;
838 p_data[2] = 0x03;
839 p_data[3] = 0xAA;
840 p_data[4] = 0x00;
841 p_data[5] = 0x00;
842 data_len = 0x6;
843 mHalWrapperDataCallback(data_len, p_data);
844 mHalWrapperState = HAL_WRAPPER_STATE_RECOVERY;
845 }
846 return;
847 }
848 break;
849
850 default:
851 break;
852 }
853
854 mHalWrapperCallback(event, event_status);
855 }
856
857 /*******************************************************************************
858 **
859 ** Function nfc_set_state
860 **
861 ** Description Set the state of NFC stack
862 **
863 ** Returns void
864 **
865 *******************************************************************************/
hal_wrapper_set_state(hal_wrapper_state_e new_wrapper_state)866 void hal_wrapper_set_state(hal_wrapper_state_e new_wrapper_state) {
867 ALOGD("nfc_set_state %d->%d", mHalWrapperState, new_wrapper_state);
868
869 mHalWrapperState = new_wrapper_state;
870 }
871
872 /*******************************************************************************
873 **
874 ** Function hal_wrapper_setFwLogging
875 **
876 ** Description Enable the FW log by hte GUI if needed.
877 **
878 ** Returns void
879 **
880 *******************************************************************************/
hal_wrapper_setFwLogging(bool enable)881 void hal_wrapper_setFwLogging(bool enable) {
882 ALOGD("%s : enable = %d", __func__, enable);
883
884 sEnableFwLog = enable;
885 }
886