Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 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> |
George Chang | a009f4e | 2020-12-29 16:57:45 +0800 | [diff] [blame] | 23 | #include <log/log.h> |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 24 | #include <string.h> |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 25 | #include <unistd.h> |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 26 | #include "android_logmsg.h" |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 27 | #include "hal_fd.h" |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 28 | #include "halcore.h" |
| 29 | |
| 30 | extern void HalCoreCallback(void* context, uint32_t event, const void* d, |
| 31 | size_t length); |
| 32 | extern bool I2cOpenLayer(void* dev, HAL_CALLBACK callb, HALHANDLE* pHandle); |
| 33 | extern void I2cCloseLayer(); |
| 34 | |
| 35 | typedef struct { |
| 36 | struct nfc_nci_device nci_device; // nci_device must be first struct member |
| 37 | // below declarations are private variables within HAL |
| 38 | nfc_stack_callback_t* p_cback; |
| 39 | nfc_stack_data_callback_t* p_data_cback; |
| 40 | HALHANDLE hHAL; |
| 41 | } st21nfc_dev_t; |
| 42 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 43 | static void halWrapperDataCallback(uint16_t data_len, uint8_t* p_data); |
| 44 | static void halWrapperCallback(uint8_t event, uint8_t event_status); |
| 45 | |
| 46 | nfc_stack_callback_t* mHalWrapperCallback = NULL; |
| 47 | nfc_stack_data_callback_t* mHalWrapperDataCallback = NULL; |
| 48 | hal_wrapper_state_e mHalWrapperState = HAL_WRAPPER_STATE_CLOSED; |
| 49 | HALHANDLE mHalHandle = NULL; |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 50 | |
| 51 | uint8_t mClfMode; |
| 52 | uint8_t mFwUpdateTaskMask; |
| 53 | int mRetryFwDwl; |
| 54 | uint8_t mFwUpdateResMask = 0; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 55 | uint8_t* ConfigBuffer = NULL; |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 56 | uint8_t mError_count = 0; |
| 57 | bool mIsActiveRW = false; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 58 | pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; |
| 59 | pthread_cond_t ready_cond = PTHREAD_COND_INITIALIZER; |
| 60 | |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 61 | static const uint8_t ApduGetAtr[] = {0x2F, 0x04, 0x05, 0x80, |
| 62 | 0x8A, 0x00, 0x00, 0x04}; |
| 63 | |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 64 | static const uint8_t nciHeaderPropSetConfig[9] = {0x2F, 0x02, 0x98, 0x04, 0x00, |
| 65 | 0x14, 0x01, 0x00, 0x92}; |
| 66 | static uint8_t nciPropEnableFwDbgTraces[256]; |
| 67 | static uint8_t nciPropGetFwDbgTracesConfig[] = {0x2F, 0x02, 0x05, 0x03, |
| 68 | 0x00, 0x14, 0x01, 0x00}; |
Jack Yu | c94c649 | 2020-07-08 17:06:58 +0800 | [diff] [blame] | 69 | static bool isDebuggable; |
| 70 | |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 71 | bool mReadFwConfigDone = false; |
| 72 | |
Arach MOHAMMED BRAHIM | 449661b | 2018-09-24 17:02:54 +0200 | [diff] [blame] | 73 | bool mHciCreditLent = false; |
Arach MOHAMMED BRAHIM | cf7bd92 | 2019-05-09 15:40:17 +0200 | [diff] [blame] | 74 | bool mfactoryReset = false; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 75 | bool ready_flag = 0; |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 76 | bool mTimerStarted = false; |
| 77 | bool forceRecover = false; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 78 | |
| 79 | void wait_ready() { |
| 80 | pthread_mutex_lock(&mutex); |
| 81 | while (!ready_flag) { |
| 82 | pthread_cond_wait(&ready_cond, &mutex); |
| 83 | } |
| 84 | pthread_mutex_unlock(&mutex); |
| 85 | } |
| 86 | |
| 87 | void set_ready(bool ready) { |
| 88 | pthread_mutex_lock(&mutex); |
| 89 | ready_flag = ready; |
| 90 | pthread_cond_signal(&ready_cond); |
| 91 | pthread_mutex_unlock(&mutex); |
| 92 | } |
| 93 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 94 | bool hal_wrapper_open(st21nfc_dev_t* dev, nfc_stack_callback_t* p_cback, |
| 95 | nfc_stack_data_callback_t* p_data_cback, |
| 96 | HALHANDLE* pHandle) { |
| 97 | bool result; |
| 98 | |
| 99 | STLOG_HAL_D("%s", __func__); |
| 100 | |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 101 | mFwUpdateResMask = hal_fd_init(); |
| 102 | mRetryFwDwl = 5; |
| 103 | mFwUpdateTaskMask = 0; |
| 104 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 105 | mHalWrapperState = HAL_WRAPPER_STATE_OPEN; |
Arach MOHAMMED BRAHIM | 449661b | 2018-09-24 17:02:54 +0200 | [diff] [blame] | 106 | mHciCreditLent = false; |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 107 | mReadFwConfigDone = false; |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 108 | mError_count = 0; |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 109 | |
| 110 | mHalWrapperCallback = p_cback; |
| 111 | mHalWrapperDataCallback = p_data_cback; |
| 112 | |
| 113 | dev->p_data_cback = halWrapperDataCallback; |
| 114 | dev->p_cback = halWrapperCallback; |
| 115 | |
| 116 | result = I2cOpenLayer(dev, HalCoreCallback, pHandle); |
| 117 | |
| 118 | if (!result || !(*pHandle)) { |
| 119 | return -1; // We are doomed, stop it here, NOW ! |
| 120 | } |
| 121 | |
Jack Yu | c94c649 | 2020-07-08 17:06:58 +0800 | [diff] [blame] | 122 | isDebuggable = property_get_int32("ro.debuggable", 0); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 123 | mHalHandle = *pHandle; |
| 124 | |
| 125 | return 1; |
| 126 | } |
| 127 | |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 128 | int hal_wrapper_close(int call_cb, int nfc_mode) { |
| 129 | STLOG_HAL_V("%s - Sending PROP_NFC_MODE_SET_CMD(%d)", __func__, nfc_mode); |
| 130 | uint8_t propNfcModeSetCmdQb[] = {0x2f, 0x02, 0x02, 0x02, (uint8_t)nfc_mode}; |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 131 | |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 132 | mHalWrapperState = HAL_WRAPPER_STATE_CLOSING; |
| 133 | // Send PROP_NFC_MODE_SET_CMD |
| 134 | if (!HalSendDownstreamTimer(mHalHandle, propNfcModeSetCmdQb, |
Arach MOHAMMED BRAHIM | d51c023 | 2020-08-05 10:11:11 +0200 | [diff] [blame] | 135 | sizeof(propNfcModeSetCmdQb), 40)) { |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 136 | STLOG_HAL_E("NFC-NCI HAL: %s HalSendDownstreamTimer failed", __func__); |
| 137 | return -1; |
| 138 | } |
| 139 | // Let the CLF receive and process this |
| 140 | usleep(50000); |
| 141 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 142 | I2cCloseLayer(); |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 143 | if (call_cb) mHalWrapperCallback(HAL_NFC_CLOSE_CPLT_EVT, HAL_NFC_STATUS_OK); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 144 | |
| 145 | return 1; |
| 146 | } |
| 147 | |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 148 | void hal_wrapper_send_core_config_prop() { |
| 149 | long retlen = 0; |
| 150 | int isfound = 0; |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 151 | |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 152 | // allocate buffer for setting parameters |
| 153 | ConfigBuffer = (uint8_t*)malloc(256 * sizeof(uint8_t)); |
| 154 | if (ConfigBuffer != NULL) { |
| 155 | isfound = GetByteArrayValue(NAME_CORE_CONF_PROP, (char*)ConfigBuffer, 256, |
| 156 | &retlen); |
| 157 | |
| 158 | if (isfound > 0) { |
| 159 | STLOG_HAL_V("%s - Enter", __func__); |
| 160 | set_ready(0); |
| 161 | |
| 162 | if (!HalSendDownstreamTimer(mHalHandle, ConfigBuffer, retlen, 500)) { |
| 163 | STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__); |
| 164 | } |
| 165 | mHalWrapperState = HAL_WRAPPER_STATE_PROP_CONFIG; |
| 166 | wait_ready(); |
| 167 | } |
| 168 | free(ConfigBuffer); |
| 169 | ConfigBuffer = NULL; |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 170 | } |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 171 | } |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 172 | |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 173 | void hal_wrapper_send_vs_config() { |
| 174 | STLOG_HAL_V("%s - Enter", __func__); |
| 175 | set_ready(0); |
| 176 | |
| 177 | if (!HalSendDownstreamTimer(mHalHandle, nciPropGetFwDbgTracesConfig, |
| 178 | sizeof(nciPropGetFwDbgTracesConfig), 500)) { |
| 179 | STLOG_HAL_E("%s - SendDownstream failed", __func__); |
| 180 | } |
| 181 | mReadFwConfigDone = true; |
| 182 | wait_ready(); |
| 183 | } |
| 184 | |
| 185 | void hal_wrapper_send_config() { |
| 186 | hal_wrapper_send_core_config_prop(); |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 187 | mHalWrapperState = HAL_WRAPPER_STATE_PROP_CONFIG; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 188 | hal_wrapper_send_vs_config(); |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 189 | } |
| 190 | |
Arach MOHAMMED BRAHIM | cf7bd92 | 2019-05-09 15:40:17 +0200 | [diff] [blame] | 191 | void hal_wrapper_factoryReset() { |
| 192 | mfactoryReset = true; |
| 193 | STLOG_HAL_V("%s - mfactoryReset = %d", __func__, mfactoryReset); |
| 194 | } |
Arach MOHAMMED BRAHIM | 0b1b8ab | 2019-05-29 18:10:20 +0200 | [diff] [blame] | 195 | |
| 196 | void hal_wrapper_update_complete() { |
| 197 | STLOG_HAL_V("%s ", __func__); |
| 198 | mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_OK); |
| 199 | mHalWrapperState = HAL_WRAPPER_STATE_OPEN_CPLT; |
| 200 | } |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 201 | void halWrapperDataCallback(uint16_t data_len, uint8_t* p_data) { |
| 202 | uint8_t propNfcModeSetCmdOn[] = {0x2f, 0x02, 0x02, 0x02, 0x01}; |
| 203 | uint8_t coreInitCmd[] = {0x20, 0x01, 0x02, 0x00, 0x00}; |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 204 | uint8_t coreResetCmd[] = {0x20, 0x00, 0x01, 0x01}; |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 205 | unsigned long num = 0; |
Arach MOHAMMED BRAHIM | 42be702 | 2020-04-15 11:58:56 +0200 | [diff] [blame] | 206 | int nciPropEnableFwDbgTraces_size = sizeof(nciPropEnableFwDbgTraces); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 207 | |
| 208 | switch (mHalWrapperState) { |
| 209 | case HAL_WRAPPER_STATE_CLOSED: // 0 |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 210 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_CLOSED", __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 211 | break; |
| 212 | case HAL_WRAPPER_STATE_OPEN: // 1 |
| 213 | // CORE_RESET_NTF |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 214 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_OPEN", __func__); |
| 215 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 216 | if ((p_data[0] == 0x60) && (p_data[1] == 0x00)) { |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 217 | mFwUpdateTaskMask = ft_cmd_HwReset(p_data, &mClfMode); |
Arach MOHAMMED BRAHIM | cf7bd92 | 2019-05-09 15:40:17 +0200 | [diff] [blame] | 218 | |
| 219 | if (mfactoryReset == true) { |
| 220 | STLOG_HAL_V( |
| 221 | "%s - first boot after factory reset detected - start FW update", |
| 222 | __func__); |
| 223 | if ((mFwUpdateResMask & FW_PATCH_AVAILABLE) && |
| 224 | (mFwUpdateResMask & FW_CUSTOM_PARAM_AVAILABLE)) { |
| 225 | mFwUpdateTaskMask = FW_UPDATE_NEEDED | CONF_UPDATE_NEEDED; |
| 226 | mfactoryReset = false; |
| 227 | } |
| 228 | } |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 229 | STLOG_HAL_V( |
| 230 | "%s - mFwUpdateTaskMask = %d, mClfMode = %d, mRetryFwDwl = %d", |
| 231 | __func__, mFwUpdateTaskMask, mClfMode, mRetryFwDwl); |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 232 | // CLF in MODE LOADER & Update needed. |
| 233 | if (mClfMode == FT_CLF_MODE_LOADER) { |
| 234 | HalSendDownstreamStopTimer(mHalHandle); |
| 235 | STLOG_HAL_V("%s --- CLF mode is LOADER ---", __func__); |
| 236 | |
| 237 | if (mRetryFwDwl == 0) { |
| 238 | STLOG_HAL_V( |
| 239 | "%s - Reached maximum nb of retries, FW update failed, exiting", |
| 240 | __func__); |
| 241 | mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_FAILED); |
| 242 | I2cCloseLayer(); |
| 243 | } else { |
| 244 | STLOG_HAL_V("%s - Send APDU_GET_ATR_CMD", __func__); |
| 245 | mRetryFwDwl--; |
| 246 | if (!HalSendDownstreamTimer(mHalHandle, ApduGetAtr, |
| 247 | sizeof(ApduGetAtr), |
| 248 | FW_TIMER_DURATION)) { |
| 249 | STLOG_HAL_E("%s - SendDownstream failed", __func__); |
| 250 | } |
| 251 | mHalWrapperState = HAL_WRAPPER_STATE_UPDATE; |
| 252 | } |
| 253 | } else if (mFwUpdateTaskMask == 0 || mRetryFwDwl == 0) { |
| 254 | STLOG_HAL_V("%s - Proceeding with normal startup", __func__); |
| 255 | if (p_data[3] == 0x01) { |
| 256 | // Normal mode, start HAL |
| 257 | mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_OK); |
| 258 | mHalWrapperState = HAL_WRAPPER_STATE_OPEN_CPLT; |
| 259 | } else { |
| 260 | // No more retries or CLF not in correct mode |
| 261 | mHalWrapperCallback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_FAILED); |
| 262 | } |
| 263 | // CLF in MODE ROUTER & Update needed. |
| 264 | } else if (mClfMode == FT_CLF_MODE_ROUTER) { |
| 265 | if ((mFwUpdateTaskMask & FW_UPDATE_NEEDED) && |
| 266 | (mFwUpdateResMask & FW_PATCH_AVAILABLE)) { |
| 267 | STLOG_HAL_V( |
| 268 | "%s - CLF in ROUTER mode, FW update needed, try upgrade FW -", |
| 269 | __func__); |
| 270 | mRetryFwDwl--; |
| 271 | |
| 272 | if (!HalSendDownstream(mHalHandle, coreResetCmd, |
| 273 | sizeof(coreResetCmd))) { |
| 274 | STLOG_HAL_E("%s - SendDownstream failed", __func__); |
| 275 | } |
| 276 | mHalWrapperState = HAL_WRAPPER_STATE_EXIT_HIBERNATE_INTERNAL; |
| 277 | } else if ((mFwUpdateTaskMask & CONF_UPDATE_NEEDED) && |
| 278 | (mFwUpdateResMask & FW_CUSTOM_PARAM_AVAILABLE)) { |
| 279 | if (!HalSendDownstream(mHalHandle, coreResetCmd, |
| 280 | sizeof(coreResetCmd))) { |
| 281 | STLOG_HAL_E("%s - SendDownstream failed", __func__); |
| 282 | } |
| 283 | mHalWrapperState = HAL_WRAPPER_STATE_APPLY_CUSTOM_PARAM; |
Arach MOHAMMED BRAHIM | 1bff272 | 2021-07-01 16:38:56 +0200 | [diff] [blame] | 284 | } else if ((mFwUpdateTaskMask & UWB_CONF_UPDATE_NEEDED) && |
| 285 | (mFwUpdateResMask & FW_UWB_PARAM_AVAILABLE)) { |
| 286 | if (!HalSendDownstream(mHalHandle, coreResetCmd, |
| 287 | sizeof(coreResetCmd))) { |
| 288 | STLOG_HAL_E("%s - SendDownstream failed", __func__); |
| 289 | } |
| 290 | mHalWrapperState = HAL_WRAPPER_STATE_APPLY_UWB_PARAM; |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 291 | } |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 292 | } |
| 293 | } else { |
| 294 | mHalWrapperDataCallback(data_len, p_data); |
| 295 | } |
| 296 | break; |
| 297 | case HAL_WRAPPER_STATE_OPEN_CPLT: // 2 |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 298 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_OPEN_CPLT", |
| 299 | __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 300 | // CORE_INIT_RSP |
| 301 | if ((p_data[0] == 0x40) && (p_data[1] == 0x01)) { |
| 302 | } else if ((p_data[0] == 0x60) && (p_data[1] == 0x06)) { |
Arach MOHAMMED BRAHIM | ed64c1b | 2018-07-25 16:45:04 +0200 | [diff] [blame] | 303 | STLOG_HAL_V("%s - Sending PROP_NFC_MODE_SET_CMD", __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 304 | // Send PROP_NFC_MODE_SET_CMD(ON) |
| 305 | if (!HalSendDownstreamTimer(mHalHandle, propNfcModeSetCmdOn, |
| 306 | sizeof(propNfcModeSetCmdOn), 100)) { |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 307 | STLOG_HAL_E("NFC-NCI HAL: %s HalSendDownstreamTimer failed", |
| 308 | __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 309 | } |
| 310 | mHalWrapperState = HAL_WRAPPER_STATE_NFC_ENABLE_ON; |
| 311 | } else { |
| 312 | mHalWrapperDataCallback(data_len, p_data); |
| 313 | } |
| 314 | break; |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 315 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 316 | case HAL_WRAPPER_STATE_NFC_ENABLE_ON: // 3 |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 317 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_NFC_ENABLE_ON", |
| 318 | __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 319 | // PROP_NFC_MODE_SET_RSP |
| 320 | if ((p_data[0] == 0x4f) && (p_data[1] == 0x02)) { |
| 321 | // DO nothing: wait for core_reset_ntf or timer timeout |
| 322 | } |
| 323 | // CORE_RESET_NTF |
| 324 | else if ((p_data[0] == 0x60) && (p_data[1] == 0x00)) { |
| 325 | // Stop timer |
| 326 | HalSendDownstreamStopTimer(mHalHandle); |
Arach MOHAMMED BRAHIM | 837eb80 | 2020-10-12 15:46:43 +0200 | [diff] [blame] | 327 | if (forceRecover == true) { |
| 328 | forceRecover = false; |
| 329 | mHalWrapperDataCallback(data_len, p_data); |
| 330 | break; |
| 331 | } |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 332 | |
| 333 | // Send CORE_INIT_CMD |
Arach MOHAMMED BRAHIM | ed64c1b | 2018-07-25 16:45:04 +0200 | [diff] [blame] | 334 | STLOG_HAL_V("%s - Sending CORE_INIT_CMD", __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 335 | if (!HalSendDownstream(mHalHandle, coreInitCmd, sizeof(coreInitCmd))) { |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 336 | STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 337 | } |
| 338 | } |
| 339 | // CORE_INIT_RSP |
| 340 | else if ((p_data[0] == 0x40) && (p_data[1] == 0x01)) { |
| 341 | STLOG_HAL_D("%s - NFC mode enabled", __func__); |
Arach MOHAMMED BRAHIM | 449661b | 2018-09-24 17:02:54 +0200 | [diff] [blame] | 342 | // Do we need to lend a credit ? |
| 343 | if (p_data[13] == 0x00) { |
| 344 | STLOG_HAL_D("%s - 1 credit lent", __func__); |
| 345 | p_data[13] = 0x01; |
| 346 | mHciCreditLent = true; |
| 347 | } |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 348 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 349 | mHalWrapperState = HAL_WRAPPER_STATE_READY; |
| 350 | mHalWrapperDataCallback(data_len, p_data); |
| 351 | } |
| 352 | break; |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 353 | |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 354 | case HAL_WRAPPER_STATE_PROP_CONFIG: // 4 |
| 355 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_PROP_CONFIG", |
| 356 | __func__); |
| 357 | // CORE_SET_CONFIG_RSP |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 358 | if ((p_data[0] == 0x40) && (p_data[1] == 0x02)) { |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 359 | HalSendDownstreamStopTimer(mHalHandle); |
| 360 | set_ready(1); |
| 361 | |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 362 | STLOG_HAL_V("%s - Received config RSP, read FW dDBG config", __func__); |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 363 | } else if (mHciCreditLent && (p_data[0] == 0x60) && (p_data[1] == 0x06)) { |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 364 | // CORE_CONN_CREDITS_NTF |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 365 | if (p_data[4] == 0x01) { // HCI connection |
| 366 | mHciCreditLent = false; |
| 367 | STLOG_HAL_D("%s - credit returned", __func__); |
| 368 | if (p_data[5] == 0x01) { |
| 369 | // no need to send this. |
| 370 | break; |
| 371 | } else { |
| 372 | if (p_data[5] != 0x00 && p_data[5] != 0xFF) { |
| 373 | // send with 1 less |
| 374 | p_data[5]--; |
| 375 | } |
| 376 | } |
| 377 | } |
| 378 | mHalWrapperDataCallback(data_len, p_data); |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 379 | } else if (p_data[0] == 0x4f) { |
| 380 | // PROP_RSP |
| 381 | if (mReadFwConfigDone == true) { |
| 382 | mReadFwConfigDone = false; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 383 | HalSendDownstreamStopTimer(mHalHandle); |
| 384 | set_ready(1); |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 385 | // NFC_STATUS_OK |
| 386 | if (p_data[3] == 0x00) { |
| 387 | bool confNeeded = false; |
Jack Yu | c94c649 | 2020-07-08 17:06:58 +0800 | [diff] [blame] | 388 | bool firmware_debug_enabled = |
| 389 | property_get_int32("persist.vendor.nfc.firmware_debug_enabled", 0); |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 390 | |
| 391 | // Check if FW DBG shall be set |
Jack Yu | c94c649 | 2020-07-08 17:06:58 +0800 | [diff] [blame] | 392 | if (GetNumValue(NAME_STNFC_FW_DEBUG_ENABLED, &num, sizeof(num)) || |
| 393 | isDebuggable) { |
| 394 | if (firmware_debug_enabled) num = 1; |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 395 | // If conf file indicate set needed and not yet enabled |
| 396 | if ((num == 1) && (p_data[7] == 0x00)) { |
| 397 | STLOG_HAL_D("%s - FW DBG traces enabling needed", __func__); |
| 398 | nciPropEnableFwDbgTraces[9] = 0x01; |
| 399 | confNeeded = true; |
| 400 | } else if ((num == 0) && (p_data[7] == 0x01)) { |
| 401 | STLOG_HAL_D("%s - FW DBG traces disabling needed", __func__); |
| 402 | nciPropEnableFwDbgTraces[9] = 0x00; |
| 403 | confNeeded = true; |
| 404 | } else { |
| 405 | STLOG_HAL_D("%s - No changes in FW DBG traces config needed", |
| 406 | __func__); |
| 407 | } |
| 408 | |
George Chang | a009f4e | 2020-12-29 16:57:45 +0800 | [diff] [blame] | 409 | if (data_len < 9 || p_data[6] == 0 || p_data[6] < (data_len - 7) |
| 410 | || p_data[6] > (sizeof(nciPropEnableFwDbgTraces) - 9)) { |
| 411 | if (confNeeded) { |
| 412 | android_errorWriteLog(0x534e4554, "169328517"); |
| 413 | confNeeded = false; |
| 414 | } |
| 415 | } |
| 416 | |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 417 | if (confNeeded) { |
| 418 | memcpy(nciPropEnableFwDbgTraces, nciHeaderPropSetConfig, 9); |
| 419 | memcpy(&nciPropEnableFwDbgTraces[10], &p_data[8], |
| 420 | p_data[6] - 1); |
Arach MOHAMMED BRAHIM | 42be702 | 2020-04-15 11:58:56 +0200 | [diff] [blame] | 421 | if ((9 + p_data[6]) < sizeof(nciPropEnableFwDbgTraces)) { |
| 422 | nciPropEnableFwDbgTraces_size = 9 + p_data[6]; |
| 423 | } |
| 424 | |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 425 | confNeeded = false; |
| 426 | |
| 427 | if (!HalSendDownstream(mHalHandle, nciPropEnableFwDbgTraces, |
Arach MOHAMMED BRAHIM | 42be702 | 2020-04-15 11:58:56 +0200 | [diff] [blame] | 428 | nciPropEnableFwDbgTraces_size)) { |
Arach MOHAMMED BRAHIM | cb8da7f | 2019-02-15 16:20:29 +0100 | [diff] [blame] | 429 | STLOG_HAL_E("%s - SendDownstream failed", __func__); |
| 430 | } |
| 431 | |
| 432 | break; |
| 433 | } |
| 434 | } |
| 435 | } |
| 436 | } |
| 437 | |
| 438 | // Exit state, all processing done |
| 439 | mHalWrapperCallback(HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_OK); |
| 440 | mHalWrapperState = HAL_WRAPPER_STATE_READY; |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 441 | } |
| 442 | break; |
| 443 | |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 444 | case HAL_WRAPPER_STATE_READY: // 5 |
| 445 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_READY", __func__); |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 446 | if (!((p_data[0] == 0x60) && (p_data[3] == 0xa0))) { |
Arach MOHAMMED BRAHIM | 449661b | 2018-09-24 17:02:54 +0200 | [diff] [blame] | 447 | if (mHciCreditLent && (p_data[0] == 0x60) && (p_data[1] == 0x06)) { |
| 448 | if (p_data[4] == 0x01) { // HCI connection |
| 449 | mHciCreditLent = false; |
| 450 | STLOG_HAL_D("%s - credit returned", __func__); |
| 451 | if (p_data[5] == 0x01) { |
| 452 | // no need to send this. |
| 453 | break; |
| 454 | } else { |
| 455 | if (p_data[5] != 0x00 && p_data[5] != 0xFF) { |
| 456 | // send with 1 less |
| 457 | p_data[5]--; |
| 458 | } |
| 459 | } |
| 460 | } |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 461 | } else if ((p_data[0] == 0x6f) && (p_data[1] == 0x05)) { |
| 462 | // start timer |
| 463 | mTimerStarted = true; |
Jack Yu | b33f02f | 2020-06-23 17:08:11 +0800 | [diff] [blame] | 464 | HalSendDownstreamTimer(mHalHandle, 5000); |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 465 | mIsActiveRW = true; |
| 466 | } else if ((p_data[0] == 0x6f) && (p_data[1] == 0x06)) { |
| 467 | // stop timer |
| 468 | if (mTimerStarted) { |
| 469 | HalSendDownstreamStopTimer(mHalHandle); |
| 470 | mTimerStarted = false; |
| 471 | } |
| 472 | if(mIsActiveRW == true) { |
| 473 | mIsActiveRW = false; |
| 474 | } else { |
| 475 | mError_count ++; |
| 476 | STLOG_HAL_E("Error Act -> Act count=%d", mError_count); |
| 477 | if(mError_count > 20) { |
| 478 | mError_count = 0; |
| 479 | STLOG_HAL_E("NFC Recovery Start"); |
| 480 | mTimerStarted = true; |
| 481 | HalSendDownstreamTimer(mHalHandle, 1); |
| 482 | } |
| 483 | } |
| 484 | } else if (((p_data[0] == 0x61) && (p_data[1] == 0x05)) || |
| 485 | ((p_data[0] == 0x61) && (p_data[1] == 0x03))) { |
| 486 | mError_count = 0; |
| 487 | // stop timer |
| 488 | if (mTimerStarted) { |
| 489 | HalSendDownstreamStopTimer(mHalHandle); |
| 490 | mTimerStarted = false; |
| 491 | } |
Arach MOHAMMED BRAHIM | 449661b | 2018-09-24 17:02:54 +0200 | [diff] [blame] | 492 | } |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 493 | mHalWrapperDataCallback(data_len, p_data); |
| 494 | } else { |
| 495 | STLOG_HAL_V("%s - Core reset notification - Nfc mode ", __func__); |
| 496 | } |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 497 | break; |
Alexandra Ducati-Manas | 9030f51 | 2018-11-22 09:22:43 +0100 | [diff] [blame] | 498 | |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 499 | case HAL_WRAPPER_STATE_CLOSING: // 6 |
| 500 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_CLOSING", |
| 501 | __func__); |
Arach MOHAMMED BRAHIM | 0b1b8ab | 2019-05-29 18:10:20 +0200 | [diff] [blame] | 502 | hal_fd_close(); |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 503 | if ((p_data[0] == 0x4f) && (p_data[1] == 0x02)) { |
Arach MOHAMMED BRAHIM | 7469e92 | 2018-11-29 18:47:50 +0100 | [diff] [blame] | 504 | // intercept this expected message, don t forward. |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 505 | mHalWrapperState = HAL_WRAPPER_STATE_CLOSED; |
Arach MOHAMMED BRAHIM | 7469e92 | 2018-11-29 18:47:50 +0100 | [diff] [blame] | 506 | } else { |
| 507 | mHalWrapperDataCallback(data_len, p_data); |
Arach MOHAMMED BRAHIM | ef5b4d9 | 2018-09-24 16:07:04 +0200 | [diff] [blame] | 508 | } |
| 509 | break; |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 510 | |
| 511 | case HAL_WRAPPER_STATE_EXIT_HIBERNATE_INTERNAL: // 6 |
| 512 | STLOG_HAL_V( |
| 513 | "%s - mHalWrapperState = HAL_WRAPPER_STATE_EXIT_HIBERNATE_INTERNAL", |
| 514 | __func__); |
| 515 | ExitHibernateHandler(mHalHandle, data_len, p_data); |
| 516 | break; |
| 517 | |
| 518 | case HAL_WRAPPER_STATE_UPDATE: // 7 |
| 519 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_UPDATE", __func__); |
| 520 | UpdateHandler(mHalHandle, data_len, p_data); |
| 521 | break; |
| 522 | case HAL_WRAPPER_STATE_APPLY_CUSTOM_PARAM: // 8 |
| 523 | STLOG_HAL_V( |
| 524 | "%s - mHalWrapperState = HAL_WRAPPER_STATE_APPLY_CUSTOM_PARAM", |
| 525 | __func__); |
| 526 | ApplyCustomParamHandler(mHalHandle, data_len, p_data); |
| 527 | break; |
Arach MOHAMMED BRAHIM | 1bff272 | 2021-07-01 16:38:56 +0200 | [diff] [blame] | 528 | case HAL_WRAPPER_STATE_APPLY_UWB_PARAM: // 9 |
| 529 | STLOG_HAL_V("%s - mHalWrapperState = HAL_WRAPPER_STATE_APPLY_UWB_PARAM", |
| 530 | __func__); |
| 531 | ApplyUwbParamHandler(mHalHandle, data_len, p_data); |
| 532 | break; |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 533 | } |
| 534 | } |
| 535 | |
Arach MOHAMMED BRAHIM | 837eb80 | 2020-10-12 15:46:43 +0200 | [diff] [blame] | 536 | static void halWrapperCallback(uint8_t event, __attribute__((unused))uint8_t event_status) { |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 537 | uint8_t coreInitCmd[] = {0x20, 0x01, 0x02, 0x00, 0x00}; |
| 538 | |
| 539 | switch (mHalWrapperState) { |
Arach MOHAMMED BRAHIM | d51c023 | 2020-08-05 10:11:11 +0200 | [diff] [blame] | 540 | case HAL_WRAPPER_STATE_CLOSING: |
| 541 | if (event == HAL_WRAPPER_TIMEOUT_EVT) { |
| 542 | STLOG_HAL_D("NFC-NCI HAL: %s Timeout. Close anyway", __func__); |
| 543 | HalSendDownstreamStopTimer(mHalHandle); |
| 544 | hal_fd_close(); |
| 545 | mHalWrapperState = HAL_WRAPPER_STATE_CLOSED; |
| 546 | return; |
| 547 | } |
| 548 | break; |
| 549 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 550 | case HAL_WRAPPER_STATE_CLOSED: |
Arach MOHAMMED BRAHIM | d9214f1 | 2018-11-29 14:54:52 +0100 | [diff] [blame] | 551 | if (event == HAL_WRAPPER_TIMEOUT_EVT) { |
| 552 | STLOG_HAL_D("NFC-NCI HAL: %s Timeout. Close anyway", __func__); |
| 553 | HalSendDownstreamStopTimer(mHalHandle); |
| 554 | return; |
| 555 | } |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 556 | break; |
| 557 | |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 558 | case HAL_WRAPPER_STATE_UPDATE: |
| 559 | if (event == HAL_WRAPPER_TIMEOUT_EVT) { |
| 560 | STLOG_HAL_E("%s - Timer for FW update procedure timeout, retry", |
| 561 | __func__); |
| 562 | HalSendDownstreamStopTimer(mHalHandle); |
| 563 | resetHandlerState(); |
| 564 | I2cResetPulse(); |
| 565 | mHalWrapperState = HAL_WRAPPER_STATE_OPEN; |
| 566 | } |
| 567 | break; |
| 568 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 569 | case HAL_WRAPPER_STATE_NFC_ENABLE_ON: |
| 570 | if (event == HAL_WRAPPER_TIMEOUT_EVT) { |
| 571 | // timeout |
| 572 | // Send CORE_INIT_CMD |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 573 | STLOG_HAL_V("%s - Sending CORE_INIT_CMD", __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 574 | if (!HalSendDownstream(mHalHandle, coreInitCmd, sizeof(coreInitCmd))) { |
Arach MOHAMMED BRAHIM | 838910b | 2018-08-16 16:05:24 +0200 | [diff] [blame] | 575 | STLOG_HAL_E("NFC-NCI HAL: %s SendDownstream failed", __func__); |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 576 | } |
| 577 | return; |
| 578 | } |
| 579 | break; |
Arach MOHAMMED BRAHIM | dbc5db0 | 2019-05-07 12:26:29 +0200 | [diff] [blame] | 580 | case HAL_WRAPPER_STATE_PROP_CONFIG: |
| 581 | if (event == HAL_WRAPPER_TIMEOUT_EVT) { |
| 582 | STLOG_HAL_E("%s - Timer when sending conf parameters, retry", __func__); |
| 583 | HalSendDownstreamStopTimer(mHalHandle); |
| 584 | resetHandlerState(); |
| 585 | I2cResetPulse(); |
| 586 | mHalWrapperState = HAL_WRAPPER_STATE_OPEN; |
| 587 | } |
| 588 | break; |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 589 | |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 590 | case HAL_WRAPPER_STATE_READY: |
| 591 | if (event == HAL_WRAPPER_TIMEOUT_EVT) { |
| 592 | if (mTimerStarted) { |
| 593 | STLOG_HAL_D("NFC-NCI HAL: %s Timeout.. Recover", __func__); |
| 594 | HalSendDownstreamStopTimer(mHalHandle); |
| 595 | mTimerStarted = false; |
| 596 | forceRecover = true; |
Arach MOHAMMED BRAHIM | 837eb80 | 2020-10-12 15:46:43 +0200 | [diff] [blame] | 597 | resetHandlerState(); |
| 598 | I2cResetPulse(); |
| 599 | mHalWrapperState = HAL_WRAPPER_STATE_OPEN; |
| 600 | |
Arach MOHAMMED BRAHIM | 507dcb0 | 2019-09-13 10:30:38 +0200 | [diff] [blame] | 601 | } |
| 602 | return; |
| 603 | } |
| 604 | break; |
| 605 | |
Arach MOHAMMED BRAHIM | 7c2cf79 | 2018-05-09 10:04:24 +0200 | [diff] [blame] | 606 | default: |
| 607 | break; |
| 608 | } |
| 609 | |
| 610 | mHalWrapperCallback(event, event_status); |
| 611 | } |
Arach MOHAMMED BRAHIM | 7238143 | 2019-02-11 18:03:27 +0100 | [diff] [blame] | 612 | |
| 613 | /******************************************************************************* |
| 614 | ** |
| 615 | ** Function nfc_set_state |
| 616 | ** |
| 617 | ** Description Set the state of NFC stack |
| 618 | ** |
| 619 | ** Returns void |
| 620 | ** |
| 621 | *******************************************************************************/ |
| 622 | void hal_wrapper_set_state(hal_wrapper_state_e new_wrapper_state) { |
| 623 | ALOGD("nfc_set_state %d->%d", mHalWrapperState, new_wrapper_state); |
| 624 | |
| 625 | mHalWrapperState = new_wrapper_state; |
| 626 | } |