1 /*
2 * Copyright 2012-2023 NXP
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include <log/log.h>
17 #include <phDal4Nfc_messageQueueLib.h>
18 #include <phDnldNfc.h>
19 #include <phNxpConfig.h>
20 #include <phNxpLog.h>
21 #include <phNxpNciHal.h>
22 #include <phNxpNciHal_Adaptation.h>
23 #include <phNxpNciHal_NfcDepSWPrio.h>
24 #include <phNxpNciHal_ext.h>
25 #include <phTmlNfc.h>
26
27 #include <vector>
28
29 #include "phNxpNciHal.h"
30 #include "phNxpNciHal_IoctlOperations.h"
31 #include "phNxpNciHal_PowerTrackerIface.h"
32 #include "phNxpNciHal_nciParser.h"
33
34 #define NXP_EN_SN110U 1
35 #define NXP_EN_SN100U 1
36 #define NXP_EN_SN220U 1
37 #define NXP_EN_PN557 1
38 #define NXP_EN_PN560 1
39 #define NFC_NXP_MW_ANDROID_VER (14U) /* Android version used by NFC MW */
40 #define NFC_NXP_MW_VERSION_MAJ (0x04) /* MW Major Version */
41 #define NFC_NXP_MW_VERSION_MIN (0x00) /* MW Minor Version */
42 #define NFC_NXP_MW_CUSTOMER_ID (0x00) /* MW Customer Id */
43 #define NFC_NXP_MW_RC_VERSION (0x00) /* MW RC Version */
44
45 /* Timeout value to wait for response from PN548AD */
46 #define HAL_EXTNS_WRITE_RSP_TIMEOUT (1000)
47 #define NCI_NFC_DEP_RF_INTF 0x03
48 #define NCI_STATUS_OK 0x00
49 #define NCI_MODE_HEADER_LEN 3
50
51 #undef P2P_PRIO_LOGIC_HAL_IMP
52
53 /******************* Global variables *****************************************/
54 extern phNxpNciHal_Control_t nxpncihal_ctrl;
55 extern phNxpNciProfile_Control_t nxpprofile_ctrl;
56 extern phNxpNci_getCfg_info_t* mGetCfg_info;
57 extern PowerTrackerHandle gPowerTrackerHandle;
58
59 extern bool_t gsIsFwRecoveryRequired;
60
61 extern uint32_t cleanup_timer;
62 extern bool nfc_debug_enabled;
63 uint8_t icode_detected = 0x00;
64 uint8_t icode_send_eof = 0x00;
65 static uint8_t ee_disc_done = 0x00;
66 uint8_t EnableP2P_PrioLogic = false;
67 extern bool bEnableMfcExtns;
68 extern bool bEnableMfcReader;
69 extern bool bDisableLegacyMfcExtns;
70 static uint32_t RfDiscID = 1;
71 static uint32_t RfProtocolType = 4;
72 /* NFCEE Set mode */
73 static uint8_t setEEModeDone = 0x00;
74 /* External global variable to get FW version from NCI response*/
75 extern uint32_t wFwVerRsp;
76 /* External global variable to get FW version from FW file*/
77 extern uint16_t wFwVer;
78 extern bool_t gParserCreated;
79 /* local buffer to store CORE_INIT response */
80 static uint32_t bCoreInitRsp[40];
81 static uint32_t iCoreInitRspLen;
82
83 extern uint32_t timeoutTimerId;
84
85 /************** HAL extension functions ***************************************/
86 static void hal_extns_write_rsp_timeout_cb(uint32_t TimerId, void* pContext);
87
88 /*Proprietary cmd sent to HAL to send reader mode flag
89 * Last byte of 4 byte proprietary cmd data contains ReaderMode flag
90 * If this flag is enabled, NFC-DEP protocol is modified to T3T protocol
91 * if FrameRF interface is selected. This needs to be done as the FW
92 * always sends Ntf for FrameRF with NFC-DEP even though FrameRF with T3T is
93 * previously selected with DISCOVER_SELECT_CMD
94 */
95 #define PROPRIETARY_CMD_FELICA_READER_MODE 0xFE
96 static uint8_t gFelicaReaderMode;
97 static bool mfc_mode = false;
98
99 static NFCSTATUS phNxpNciHal_ext_process_nfc_init_rsp(uint8_t* p_ntf,
100 uint16_t* p_len);
101 static void RemoveNfcDepIntfFromInitResp(uint8_t* coreInitResp,
102 uint16_t* coreInitRespLen);
103
printNfcMwVersion()104 void printNfcMwVersion() {
105 uint32_t validation = (NXP_EN_SN100U << 13);
106 validation |= (NXP_EN_SN110U << 14);
107 validation |= (NXP_EN_SN220U << 15);
108 validation |= (NXP_EN_PN560 << 16);
109 validation |= (NXP_EN_PN557 << 11);
110
111 ALOGE("MW-HAL Version: NFC_AR_%02X_%05X_%02d.%02x.%02x",
112 NFC_NXP_MW_CUSTOMER_ID, validation, NFC_NXP_MW_ANDROID_VER,
113 NFC_NXP_MW_VERSION_MAJ, NFC_NXP_MW_VERSION_MIN);
114 }
115 /*******************************************************************************
116 **
117 ** Function phNxpNciHal_ext_init
118 **
119 ** Description initialize extension function
120 **
121 *******************************************************************************/
phNxpNciHal_ext_init(void)122 void phNxpNciHal_ext_init(void) {
123 icode_detected = 0x00;
124 if (IS_CHIP_TYPE_L(sn100u)) {
125 icode_send_eof = 0x00;
126 }
127 setEEModeDone = 0x00;
128 EnableP2P_PrioLogic = false;
129 }
130
131 /*******************************************************************************
132 **
133 ** Function phNxpNciHal_ext_send_sram_config_to_flash
134 **
135 ** Description This function is called to update the SRAM contents such as
136 ** set config to FLASH for permanent storage.
137 ** Note: This function has to be called after set config and
138 ** before sending core_reset command again.
139 **
140 *******************************************************************************/
phNxpNciHal_ext_send_sram_config_to_flash()141 NFCSTATUS phNxpNciHal_ext_send_sram_config_to_flash() {
142 NXPLOG_NCIHAL_D("phNxpNciHal_ext_send_sram_config_to_flash send");
143 NFCSTATUS status = NFCSTATUS_SUCCESS;
144 uint8_t send_sram_flash[] = {NXP_PROPCMD_GID, NXP_FLUSH_SRAM_AO_TO_FLASH,
145 0x00};
146 status = phNxpNciHal_send_ext_cmd(sizeof(send_sram_flash), send_sram_flash);
147 return status;
148 }
149 /*******************************************************************************
150 **
151 ** Function phNxpNciHal_process_ext_rsp
152 **
153 ** Description Process extension function response
154 **
155 ** Returns NFCSTATUS_SUCCESS if success
156 **
157 *******************************************************************************/
phNxpNciHal_process_ext_rsp(uint8_t * p_ntf,uint16_t * p_len)158 NFCSTATUS phNxpNciHal_process_ext_rsp(uint8_t* p_ntf, uint16_t* p_len) {
159 NFCSTATUS status = NFCSTATUS_SUCCESS;
160
161 /*parse and decode LxDebug Notifications*/
162 if (p_ntf[0] == 0x6F && (p_ntf[1] == 0x35 || p_ntf[1] == 0x36)) {
163 if (gParserCreated) phNxpNciHal_parsePacket(p_ntf, *p_len);
164 }
165 #if (NXP_SRD == TRUE)
166 if (p_ntf[0] == 0x01 && p_ntf[1] == 0x00 && p_ntf[5] == 0x81 &&
167 p_ntf[23] == 0x82 && p_ntf[26] == 0xA0 && p_ntf[27] == 0xFE) {
168 if (p_ntf[29] == 0x01) {
169 nxpprofile_ctrl.profile_type = SRD_PROFILE;
170 } else if (p_ntf[29] == 0x00) {
171 nxpprofile_ctrl.profile_type = NFC_FORUM_PROFILE;
172 }
173 } else if (p_ntf[0] == 0x60 && p_ntf[1] == 0x07 && p_ntf[2] == 0x01 &&
174 p_ntf[3] == 0xE2) {
175 nxpprofile_ctrl.profile_type = NFC_FORUM_PROFILE;
176 }
177 #endif
178
179 if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && *p_len < 14) {
180 if (*p_len <= 6) {
181 android_errorWriteLog(0x534e4554, "118152591");
182 }
183 NXPLOG_NCIHAL_E("RF_INTF_ACTIVATED_NTF length error!");
184 status = NFCSTATUS_FAILED;
185 return status;
186 }
187
188 if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && p_ntf[4] == 0x03 &&
189 p_ntf[5] == 0x05 && nxpprofile_ctrl.profile_type == EMV_CO_PROFILE) {
190 p_ntf[4] = 0xFF;
191 p_ntf[5] = 0xFF;
192 p_ntf[6] = 0xFF;
193 NXPLOG_NCIHAL_D("Nfc-Dep Detect in EmvCo profile - Restart polling");
194 }
195
196 if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && p_ntf[4] == 0x01 &&
197 p_ntf[5] == 0x05 && p_ntf[6] == 0x02 && gFelicaReaderMode) {
198 /*If FelicaReaderMode is enabled,Change Protocol to T3T from NFC-DEP
199 * when FrameRF interface is selected*/
200 p_ntf[5] = 0x03;
201 NXPLOG_NCIHAL_D("FelicaReaderMode:Activity 1.1");
202 }
203
204 #ifdef P2P_PRIO_LOGIC_HAL_IMP
205 if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && p_ntf[4] == 0x02 &&
206 p_ntf[5] == 0x04 && nxpprofile_ctrl.profile_type == NFC_FORUM_PROFILE) {
207 EnableP2P_PrioLogic = true;
208 }
209
210 NXPLOG_NCIHAL_D("Is EnableP2P_PrioLogic: 0x0%X", EnableP2P_PrioLogic);
211 if (phNxpDta_IsEnable() == false) {
212 if ((icode_detected != 1) && (EnableP2P_PrioLogic == true)) {
213 if (phNxpNciHal_NfcDep_comapre_ntf(p_ntf, *p_len) == NFCSTATUS_FAILED) {
214 status = phNxpNciHal_NfcDep_rsp_ext(p_ntf, p_len);
215 if (status != NFCSTATUS_INVALID_PARAMETER) {
216 return status;
217 }
218 }
219 }
220 }
221 #endif
222
223 status = NFCSTATUS_SUCCESS;
224
225 if (bDisableLegacyMfcExtns && bEnableMfcExtns && p_ntf[0] == 0) {
226 if (*p_len < NCI_HEADER_SIZE) {
227 android_errorWriteLog(0x534e4554, "169258743");
228 return NFCSTATUS_FAILED;
229 }
230 uint16_t extlen;
231 extlen = *p_len - NCI_HEADER_SIZE;
232 NxpMfcReaderInstance.AnalyzeMfcResp(&p_ntf[3], &extlen);
233 p_ntf[2] = extlen;
234 *p_len = extlen + NCI_HEADER_SIZE;
235 }
236
237 if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05) {
238 bEnableMfcExtns = false;
239 if (bDisableLegacyMfcExtns && p_ntf[4] == 0x80 && p_ntf[5] == 0x80) {
240 bEnableMfcExtns = true;
241 NXPLOG_NCIHAL_D("NxpNci: RF Interface = Mifare Enable MifareExtns");
242 }
243 switch (p_ntf[4]) {
244 case 0x00:
245 NXPLOG_NCIHAL_D("NxpNci: RF Interface = NFCEE Direct RF");
246 break;
247 case 0x01:
248 NXPLOG_NCIHAL_D("NxpNci: RF Interface = Frame RF");
249 break;
250 case 0x02:
251 NXPLOG_NCIHAL_D("NxpNci: RF Interface = ISO-DEP");
252 break;
253 case 0x03:
254 NXPLOG_NCIHAL_D("NxpNci: RF Interface = NFC-DEP");
255 break;
256 case 0x80:
257 NXPLOG_NCIHAL_D("NxpNci: RF Interface = MIFARE");
258 break;
259 default:
260 NXPLOG_NCIHAL_D("NxpNci: RF Interface = Unknown");
261 break;
262 }
263
264 switch (p_ntf[5]) {
265 case 0x01:
266 NXPLOG_NCIHAL_D("NxpNci: Protocol = T1T");
267 phNxpDta_T1TEnable();
268 break;
269 case 0x02:
270 NXPLOG_NCIHAL_D("NxpNci: Protocol = T2T");
271 break;
272 case 0x03:
273 NXPLOG_NCIHAL_D("NxpNci: Protocol = T3T");
274 break;
275 case 0x04:
276 NXPLOG_NCIHAL_D("NxpNci: Protocol = ISO-DEP");
277 break;
278 case 0x05:
279 NXPLOG_NCIHAL_D("NxpNci: Protocol = NFC-DEP");
280 break;
281 case 0x06:
282 NXPLOG_NCIHAL_D("NxpNci: Protocol = 15693");
283 break;
284 case 0x80:
285 NXPLOG_NCIHAL_D("NxpNci: Protocol = MIFARE");
286 break;
287 case 0x81:
288 NXPLOG_NCIHAL_D("NxpNci: Protocol = Kovio");
289 break;
290 default:
291 NXPLOG_NCIHAL_D("NxpNci: Protocol = Unknown");
292 break;
293 }
294
295 switch (p_ntf[6]) {
296 case 0x00:
297 NXPLOG_NCIHAL_D("NxpNci: Mode = A Passive Poll");
298 break;
299 case 0x01:
300 NXPLOG_NCIHAL_D("NxpNci: Mode = B Passive Poll");
301 break;
302 case 0x02:
303 NXPLOG_NCIHAL_D("NxpNci: Mode = F Passive Poll");
304 break;
305 case 0x03:
306 NXPLOG_NCIHAL_D("NxpNci: Mode = A Active Poll");
307 break;
308 case 0x05:
309 NXPLOG_NCIHAL_D("NxpNci: Mode = F Active Poll");
310 break;
311 case 0x06:
312 NXPLOG_NCIHAL_D("NxpNci: Mode = 15693 Passive Poll");
313 break;
314 case 0x70:
315 NXPLOG_NCIHAL_D("NxpNci: Mode = Kovio");
316 break;
317 #if (NXP_QTAG == TRUE)
318 case 0x71:
319 NXPLOG_NCIHAL_D("NxpNci: Mode = Q Passive Poll");
320 break;
321 #endif
322 case 0x80:
323 NXPLOG_NCIHAL_D("NxpNci: Mode = A Passive Listen");
324 break;
325 case 0x81:
326 NXPLOG_NCIHAL_D("NxpNci: Mode = B Passive Listen");
327 break;
328 case 0x82:
329 NXPLOG_NCIHAL_D("NxpNci: Mode = F Passive Listen");
330 break;
331 case 0x83:
332 NXPLOG_NCIHAL_D("NxpNci: Mode = A Active Listen");
333 break;
334 case 0x85:
335 NXPLOG_NCIHAL_D("NxpNci: Mode = F Active Listen");
336 break;
337 case 0x86:
338 NXPLOG_NCIHAL_D("NxpNci: Mode = 15693 Passive Listen");
339 break;
340 default:
341 NXPLOG_NCIHAL_D("NxpNci: Mode = Unknown");
342 break;
343 }
344 }
345 phNxpNciHal_ext_process_nfc_init_rsp(p_ntf, p_len);
346 if (p_ntf[0] == NCI_MT_NTF &&
347 ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_RESET) &&
348 p_ntf[3] == CORE_RESET_TRIGGER_TYPE_POWERED_ON) {
349 status = NFCSTATUS_FAILED;
350 NXPLOG_NCIHAL_D("Skipping power on reset notification!!:");
351 return status;
352 }
353 if (p_ntf[0] == 0x42 && p_ntf[1] == 0x01 && p_ntf[2] == 0x01 &&
354 p_ntf[3] == 0x00) {
355 if (nxpncihal_ctrl.hal_ext_enabled == TRUE && IS_CHIP_TYPE_GE(sn100u)) {
356 nxpncihal_ctrl.nci_info.wait_for_ntf = TRUE;
357 NXPLOG_NCIHAL_D(" Mode set received");
358 }
359 } else if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && p_ntf[2] == 0x15 &&
360 p_ntf[4] == 0x01 && p_ntf[5] == 0x06 && p_ntf[6] == 0x06) {
361 NXPLOG_NCIHAL_D("> Going through workaround - notification of ISO 15693");
362 icode_detected = 0x01;
363 p_ntf[21] = 0x01;
364 p_ntf[22] = 0x01;
365 } else if (IS_CHIP_TYPE_L(sn100u) && icode_detected == 1 &&
366 icode_send_eof == 2) {
367 icode_send_eof = 3;
368 } else if (IS_CHIP_TYPE_L(sn100u) && p_ntf[0] == 0x00 && p_ntf[1] == 0x00 &&
369 icode_detected == 1) {
370 if (icode_send_eof == 3) {
371 icode_send_eof = 0;
372 }
373 if (nxpncihal_ctrl.nci_info.nci_version != NCI_VERSION_2_0) {
374 if (*p_len <= (p_ntf[2] + 2)) {
375 android_errorWriteLog(0x534e4554, "181660091");
376 NXPLOG_NCIHAL_E("length error!");
377 return NFCSTATUS_FAILED;
378 }
379 if (p_ntf[p_ntf[2] + 2] == 0x00) {
380 NXPLOG_NCIHAL_D("> Going through workaround - data of ISO 15693");
381 p_ntf[2]--;
382 (*p_len)--;
383 } else {
384 p_ntf[p_ntf[2] + 2] |= 0x01;
385 }
386 }
387 } else if (IS_CHIP_TYPE_L(sn100u) && p_ntf[2] == 0x02 && p_ntf[1] == 0x00 &&
388 icode_detected == 1) {
389 NXPLOG_NCIHAL_D("> ICODE EOF response do not send to upper layer");
390 } else if (p_ntf[0] == 0x61 && p_ntf[1] == 0x06 && icode_detected == 1) {
391 NXPLOG_NCIHAL_D("> Polling Loop Re-Started");
392 icode_detected = 0;
393 if (IS_CHIP_TYPE_L(sn100u)) icode_send_eof = 0;
394 } else if (*p_len == 4 && p_ntf[0] == 0x40 && p_ntf[1] == 0x02 &&
395 p_ntf[2] == 0x01 && p_ntf[3] == 0x06) {
396 /*NXPLOG_NCIHAL_D("> Deinit workaround for LLCP set_config 0x%x 0x%x 0x%x",
397 p_ntf[21], p_ntf[22], p_ntf[23]);*/
398 p_ntf[0] = 0x40;
399 p_ntf[1] = 0x02;
400 p_ntf[2] = 0x02;
401 p_ntf[3] = 0x00;
402 p_ntf[4] = 0x00;
403 *p_len = 5;
404 }
405
406 if (p_ntf[0] == 0x60 && p_ntf[1] == 0x07 && p_ntf[2] == 0x01) {
407 if (p_ntf[3] == 0xEA) {
408 gsIsFwRecoveryRequired = true;
409 NXPLOG_NCIHAL_D("FW update required");
410 status = NFCSTATUS_FAILED;
411 } else if ((p_ntf[3] == 0xE5) || (p_ntf[3] == 0x60)) {
412 NXPLOG_NCIHAL_D("ignore core generic error");
413 status = NFCSTATUS_FAILED;
414 }
415 return status;
416 } else if (p_ntf[0] == 0x61 && p_ntf[1] == 0x21 && p_ntf[2] == 0x00) {
417 status = NFCSTATUS_FAILED;
418 NXPLOG_NCIHAL_D("ignore core generic error");
419 return status;
420 }
421 // 4200 02 00 01
422 else if (p_ntf[0] == 0x42 && p_ntf[1] == 0x00 && ee_disc_done == 0x01) {
423 NXPLOG_NCIHAL_D("Going through workaround - NFCEE_DISCOVER_RSP");
424 if (p_ntf[4] == 0x01) {
425 p_ntf[4] = 0x00;
426
427 ee_disc_done = 0x00;
428 }
429 NXPLOG_NCIHAL_D("Going through workaround - NFCEE_DISCOVER_RSP - END");
430
431 } else if (p_ntf[0] == 0x61 && p_ntf[1] == 0x03 /*&& cleanup_timer!=0*/) {
432 if (cleanup_timer != 0) {
433 /* if RF Notification Type of RF_DISCOVER_NTF is Last Notification */
434 if (0 == (*(p_ntf + 2 + (*(p_ntf + 2))))) {
435 phNxpNciHal_select_RF_Discovery(RfDiscID, RfProtocolType);
436 status = NFCSTATUS_FAILED;
437 return status;
438 } else {
439 RfDiscID = p_ntf[3];
440 RfProtocolType = p_ntf[4];
441 }
442 status = NFCSTATUS_FAILED;
443 return status;
444 }
445 } else if (p_ntf[0] == 0x41 && p_ntf[1] == 0x04 && cleanup_timer != 0) {
446 status = NFCSTATUS_FAILED;
447 return status;
448 } else if (*p_len == 4 && p_ntf[0] == 0x4F && p_ntf[1] == 0x11 &&
449 p_ntf[2] == 0x01) {
450 if (p_ntf[3] == 0x00) {
451 NXPLOG_NCIHAL_D(
452 "> Workaround for ISO-DEP Presence Check, ignore response and wait "
453 "for notification");
454 p_ntf[0] = 0x60;
455 p_ntf[1] = 0x06;
456 p_ntf[2] = 0x03;
457 p_ntf[3] = 0x01;
458 p_ntf[4] = 0x00;
459 p_ntf[5] = 0x01;
460 *p_len = 6;
461 } else {
462 NXPLOG_NCIHAL_D(
463 "> Workaround for ISO-DEP Presence Check, presence check return "
464 "failed");
465 p_ntf[0] = 0x60;
466 p_ntf[1] = 0x08;
467 p_ntf[2] = 0x02;
468 p_ntf[3] = 0xB2;
469 p_ntf[4] = 0x00;
470 *p_len = 5;
471 }
472 } else if (*p_len == 4 && p_ntf[0] == 0x6F && p_ntf[1] == 0x11 &&
473 p_ntf[2] == 0x01) {
474 if (p_ntf[3] == 0x01) {
475 NXPLOG_NCIHAL_D(
476 "> Workaround for ISO-DEP Presence Check - Card still in field");
477 p_ntf[0] = 0x00;
478 p_ntf[1] = 0x00;
479 p_ntf[2] = 0x01;
480 p_ntf[3] = 0x7E;
481 } else {
482 NXPLOG_NCIHAL_D(
483 "> Workaround for ISO-DEP Presence Check - Card not in field");
484 p_ntf[0] = 0x60;
485 p_ntf[1] = 0x08;
486 p_ntf[2] = 0x02;
487 p_ntf[3] = 0xB2;
488 p_ntf[4] = 0x00;
489 *p_len = 5;
490 }
491 }
492
493 return status;
494 }
495
496 /******************************************************************************
497 * Function phNxpNciHal_ext_process_nfc_init_rsp
498 *
499 * Description This function is used to process the HAL NFC core reset rsp
500 * and ntf and core init rsp of NCI 1.0 or NCI2.0 and update
501 * NCI version.
502 * It also handles error response such as core_reset_ntf with
503 * error status in both NCI2.0 and NCI1.0.
504 *
505 * Returns Returns NFCSTATUS_SUCCESS if parsing response is successful
506 * or returns failure.
507 *
508 ******************************************************************************/
phNxpNciHal_ext_process_nfc_init_rsp(uint8_t * p_ntf,uint16_t * p_len)509 static NFCSTATUS phNxpNciHal_ext_process_nfc_init_rsp(uint8_t* p_ntf,
510 uint16_t* p_len) {
511 NFCSTATUS status = NFCSTATUS_SUCCESS;
512 /* Parsing CORE_RESET_RSP and CORE_RESET_NTF to update NCI version.*/
513 if (p_ntf == NULL || *p_len < 2) {
514 return NFCSTATUS_FAILED;
515 }
516 if (p_ntf[0] == NCI_MT_RSP &&
517 ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_RESET)) {
518 if (*p_len < 4) {
519 android_errorWriteLog(0x534e4554, "169258455");
520 return NFCSTATUS_FAILED;
521 }
522 if (p_ntf[2] == 0x01 && p_ntf[3] == 0x00) {
523 NXPLOG_NCIHAL_D("CORE_RESET_RSP NCI2.0");
524 if (nxpncihal_ctrl.hal_ext_enabled == TRUE &&
525 nxpncihal_ctrl.isCoreRstForFwDnld != TRUE) {
526 nxpncihal_ctrl.nci_info.wait_for_ntf = TRUE;
527 }
528 } else if (p_ntf[2] == 0x03 && p_ntf[3] == 0x00) {
529 if (*p_len < 5) {
530 android_errorWriteLog(0x534e4554, "169258455");
531 return NFCSTATUS_FAILED;
532 }
533 NXPLOG_NCIHAL_D("CORE_RESET_RSP NCI1.0");
534 nxpncihal_ctrl.nci_info.nci_version = p_ntf[4];
535 } else
536 status = NFCSTATUS_FAILED;
537 } else if (p_ntf[0] == NCI_MT_NTF &&
538 ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_RESET)) {
539 if (*p_len < 4) {
540 android_errorWriteLog(0x534e4554, "169258455");
541 return NFCSTATUS_FAILED;
542 }
543 if (p_ntf[3] == CORE_RESET_TRIGGER_TYPE_CORE_RESET_CMD_RECEIVED) {
544 if (*p_len < 6) {
545 android_errorWriteLog(0x534e4554, "169258455");
546 return NFCSTATUS_FAILED;
547 }
548 NXPLOG_NCIHAL_D("CORE_RESET_NTF NCI2.0 reason CORE_RESET_CMD received !");
549 nxpncihal_ctrl.nci_info.nci_version = p_ntf[5];
550 if (!nxpncihal_ctrl.hal_open_status)
551 phNxpNciHal_configFeatureList(p_ntf, *p_len);
552 int len = p_ntf[2] + 2; /*include 2 byte header*/
553 if (len != *p_len - 1) {
554 NXPLOG_NCIHAL_E(
555 "phNxpNciHal_ext_process_nfc_init_rsp invalid NTF length");
556 android_errorWriteLog(0x534e4554, "121263487");
557 return NFCSTATUS_FAILED;
558 }
559 wFwVerRsp = (((uint32_t)p_ntf[len - 2]) << 16U) |
560 (((uint32_t)p_ntf[len - 1]) << 8U) | p_ntf[len];
561 NXPLOG_NCIHAL_D("NxpNci> FW Version: %x.%x.%x", p_ntf[len - 2],
562 p_ntf[len - 1], p_ntf[len]);
563 } else {
564 uint32_t i;
565 char print_buffer[*p_len * 3 + 1];
566
567 memset(print_buffer, 0, sizeof(print_buffer));
568 for (i = 0; i < *p_len; i++) {
569 snprintf(&print_buffer[i * 2], 3, "%02X", p_ntf[i]);
570 }
571 NXPLOG_NCIHAL_D("CORE_RESET_NTF received !");
572 NXPLOG_NCIR_E("len = %3d > %s", *p_len, print_buffer);
573 phNxpNciHal_emergency_recovery(p_ntf[3]);
574 status = NFCSTATUS_FAILED;
575 } /* Parsing CORE_INIT_RSP*/
576 } else if (p_ntf[0] == NCI_MT_RSP &&
577 ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_INIT)) {
578 if (nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0) {
579 NXPLOG_NCIHAL_D("CORE_INIT_RSP NCI2.0 received !");
580 if (IS_CHIP_TYPE_GE(sn220u)) {
581 /* Remove NFC-DEP interface support from INIT RESP */
582 RemoveNfcDepIntfFromInitResp(p_ntf, p_len);
583 }
584 } else {
585 NXPLOG_NCIHAL_D("CORE_INIT_RSP NCI1.0 received !");
586 if (!nxpncihal_ctrl.hal_open_status &&
587 nxpncihal_ctrl.nci_info.nci_version != NCI_VERSION_2_0) {
588 phNxpNciHal_configFeatureList(p_ntf, *p_len);
589 }
590 if (*p_len < 3) {
591 android_errorWriteLog(0x534e4554, "169258455");
592 return NFCSTATUS_FAILED;
593 }
594 int len = p_ntf[2] + 2; /*include 2 byte header*/
595 if (len != *p_len - 1) {
596 NXPLOG_NCIHAL_E(
597 "phNxpNciHal_ext_process_nfc_init_rsp invalid NTF length");
598 android_errorWriteLog(0x534e4554, "121263487");
599 return NFCSTATUS_FAILED;
600 }
601 wFwVerRsp = (((uint32_t)p_ntf[len - 2]) << 16U) |
602 (((uint32_t)p_ntf[len - 1]) << 8U) | p_ntf[len];
603 if (wFwVerRsp == 0) status = NFCSTATUS_FAILED;
604 iCoreInitRspLen = *p_len;
605 memcpy(bCoreInitRsp, p_ntf, *p_len);
606 NXPLOG_NCIHAL_D("NxpNci> FW Version: %x.%x.%x", p_ntf[len - 2],
607 p_ntf[len - 1], p_ntf[len]);
608 }
609 }
610 return status;
611 }
612
613 /******************************************************************************
614 * Function phNxpNciHal_process_ext_cmd_rsp
615 *
616 * Description This function process the extension command response. It
617 * also checks the received response to expected response.
618 *
619 * Returns returns NFCSTATUS_SUCCESS if response is as expected else
620 * returns failure.
621 *
622 ******************************************************************************/
phNxpNciHal_process_ext_cmd_rsp(uint16_t cmd_len,uint8_t * p_cmd)623 static NFCSTATUS phNxpNciHal_process_ext_cmd_rsp(uint16_t cmd_len,
624 uint8_t* p_cmd) {
625 NFCSTATUS status = NFCSTATUS_FAILED;
626 uint16_t data_written = 0;
627
628 /* Check NCI Command is well formed */
629 if (!phTmlNfc_IsFwDnldModeEnabled() &&
630 (cmd_len != (p_cmd[2] + NCI_MODE_HEADER_LEN))) {
631 NXPLOG_NCIHAL_E("NCI command not well formed");
632 return NFCSTATUS_FAILED;
633 }
634
635 /* Create the local semaphore */
636 if (phNxpNciHal_init_cb_data(&nxpncihal_ctrl.ext_cb_data, NULL) !=
637 NFCSTATUS_SUCCESS) {
638 NXPLOG_NCIHAL_D("Create ext_cb_data failed");
639 return NFCSTATUS_FAILED;
640 }
641
642 nxpncihal_ctrl.ext_cb_data.status = NFCSTATUS_SUCCESS;
643
644 /* Send ext command */
645 data_written = phNxpNciHal_write_unlocked(cmd_len, p_cmd, ORIG_NXPHAL);
646 if (data_written != cmd_len) {
647 NXPLOG_NCIHAL_D("phNxpNciHal_write failed for hal ext");
648 goto clean_and_return;
649 }
650
651 /* Start timer */
652 status = phOsalNfc_Timer_Start(timeoutTimerId, HAL_EXTNS_WRITE_RSP_TIMEOUT,
653 &hal_extns_write_rsp_timeout_cb, NULL);
654 if (NFCSTATUS_SUCCESS == status) {
655 NXPLOG_NCIHAL_D("Response timer started");
656 } else {
657 NXPLOG_NCIHAL_E("Response timer not started!!!");
658 status = NFCSTATUS_FAILED;
659 goto clean_and_return;
660 }
661
662 /* Wait for rsp */
663 NXPLOG_NCIHAL_D("Waiting after ext cmd sent");
664 if (SEM_WAIT(nxpncihal_ctrl.ext_cb_data)) {
665 NXPLOG_NCIHAL_E("p_hal_ext->ext_cb_data.sem semaphore error");
666 goto clean_and_return;
667 }
668
669 /* Stop Timer */
670 status = phOsalNfc_Timer_Stop(timeoutTimerId);
671 if (NFCSTATUS_SUCCESS == status) {
672 NXPLOG_NCIHAL_D("Response timer stopped");
673 } else {
674 NXPLOG_NCIHAL_E("Response timer stop ERROR!!!");
675 status = NFCSTATUS_FAILED;
676 goto clean_and_return;
677 }
678
679 if (cmd_len < 3) {
680 android_errorWriteLog(0x534e4554, "153880630");
681 status = NFCSTATUS_FAILED;
682 goto clean_and_return;
683 }
684
685 /* No NTF expected for OMAPI command */
686 if (p_cmd[0] == 0x2F && p_cmd[1] == 0x1 && p_cmd[2] == 0x01) {
687 nxpncihal_ctrl.nci_info.wait_for_ntf = FALSE;
688 }
689 /* Start timer to wait for NTF*/
690 if (nxpncihal_ctrl.nci_info.wait_for_ntf == TRUE) {
691 status = phOsalNfc_Timer_Start(timeoutTimerId, HAL_EXTNS_WRITE_RSP_TIMEOUT,
692 &hal_extns_write_rsp_timeout_cb, NULL);
693 if (NFCSTATUS_SUCCESS == status) {
694 NXPLOG_NCIHAL_D("Response timer started");
695 } else {
696 NXPLOG_NCIHAL_E("Response timer not started!!!");
697 status = NFCSTATUS_FAILED;
698 goto clean_and_return;
699 }
700 if (SEM_WAIT(nxpncihal_ctrl.ext_cb_data)) {
701 NXPLOG_NCIHAL_E("p_hal_ext->ext_cb_data.sem semaphore error");
702 /* Stop Timer */
703 status = phOsalNfc_Timer_Stop(timeoutTimerId);
704 goto clean_and_return;
705 }
706 status = phOsalNfc_Timer_Stop(timeoutTimerId);
707 if (NFCSTATUS_SUCCESS == status) {
708 NXPLOG_NCIHAL_D("Response timer stopped");
709 } else {
710 NXPLOG_NCIHAL_E("Response timer stop ERROR!!!");
711 status = NFCSTATUS_FAILED;
712 goto clean_and_return;
713 }
714 }
715
716 if (nxpncihal_ctrl.ext_cb_data.status != NFCSTATUS_SUCCESS) {
717 NXPLOG_NCIHAL_E(
718 "Callback Status is failed!! Timer Expired!! Couldn't read it! 0x%x",
719 nxpncihal_ctrl.ext_cb_data.status);
720 status = NFCSTATUS_FAILED;
721 goto clean_and_return;
722 }
723
724 NXPLOG_NCIHAL_D("Checking response");
725 status = NFCSTATUS_SUCCESS;
726
727 /*Response check for Set config, Core Reset & Core init command sent part of
728 * HAL_EXT*/
729 if (nxpncihal_ctrl.p_rx_data[0] == 0x40 &&
730 nxpncihal_ctrl.p_rx_data[1] <= 0x02 &&
731 nxpncihal_ctrl.p_rx_data[2] != 0x00) {
732 status = nxpncihal_ctrl.p_rx_data[3];
733 if (status != NCI_STATUS_OK) {
734 /*Add 500ms delay for FW to flush circular buffer */
735 usleep(500 * 1000);
736 NXPLOG_NCIHAL_D("Status Failed. Status = 0x%02x", status);
737 }
738 }
739
740 /*Response check for SYSTEM SET SERVICE STATUS command sent as part of
741 * HAL_EXT*/
742 if (IS_CHIP_TYPE_GE(sn220u) && nxpncihal_ctrl.p_rx_data[0] == 0x4F &&
743 nxpncihal_ctrl.p_rx_data[1] == 0x01 &&
744 nxpncihal_ctrl.p_rx_data[2] != 0x00) {
745 status = nxpncihal_ctrl.p_rx_data[3];
746 }
747
748 clean_and_return:
749 phNxpNciHal_cleanup_cb_data(&nxpncihal_ctrl.ext_cb_data);
750 nxpncihal_ctrl.nci_info.wait_for_ntf = FALSE;
751 HAL_DISABLE_EXT();
752 return status;
753 }
754
755 /******************************************************************************
756 * Function phNxpNciHal_write_ext
757 *
758 * Description This function inform the status of phNxpNciHal_open
759 * function to libnfc-nci.
760 *
761 * Returns It return NFCSTATUS_SUCCESS then continue with send else
762 * sends NFCSTATUS_FAILED direct response is prepared and
763 * do not send anything to NFCC.
764 *
765 ******************************************************************************/
phNxpNciHal_write_ext(uint16_t * cmd_len,uint8_t * p_cmd_data,uint16_t * rsp_len,uint8_t * p_rsp_data)766 NFCSTATUS phNxpNciHal_write_ext(uint16_t* cmd_len, uint8_t* p_cmd_data,
767 uint16_t* rsp_len, uint8_t* p_rsp_data) {
768 NFCSTATUS status = NFCSTATUS_SUCCESS;
769
770 phNxpNciHal_NfcDep_cmd_ext(p_cmd_data, cmd_len);
771
772 if (phNxpDta_IsEnable() == true) {
773 status = phNxpNHal_DtaUpdate(cmd_len, p_cmd_data, rsp_len, p_rsp_data);
774 }
775
776 if (p_cmd_data[0] == PROPRIETARY_CMD_FELICA_READER_MODE &&
777 p_cmd_data[1] == PROPRIETARY_CMD_FELICA_READER_MODE &&
778 p_cmd_data[2] == PROPRIETARY_CMD_FELICA_READER_MODE) {
779 NXPLOG_NCIHAL_D("Received proprietary command to set Felica Reader mode:%d",
780 p_cmd_data[3]);
781 gFelicaReaderMode = p_cmd_data[3];
782 /* frame the fake response */
783 *rsp_len = 4;
784 p_rsp_data[0] = 0x00;
785 p_rsp_data[1] = 0x00;
786 p_rsp_data[2] = 0x00;
787 p_rsp_data[3] = 0x00;
788 status = NFCSTATUS_FAILED;
789 } else if (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02 &&
790 (p_cmd_data[2] == 0x05 || p_cmd_data[2] == 0x32) &&
791 (p_cmd_data[3] == 0x01 || p_cmd_data[3] == 0x02) &&
792 p_cmd_data[4] == 0xA0 && p_cmd_data[5] == 0x44 &&
793 p_cmd_data[6] == 0x01 && p_cmd_data[7] == 0x01) {
794 nxpprofile_ctrl.profile_type = EMV_CO_PROFILE;
795 NXPLOG_NCIHAL_D("EMV_CO_PROFILE mode - Enabled");
796 status = NFCSTATUS_SUCCESS;
797 } else if (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02 &&
798 (p_cmd_data[2] == 0x05 || p_cmd_data[2] == 0x32) &&
799 (p_cmd_data[3] == 0x01 || p_cmd_data[3] == 0x02) &&
800 p_cmd_data[4] == 0xA0 && p_cmd_data[5] == 0x44 &&
801 p_cmd_data[6] == 0x01 && p_cmd_data[7] == 0x00) {
802 NXPLOG_NCIHAL_D("NFC_FORUM_PROFILE mode - Enabled");
803 nxpprofile_ctrl.profile_type = NFC_FORUM_PROFILE;
804 status = NFCSTATUS_SUCCESS;
805 }
806
807 if (nxpprofile_ctrl.profile_type == EMV_CO_PROFILE) {
808 if (p_cmd_data[0] == 0x21 && p_cmd_data[1] == 0x06 &&
809 p_cmd_data[2] == 0x01 && p_cmd_data[3] == 0x03) {
810 #if 0
811 //Needs clarification whether to keep it or not
812 NXPLOG_NCIHAL_D ("EmvCo Poll mode - RF Deactivate discard");
813 phNxpNciHal_print_packet("SEND", p_cmd_data, *cmd_len);
814 *rsp_len = 4;
815 p_rsp_data[0] = 0x41;
816 p_rsp_data[1] = 0x06;
817 p_rsp_data[2] = 0x01;
818 p_rsp_data[3] = 0x00;
819 phNxpNciHal_print_packet("RECV", p_rsp_data, 4);
820 status = NFCSTATUS_FAILED;
821 #endif
822 } else if (p_cmd_data[0] == 0x21 && p_cmd_data[1] == 0x03) {
823 NXPLOG_NCIHAL_D("EmvCo Poll mode - Discover map only for A and B");
824 p_cmd_data[2] = 0x05;
825 p_cmd_data[3] = 0x02;
826 p_cmd_data[4] = 0x00;
827 p_cmd_data[5] = 0x01;
828 p_cmd_data[6] = 0x01;
829 p_cmd_data[7] = 0x01;
830 *cmd_len = 8;
831 }
832 }
833
834 if (mfc_mode == true && p_cmd_data[0] == 0x21 && p_cmd_data[1] == 0x03) {
835 NXPLOG_NCIHAL_D("EmvCo Poll mode - Discover map only for A and B");
836 p_cmd_data[2] = 0x03;
837 p_cmd_data[3] = 0x01;
838 p_cmd_data[4] = 0x00;
839 p_cmd_data[5] = 0x01;
840 *cmd_len = 6;
841 mfc_mode = false;
842 }
843
844 if (*cmd_len <= (NCI_MAX_DATA_LEN - 3) && bEnableMfcReader &&
845 (p_cmd_data[0] == 0x21 && p_cmd_data[1] == 0x00) &&
846 (nxpprofile_ctrl.profile_type == NFC_FORUM_PROFILE)) {
847 unsigned long retval = 0;
848 if (p_cmd_data[2] == 0x04 && p_cmd_data[3] == 0x01 &&
849 p_cmd_data[4] == 0x80 && p_cmd_data[5] == 0x01 &&
850 p_cmd_data[6] == 0x83) {
851 mfc_mode = true;
852 } else {
853 if (!GetNxpNumValue(NAME_MIFARE_READER_ENABLE, &retval,
854 sizeof(unsigned long))) {
855 NXPLOG_NCIHAL_E(
856 "Reading of MIFARE_READER_ENABLE failed. Default retval = %lu",
857 retval);
858 }
859 if (retval == 0x01) {
860 NXPLOG_NCIHAL_D("Going through extns - Adding Mifare in RF Discovery");
861 p_cmd_data[2] += 3;
862 p_cmd_data[3] += 1;
863 p_cmd_data[*cmd_len] = 0x80;
864 p_cmd_data[*cmd_len + 1] = 0x01;
865 p_cmd_data[*cmd_len + 2] = 0x80;
866 *cmd_len += 3;
867 status = NFCSTATUS_SUCCESS;
868 NXPLOG_NCIHAL_D(
869 "Going through extns - Adding Mifare in RF Discovery - END");
870 }
871 }
872 } else if ((*cmd_len >= 6) &&
873 (p_cmd_data[3] == 0x81 && p_cmd_data[4] == 0x01 &&
874 p_cmd_data[5] == 0x03)) {
875 NXPLOG_NCIHAL_D("> Going through the set host list");
876 if (IS_CHIP_TYPE_GE(sn100u)) {
877 *cmd_len = 10;
878
879 p_cmd_data[2] = 0x07;
880
881 p_cmd_data[6] = 0x02;
882 p_cmd_data[7] = 0x80;
883 p_cmd_data[8] = 0x81;
884 p_cmd_data[9] = 0xC0;
885 } else {
886 *cmd_len = 8;
887
888 p_cmd_data[2] = 0x05;
889 p_cmd_data[6] = 0x02;
890 p_cmd_data[7] = 0xC0;
891 }
892 status = NFCSTATUS_SUCCESS;
893 } else if (icode_detected) {
894 if (IS_CHIP_TYPE_L(sn100u) && IS_CHIP_TYPE_NE(pn557) &&
895 (p_cmd_data[3] & 0x40) == 0x40 &&
896 (p_cmd_data[4] == 0x21 || p_cmd_data[4] == 0x22 ||
897 p_cmd_data[4] == 0x24 || p_cmd_data[4] == 0x27 ||
898 p_cmd_data[4] == 0x28 || p_cmd_data[4] == 0x29 ||
899 p_cmd_data[4] == 0x2a)) {
900 NXPLOG_NCIHAL_D("> Send EOF set");
901 icode_send_eof = 1;
902 }
903
904 if (p_cmd_data[3] == 0x20 || p_cmd_data[3] == 0x24 ||
905 p_cmd_data[3] == 0x60) {
906 NXPLOG_NCIHAL_D("> NFC ISO_15693 Proprietary CMD ");
907 p_cmd_data[3] += 0x02;
908 }
909 } else if (p_cmd_data[0] == 0x21 && p_cmd_data[1] == 0x03) {
910 NXPLOG_NCIHAL_D("> Polling Loop Started");
911 icode_detected = 0;
912 if (IS_CHIP_TYPE_L(sn100u)) {
913 icode_send_eof = 0;
914 }
915 }
916 // 22000100
917 else if (p_cmd_data[0] == 0x22 && p_cmd_data[1] == 0x00 &&
918 p_cmd_data[2] == 0x01 && p_cmd_data[3] == 0x00) {
919 // ee_disc_done = 0x01;//Reader Over SWP event getting
920 *rsp_len = 0x05;
921 p_rsp_data[0] = 0x42;
922 p_rsp_data[1] = 0x00;
923 p_rsp_data[2] = 0x02;
924 p_rsp_data[3] = 0x00;
925 p_rsp_data[4] = 0x00;
926 phNxpNciHal_print_packet("RECV", p_rsp_data, 5);
927 status = NFCSTATUS_FAILED;
928 }
929 // 2002 0904 3000 3100 3200 5000
930 else if (*cmd_len <= (NCI_MAX_DATA_LEN - 1) &&
931 (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02) &&
932 ((p_cmd_data[2] == 0x09 && p_cmd_data[3] == 0x04) /*||
933 (p_cmd_data[2] == 0x0D && p_cmd_data[3] == 0x04)*/
934 )) {
935 *cmd_len += 0x01;
936 p_cmd_data[2] += 0x01;
937 p_cmd_data[9] = 0x01;
938 p_cmd_data[10] = 0x40;
939 p_cmd_data[11] = 0x50;
940 p_cmd_data[12] = 0x00;
941
942 NXPLOG_NCIHAL_D("> Going through workaround - Dirty Set Config ");
943 // phNxpNciHal_print_packet("SEND", p_cmd_data, *cmd_len);
944 NXPLOG_NCIHAL_D("> Going through workaround - Dirty Set Config - End ");
945 }
946 // 20020703300031003200
947 // 2002 0301 3200
948 else if ((p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02) &&
949 ((p_cmd_data[2] == 0x07 && p_cmd_data[3] == 0x03) ||
950 (p_cmd_data[2] == 0x03 && p_cmd_data[3] == 0x01 &&
951 p_cmd_data[4] == 0x32))) {
952 NXPLOG_NCIHAL_D("> Going through workaround - Dirty Set Config ");
953 phNxpNciHal_print_packet("SEND", p_cmd_data, *cmd_len);
954 *rsp_len = 5;
955 p_rsp_data[0] = 0x40;
956 p_rsp_data[1] = 0x02;
957 p_rsp_data[2] = 0x02;
958 p_rsp_data[3] = 0x00;
959 p_rsp_data[4] = 0x00;
960
961 phNxpNciHal_print_packet("RECV", p_rsp_data, 5);
962 status = NFCSTATUS_FAILED;
963 NXPLOG_NCIHAL_D("> Going through workaround - Dirty Set Config - End ");
964 }
965
966 // 2002 0D04 300104 310100 320100 500100
967 // 2002 0401 320100
968 else if ((p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02) &&
969 (
970 /*(p_cmd_data[2] == 0x0D && p_cmd_data[3] == 0x04)*/
971 (p_cmd_data[2] == 0x04 && p_cmd_data[3] == 0x01 &&
972 p_cmd_data[4] == 0x32 && p_cmd_data[5] == 0x00))) {
973 // p_cmd_data[12] = 0x40;
974
975 NXPLOG_NCIHAL_D("> Going through workaround - Dirty Set Config ");
976 phNxpNciHal_print_packet("SEND", p_cmd_data, *cmd_len);
977 p_cmd_data[6] = 0x60;
978
979 phNxpNciHal_print_packet("RECV", p_rsp_data, 5);
980 // status = NFCSTATUS_FAILED;
981 NXPLOG_NCIHAL_D("> Going through workaround - Dirty Set Config - End ");
982 }
983 #if 0
984 else if ( (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02 ) &&
985 ((p_cmd_data[2] == 0x09 && p_cmd_data[3] == 0x04) ||
986 (p_cmd_data[2] == 0x0B && p_cmd_data[3] == 0x05) ||
987 (p_cmd_data[2] == 0x07 && p_cmd_data[3] == 0x02) ||
988 (p_cmd_data[2] == 0x0A && p_cmd_data[3] == 0x03) ||
989 (p_cmd_data[2] == 0x0A && p_cmd_data[3] == 0x04) ||
990 (p_cmd_data[2] == 0x05 && p_cmd_data[3] == 0x02))
991 )
992 {
993 NXPLOG_NCIHAL_D ("> Going through workaround - Dirty Set Config ");
994 phNxpNciHal_print_packet("SEND", p_cmd_data, *cmd_len);
995 *rsp_len = 5;
996 p_rsp_data[0] = 0x40;
997 p_rsp_data[1] = 0x02;
998 p_rsp_data[2] = 0x02;
999 p_rsp_data[3] = 0x00;
1000 p_rsp_data[4] = 0x00;
1001
1002 phNxpNciHal_print_packet("RECV", p_rsp_data, 5);
1003 status = NFCSTATUS_FAILED;
1004 NXPLOG_NCIHAL_D ("> Going through workaround - Dirty Set Config - End ");
1005 }
1006
1007 else if((p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x02) &&
1008 ((p_cmd_data[3] == 0x00) ||
1009 ((*cmd_len >= 0x06) && (p_cmd_data[5] == 0x00)))) /*If the length of the first param id is zero don't allow*/
1010 {
1011 NXPLOG_NCIHAL_D ("> Going through workaround - Dirty Set Config ");
1012 phNxpNciHal_print_packet("SEND", p_cmd_data, *cmd_len);
1013 *rsp_len = 5;
1014 p_rsp_data[0] = 0x40;
1015 p_rsp_data[1] = 0x02;
1016 p_rsp_data[2] = 0x02;
1017 p_rsp_data[3] = 0x00;
1018 p_rsp_data[4] = 0x00;
1019
1020 phNxpNciHal_print_packet("RECV", p_rsp_data, 5);
1021 status = NFCSTATUS_FAILED;
1022 NXPLOG_NCIHAL_D ("> Going through workaround - Dirty Set Config - End ");
1023 }
1024 #endif
1025 else if ((wFwVerRsp & 0x0000FFFF) == wFwVer) {
1026 /* skip CORE_RESET and CORE_INIT from Brcm */
1027 if (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x00 &&
1028 p_cmd_data[2] == 0x01 && p_cmd_data[3] == 0x01) {
1029 // *rsp_len = 6;
1030 //
1031 // NXPLOG_NCIHAL_D("> Going - core reset optimization");
1032 //
1033 // p_rsp_data[0] = 0x40;
1034 // p_rsp_data[1] = 0x00;
1035 // p_rsp_data[2] = 0x03;
1036 // p_rsp_data[3] = 0x00;
1037 // p_rsp_data[4] = 0x10;
1038 // p_rsp_data[5] = 0x01;
1039 //
1040 // status = NFCSTATUS_FAILED;
1041 // NXPLOG_NCIHAL_D("> Going - core reset optimization - END");
1042 }
1043 /* CORE_INIT */
1044 else if (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x01 &&
1045 p_cmd_data[2] == 0x00) {
1046 // NXPLOG_NCIHAL_D("> Going - core init optimization");
1047 // *rsp_len = iCoreInitRspLen;
1048 // memcpy(p_rsp_data, bCoreInitRsp, iCoreInitRspLen);
1049 // status = NFCSTATUS_FAILED;
1050 // NXPLOG_NCIHAL_D("> Going - core init optimization - END");
1051 }
1052 }
1053 /* CORE_SET_POWER_SUB_STATE */
1054 if (p_cmd_data[0] == 0x20 && p_cmd_data[1] == 0x09 && p_cmd_data[2] == 0x01 &&
1055 (p_cmd_data[3] == 0x00 || p_cmd_data[3] == 0x02)) {
1056 // Sync power tracker data for screen on transition.
1057 if (gPowerTrackerHandle.stateChange != NULL) {
1058 gPowerTrackerHandle.stateChange(SCREEN_ON);
1059 }
1060 }
1061
1062 return status;
1063 }
1064
1065 /******************************************************************************
1066 * Function phNxpNciHal_send_ext_cmd
1067 *
1068 * Description This function send the extension command to NFCC. No
1069 * response is checked by this function but it waits for
1070 * the response to come.
1071 *
1072 * Returns Returns NFCSTATUS_SUCCESS if sending cmd is successful and
1073 * response is received.
1074 *
1075 ******************************************************************************/
phNxpNciHal_send_ext_cmd(uint16_t cmd_len,uint8_t * p_cmd)1076 NFCSTATUS phNxpNciHal_send_ext_cmd(uint16_t cmd_len, uint8_t* p_cmd) {
1077 NFCSTATUS status = NFCSTATUS_FAILED;
1078 nxpncihal_ctrl.cmd_len = cmd_len;
1079 memcpy(nxpncihal_ctrl.p_cmd_data, p_cmd, cmd_len);
1080 status = phNxpNciHal_process_ext_cmd_rsp(nxpncihal_ctrl.cmd_len,
1081 nxpncihal_ctrl.p_cmd_data);
1082
1083 return status;
1084 }
1085
1086 /******************************************************************************
1087 * Function phNxpNciHal_send_ese_hal_cmd
1088 *
1089 * Description This function send the extension command to NFCC. No
1090 * response is checked by this function but it waits for
1091 * the response to come.
1092 *
1093 * Returns Returns NFCSTATUS_SUCCESS if sending cmd is successful and
1094 * response is received.
1095 *
1096 ******************************************************************************/
phNxpNciHal_send_ese_hal_cmd(uint16_t cmd_len,uint8_t * p_cmd)1097 NFCSTATUS phNxpNciHal_send_ese_hal_cmd(uint16_t cmd_len, uint8_t* p_cmd) {
1098 NFCSTATUS status = NFCSTATUS_FAILED;
1099 if (cmd_len > NCI_MAX_DATA_LEN) {
1100 NXPLOG_NCIHAL_E("cmd_len exceeds limit NCI_MAX_DATA_LEN");
1101 return status;
1102 }
1103 nxpncihal_ctrl.cmd_len = cmd_len;
1104 memcpy(nxpncihal_ctrl.p_cmd_data, p_cmd, cmd_len);
1105 status = phNxpNciHal_process_ext_cmd_rsp(nxpncihal_ctrl.cmd_len,
1106 nxpncihal_ctrl.p_cmd_data);
1107 return status;
1108 }
1109
1110 /******************************************************************************
1111 * Function hal_extns_write_rsp_timeout_cb
1112 *
1113 * Description Timer call back function
1114 *
1115 * Returns None
1116 *
1117 ******************************************************************************/
hal_extns_write_rsp_timeout_cb(uint32_t timerId,void * pContext)1118 static void hal_extns_write_rsp_timeout_cb(uint32_t timerId, void* pContext) {
1119 UNUSED_PROP(timerId);
1120 UNUSED_PROP(pContext);
1121 NXPLOG_NCIHAL_D("hal_extns_write_rsp_timeout_cb - write timeout!!!");
1122 nxpncihal_ctrl.ext_cb_data.status = NFCSTATUS_FAILED;
1123 usleep(1);
1124 sem_post(&(nxpncihal_ctrl.syncSpiNfc));
1125 SEM_POST(&(nxpncihal_ctrl.ext_cb_data));
1126
1127 return;
1128 }
1129
1130 /*******************************************************************************
1131 **
1132 ** Function: request_EEPROM()
1133 **
1134 ** Description: get and set EEPROM data
1135 ** In case of request_modes GET_EEPROM_DATA or
1136 *SET_EEPROM_DATA,
1137 ** 1.caller has to pass the buffer and the length of data
1138 *required
1139 ** to be read/written.
1140 ** 2.Type of information required to be read/written
1141 ** (Example - EEPROM_RF_CFG)
1142 **
1143 ** Returns: Returns NFCSTATUS_SUCCESS if sending cmd is successful and
1144 ** status failed if not successful
1145 **
1146 *******************************************************************************/
request_EEPROM(phNxpNci_EEPROM_info_t * mEEPROM_info)1147 NFCSTATUS request_EEPROM(phNxpNci_EEPROM_info_t* mEEPROM_info) {
1148 NXPLOG_NCIHAL_D(
1149 "%s Enter request_type : 0x%02x, request_mode : 0x%02x, bufflen : "
1150 "0x%02x",
1151 __func__, mEEPROM_info->request_type, mEEPROM_info->request_mode,
1152 mEEPROM_info->bufflen);
1153 NFCSTATUS status = NFCSTATUS_FAILED;
1154 uint8_t retry_cnt = 0;
1155 uint8_t getCfgStartIndex = 0x08;
1156 uint8_t setCfgStartIndex = 0x07;
1157 uint8_t memIndex = 0x00;
1158 uint8_t fieldLen = 0x01; // Memory field len 1bytes
1159 char addr[2] = {0};
1160 uint8_t cur_value = 0, len = 5;
1161 uint8_t b_position = 0;
1162 bool_t update_req = false;
1163 uint16_t set_cfg_cmd_len = 0;
1164 uint8_t *set_cfg_eeprom, *base_addr;
1165
1166 mEEPROM_info->update_mode = BITWISE;
1167
1168 switch (mEEPROM_info->request_type) {
1169 case EEPROM_RF_CFG:
1170 memIndex = 0x00;
1171 fieldLen = 0x20;
1172 len = fieldLen + 4; // 4 - numParam+2add+val
1173 addr[0] = 0xA0;
1174 addr[1] = 0x14;
1175 mEEPROM_info->update_mode = BYTEWISE;
1176 break;
1177
1178 case EEPROM_FW_DWNLD:
1179 fieldLen = 0x20;
1180 memIndex = 0x0C;
1181 len = fieldLen + 4;
1182 addr[0] = 0xA0;
1183 addr[1] = 0x0F;
1184 mEEPROM_info->update_mode = BYTEWISE;
1185 break;
1186
1187 case EEPROM_WIREDMODE_RESUME_TIMEOUT:
1188 mEEPROM_info->update_mode = BYTEWISE;
1189 memIndex = 0x00;
1190 fieldLen = 0x04;
1191 len = fieldLen + 4;
1192 addr[0] = 0xA0;
1193 addr[1] = 0xFC;
1194 break;
1195
1196 case EEPROM_ESE_SVDD_POWER:
1197 b_position = 0;
1198 memIndex = 0x00;
1199 addr[0] = 0xA0;
1200 addr[1] = 0xF2;
1201 break;
1202 case EEPROM_ESE_POWER_EXT_PMU:
1203 mEEPROM_info->update_mode = BYTEWISE;
1204 memIndex = 0x00;
1205 addr[0] = 0xA0;
1206 addr[1] = 0xD7;
1207 break;
1208
1209 case EEPROM_PROP_ROUTING:
1210 b_position = 7;
1211 memIndex = 0x00;
1212 addr[0] = 0xA0;
1213 addr[1] = 0x98;
1214 break;
1215
1216 case EEPROM_ESE_SESSION_ID:
1217 b_position = 0;
1218 memIndex = 0x00;
1219 addr[0] = 0xA0;
1220 addr[1] = 0xEB;
1221 break;
1222
1223 case EEPROM_SWP1_INTF:
1224 b_position = 0;
1225 memIndex = 0x00;
1226 addr[0] = 0xA0;
1227 addr[1] = 0xEC;
1228 break;
1229
1230 case EEPROM_SWP1A_INTF:
1231 b_position = 0;
1232 memIndex = 0x00;
1233 addr[0] = 0xA0;
1234 addr[1] = 0xD4;
1235 break;
1236 case EEPROM_SWP2_INTF:
1237 b_position = 0;
1238 memIndex = 0x00;
1239 addr[0] = 0xA0;
1240 addr[1] = 0xED;
1241 break;
1242 case EEPROM_FLASH_UPDATE:
1243 /* This flag is no more used in MW */
1244 fieldLen = 0x20;
1245 memIndex = 0x00;
1246 len = fieldLen + 4;
1247 addr[0] = 0xA0;
1248 addr[1] = 0x0F;
1249 break;
1250 case EEPROM_AUTH_CMD_TIMEOUT:
1251 mEEPROM_info->update_mode = BYTEWISE;
1252 memIndex = 0x00;
1253 fieldLen = mEEPROM_info->bufflen;
1254 len = fieldLen + 4;
1255 addr[0] = 0xA0;
1256 addr[1] = 0xF7;
1257 break;
1258 case EEPROM_GUARD_TIMER:
1259 mEEPROM_info->update_mode = BYTEWISE;
1260 memIndex = 0x00;
1261 addr[0] = 0xA1;
1262 addr[1] = 0x0B;
1263 break;
1264 case EEPROM_AUTONOMOUS_MODE:
1265 mEEPROM_info->update_mode = BYTEWISE;
1266 memIndex = 0x00;
1267 addr[0] = 0xA0;
1268 addr[1] = 0x15;
1269 break;
1270 case EEPROM_T4T_NFCEE_ENABLE:
1271 mEEPROM_info->update_mode = BYTEWISE;
1272 b_position = 0;
1273 memIndex = 0x00;
1274 addr[0] = 0xA0;
1275 addr[1] = 0x95;
1276 break;
1277 case EEPROM_CE_PHONE_OFF_CFG:
1278 mEEPROM_info->update_mode = BYTEWISE;
1279 b_position = 0;
1280 memIndex = 0x00;
1281 addr[0] = 0xA0;
1282 addr[1] = 0x8E;
1283 break;
1284 case EEPROM_ENABLE_VEN_CFG:
1285 mEEPROM_info->update_mode = BYTEWISE;
1286 b_position = 0;
1287 memIndex = 0x00;
1288 addr[0] = 0xA0;
1289 addr[1] = 0x07;
1290 break;
1291 case EEPROM_ISODEP_MERGE_SAK:
1292 mEEPROM_info->update_mode = BYTEWISE;
1293 b_position = 0;
1294 memIndex = 0x00;
1295 addr[0] = 0xA1;
1296 addr[1] = 0x1B;
1297 break;
1298 case EEPROM_SRD_TIMEOUT:
1299 mEEPROM_info->update_mode = BYTEWISE;
1300 memIndex = 0x00;
1301 fieldLen = 0x02;
1302 len = fieldLen + 4;
1303 addr[0] = 0xA1;
1304 addr[1] = 0x17;
1305 break;
1306 case EEPROM_UICC1_SESSION_ID:
1307 fieldLen = mEEPROM_info->bufflen;
1308 len = fieldLen + 4;
1309 memIndex = 0x00;
1310 addr[0] = 0xA0;
1311 addr[1] = 0xE4;
1312 mEEPROM_info->update_mode = BYTEWISE;
1313 break;
1314 case EEPROM_UICC2_SESSION_ID:
1315 fieldLen = mEEPROM_info->bufflen;
1316 len = fieldLen + 4;
1317 memIndex = 0x00;
1318 addr[0] = 0xA0;
1319 addr[1] = 0xE5;
1320 mEEPROM_info->update_mode = BYTEWISE;
1321 break;
1322 case EEPROM_CE_ACT_NTF:
1323 mEEPROM_info->update_mode = BYTEWISE;
1324 b_position = 0;
1325 memIndex = 0x00;
1326 addr[0] = 0xA0;
1327 addr[1] = 0x96;
1328 break;
1329 case EEPROM_UICC_HCI_CE_STATE:
1330 fieldLen = mEEPROM_info->bufflen;
1331 len = fieldLen + 4;
1332 memIndex = 0x00;
1333 addr[0] = 0xA0;
1334 addr[1] = 0xE6;
1335 mEEPROM_info->update_mode = BYTEWISE;
1336 break;
1337 case EEPROM_EXT_FIELD_DETECT_MODE:
1338 mEEPROM_info->update_mode = BYTEWISE;
1339 b_position = 0;
1340 memIndex = 0x00;
1341 addr[0] = 0xA1;
1342 addr[1] = 0x36;
1343 break;
1344 case EEPROM_CONF_GPIO_CTRL:
1345 mEEPROM_info->update_mode = BYTEWISE;
1346 memIndex = 0x00;
1347 fieldLen = mEEPROM_info->bufflen;
1348 len = fieldLen + 4;
1349 addr[0] = 0xA1;
1350 addr[1] = 0x0F;
1351 break;
1352 case EEPROM_SET_GPIO_VALUE:
1353 mEEPROM_info->update_mode = BYTEWISE;
1354 memIndex = 0x00;
1355 fieldLen = mEEPROM_info->bufflen;
1356 len = fieldLen + 4;
1357 addr[0] = 0xA1;
1358 addr[1] = 0x65;
1359 break;
1360 case EEPROM_POWER_TRACKER_ENABLE:
1361 mEEPROM_info->update_mode = BYTEWISE;
1362 memIndex = 0x00;
1363 fieldLen = mEEPROM_info->bufflen;
1364 len = fieldLen + 4;
1365 addr[0] = 0xA0;
1366 addr[1] = 0x6D;
1367 break;
1368 default:
1369 ALOGE("No valid request information found");
1370 break;
1371 }
1372
1373 uint8_t get_cfg_eeprom[6] = {
1374 0x20, // get_cfg header
1375 0x03, // get_cfg header
1376 0x03, // len of following value
1377 0x01, // Num Parameters
1378 (uint8_t)addr[0], // First byte of Address
1379 (uint8_t)addr[1] // Second byte of Address
1380 };
1381 uint8_t set_cfg_cmd_hdr[7] = {
1382 0x20, // set_cfg header
1383 0x02, // set_cfg header
1384 len, // len of following value
1385 0x01, // Num Param
1386 (uint8_t)addr[0], // First byte of Address
1387 (uint8_t)addr[1], // Second byte of Address
1388 fieldLen // Data len
1389 };
1390
1391 set_cfg_cmd_len = sizeof(set_cfg_cmd_hdr) + fieldLen;
1392 set_cfg_eeprom = (uint8_t*)malloc(set_cfg_cmd_len);
1393 if (set_cfg_eeprom == NULL) {
1394 ALOGE("memory allocation failed");
1395 return status;
1396 }
1397 base_addr = set_cfg_eeprom;
1398 memset(set_cfg_eeprom, 0, set_cfg_cmd_len);
1399 memcpy(set_cfg_eeprom, set_cfg_cmd_hdr, sizeof(set_cfg_cmd_hdr));
1400
1401 retryget:
1402 status = phNxpNciHal_send_ext_cmd(sizeof(get_cfg_eeprom), get_cfg_eeprom);
1403 if (status == NFCSTATUS_SUCCESS) {
1404 status = nxpncihal_ctrl.p_rx_data[3];
1405 if (status != NFCSTATUS_SUCCESS) {
1406 ALOGE("failed to get requested memory address");
1407 } else if (mEEPROM_info->request_mode == GET_EEPROM_DATA) {
1408 if (mEEPROM_info->bufflen == 0xFF) {
1409 /* Max bufferlenth for single Get Config Command is 0xFF.
1410 * If buffer length set to max value, reassign buffer value
1411 * depends on response from Get Config command */
1412 mEEPROM_info->bufflen =
1413 *(nxpncihal_ctrl.p_rx_data + getCfgStartIndex + memIndex - 1);
1414 }
1415 memcpy(mEEPROM_info->buffer,
1416 nxpncihal_ctrl.p_rx_data + getCfgStartIndex + memIndex,
1417 mEEPROM_info->bufflen);
1418 } else if (mEEPROM_info->request_mode == SET_EEPROM_DATA) {
1419 // Clear the buffer first
1420 memset(set_cfg_eeprom + setCfgStartIndex, 0x00,
1421 (set_cfg_cmd_len - setCfgStartIndex));
1422
1423 // copy get config data into set_cfg_eeprom
1424 memcpy(set_cfg_eeprom + setCfgStartIndex,
1425 nxpncihal_ctrl.p_rx_data + getCfgStartIndex, fieldLen);
1426 if (mEEPROM_info->update_mode == BITWISE) {
1427 cur_value =
1428 (set_cfg_eeprom[setCfgStartIndex + memIndex] >> b_position) & 0x01;
1429 if (cur_value != mEEPROM_info->buffer[0]) {
1430 update_req = true;
1431 if (mEEPROM_info->buffer[0] == 1) {
1432 set_cfg_eeprom[setCfgStartIndex + memIndex] |= (1 << b_position);
1433 } else if (mEEPROM_info->buffer[0] == 0) {
1434 set_cfg_eeprom[setCfgStartIndex + memIndex] &= (~(1 << b_position));
1435 }
1436 }
1437 } else if (mEEPROM_info->update_mode == BYTEWISE) {
1438 if (memcmp(set_cfg_eeprom + setCfgStartIndex + memIndex,
1439 mEEPROM_info->buffer, mEEPROM_info->bufflen)) {
1440 update_req = true;
1441 memcpy(set_cfg_eeprom + setCfgStartIndex + memIndex,
1442 mEEPROM_info->buffer, mEEPROM_info->bufflen);
1443 }
1444 } else {
1445 ALOGE("%s, invalid update mode", __func__);
1446 }
1447
1448 if (update_req) {
1449 // do set config
1450 retryset:
1451 status = phNxpNciHal_send_ext_cmd(set_cfg_cmd_len, set_cfg_eeprom);
1452 if (status != NFCSTATUS_SUCCESS && retry_cnt < 3) {
1453 retry_cnt++;
1454 ALOGE("Set Cfg Retry cnt=%x", retry_cnt);
1455 goto retryset;
1456 }
1457 } else {
1458 ALOGD("%s: values are same no update required", __func__);
1459 }
1460 }
1461 } else if (retry_cnt < 3) {
1462 retry_cnt++;
1463 ALOGE("Get Cfg Retry cnt=%x", retry_cnt);
1464 goto retryget;
1465 }
1466
1467 if (base_addr != NULL) {
1468 free(base_addr);
1469 base_addr = NULL;
1470 }
1471 retry_cnt = 0;
1472 return status;
1473 }
1474
1475 /*******************************************************************************
1476 **
1477 ** Function: phNxpNciHal_enableDefaultUICC2SWPline()
1478 **
1479 ** Description: Select UICC2 or UICC3
1480 **
1481 ** Returns: status
1482 **
1483 ********************************************************************************/
phNxpNciHal_enableDefaultUICC2SWPline(uint8_t uicc2_sel)1484 NFCSTATUS phNxpNciHal_enableDefaultUICC2SWPline(uint8_t uicc2_sel) {
1485 NFCSTATUS status = NFCSTATUS_FAILED;
1486 uint8_t p_data[255] = {NCI_MT_CMD, NXP_CORE_SET_CONFIG_CMD};
1487 uint8_t LEN_INDEX = 2, PARAM_INDEX = 3;
1488 uint8_t* p = p_data;
1489 NXPLOG_NCIHAL_D("phNxpNciHal_enableDefaultUICC2SWPline %d", uicc2_sel);
1490 p_data[LEN_INDEX] = 1;
1491 p += 4;
1492 if (uicc2_sel == 0x03) {
1493 UINT8_TO_STREAM(p, NXP_NFC_SET_CONFIG_PARAM_EXT);
1494 UINT8_TO_STREAM(p, NXP_NFC_PARAM_ID_SWP2);
1495 UINT8_TO_STREAM(p, 0x01);
1496 UINT8_TO_STREAM(p, 0x01);
1497 p_data[LEN_INDEX] += 4;
1498 p_data[PARAM_INDEX] += 1;
1499 }
1500 if (uicc2_sel == 0x04) {
1501 UINT8_TO_STREAM(p, NXP_NFC_SET_CONFIG_PARAM_EXT);
1502 UINT8_TO_STREAM(p, NXP_NFC_PARAM_ID_SWPUICC3);
1503 UINT8_TO_STREAM(p, 0x01);
1504 UINT8_TO_STREAM(p, 0x01);
1505 p_data[LEN_INDEX] += 4;
1506 p_data[PARAM_INDEX] += 1;
1507 }
1508 if (p_data[PARAM_INDEX] > 0x00)
1509 status = phNxpNciHal_send_ext_cmd(p - p_data, p_data);
1510 return status;
1511 }
1512
1513 /******************************************************************************
1514 * Function phNxpNciHal_prop_conf_lpcd
1515 *
1516 * Description If NFCC is not in Nfc Forum mode, then this function will
1517 * configure it back to the Nfc Forum mode.
1518 *
1519 * Returns none
1520 *
1521 ******************************************************************************/
phNxpNciHal_prop_conf_lpcd(bool enableLPCD)1522 void phNxpNciHal_prop_conf_lpcd(bool enableLPCD) {
1523 uint8_t cmd_get_lpcdval[] = {0x20, 0x03, 0x03, 0x01, 0xA0, 0x68};
1524 vector<uint8_t> cmd_set_lpcdval{0x20, 0x02, 0x2E};
1525
1526 if (NFCSTATUS_SUCCESS ==
1527 phNxpNciHal_send_ext_cmd(sizeof(cmd_get_lpcdval), cmd_get_lpcdval)) {
1528 if (NFCSTATUS_SUCCESS == nxpncihal_ctrl.p_rx_data[3]) {
1529 if (!(nxpncihal_ctrl.p_rx_data[17] & (1 << 7)) && enableLPCD) {
1530 nxpncihal_ctrl.p_rx_data[17] |= (1 << 7);
1531 cmd_set_lpcdval.insert(
1532 cmd_set_lpcdval.end(), &nxpncihal_ctrl.p_rx_data[4],
1533 (&nxpncihal_ctrl.p_rx_data[4] + cmd_set_lpcdval[2]));
1534 if (NFCSTATUS_SUCCESS ==
1535 phNxpNciHal_send_ext_cmd(cmd_set_lpcdval.size(),
1536 &cmd_set_lpcdval[0])) {
1537 return;
1538 }
1539 } else if (!enableLPCD && (nxpncihal_ctrl.p_rx_data[17] & (1 << 7))) {
1540 nxpncihal_ctrl.p_rx_data[17] &= ~(1 << 7);
1541 cmd_set_lpcdval.insert(
1542 cmd_set_lpcdval.end(), &nxpncihal_ctrl.p_rx_data[4],
1543 (&nxpncihal_ctrl.p_rx_data[4] + cmd_set_lpcdval[2]));
1544 if (NFCSTATUS_SUCCESS ==
1545 phNxpNciHal_send_ext_cmd(cmd_set_lpcdval.size(),
1546 &cmd_set_lpcdval[0])) {
1547 return;
1548 }
1549 } else {
1550 return;
1551 }
1552 }
1553 }
1554 NXPLOG_NCIHAL_E("%s: failed!!", __func__);
1555 return;
1556 }
1557
1558 /******************************************************************************
1559 * Function phNxpNciHal_prop_conf_rssi
1560 *
1561 * Description It resets RSSI param to default value.
1562 *
1563 * Returns none
1564 *
1565 ******************************************************************************/
phNxpNciHal_prop_conf_rssi()1566 void phNxpNciHal_prop_conf_rssi() {
1567 if (IS_CHIP_TYPE_L(sn220u)) {
1568 NXPLOG_NCIHAL_D("%s: feature is not supported", __func__);
1569 return;
1570 }
1571 vector<uint8_t> cmd_get_rssival = {0x20, 0x03, 0x03, 0x01, 0xA1, 0x55};
1572 vector<uint8_t> cmd_set_rssival = {0x20, 0x02, 0x06, 0x01, 0xA1,
1573 0x55, 0x02, 0x00, 0x00};
1574
1575 if (NFCSTATUS_SUCCESS !=
1576 phNxpNciHal_send_ext_cmd(cmd_get_rssival.size(), &cmd_get_rssival[0])) {
1577 NXPLOG_NCIHAL_E("%s: failed!! Line:%d", __func__, __LINE__);
1578 return;
1579 }
1580 if ((nxpncihal_ctrl.rx_data_len <= 9) ||
1581 (NFCSTATUS_SUCCESS != nxpncihal_ctrl.p_rx_data[3])) {
1582 NXPLOG_NCIHAL_E("%s: failed!! Line:%d", __func__, __LINE__);
1583 return;
1584 }
1585 if ((nxpncihal_ctrl.p_rx_data[8] != 0x00) ||
1586 (nxpncihal_ctrl.p_rx_data[9] != 0x00)) {
1587 if (NFCSTATUS_SUCCESS !=
1588 phNxpNciHal_send_ext_cmd(cmd_set_rssival.size(), &cmd_set_rssival[0])) {
1589 NXPLOG_NCIHAL_E("%s: failed!! Line:%d", __func__, __LINE__);
1590 return;
1591 }
1592 }
1593
1594 return;
1595 }
1596
1597 /******************************************************************************
1598 * Function phNxpNciHal_conf_nfc_forum_mode
1599 *
1600 * Description If NFCC is not in Nfc Forum mode, then this function will
1601 * configure it back to the Nfc Forum mode.
1602 *
1603 * Returns none
1604 *
1605 ******************************************************************************/
phNxpNciHal_conf_nfc_forum_mode()1606 void phNxpNciHal_conf_nfc_forum_mode() {
1607 uint8_t cmd_get_emvcocfg[] = {0x20, 0x03, 0x03, 0x01, 0xA0, 0x44};
1608 uint8_t cmd_reset_emvcocfg[8];
1609 long cmdlen = 8;
1610 long retlen = 0;
1611
1612 if (GetNxpByteArrayValue(NAME_NXP_PROP_RESET_EMVCO_CMD,
1613 (char*)cmd_reset_emvcocfg, cmdlen, &retlen)) {
1614 }
1615 if (retlen != 0x08) {
1616 NXPLOG_NCIHAL_E("%s: command is not provided", __func__);
1617 return;
1618 }
1619 /* Update the flag address from the Nxp config file */
1620 cmd_get_emvcocfg[4] = cmd_reset_emvcocfg[4];
1621 cmd_get_emvcocfg[5] = cmd_reset_emvcocfg[5];
1622
1623 if (NFCSTATUS_SUCCESS ==
1624 phNxpNciHal_send_ext_cmd(sizeof(cmd_get_emvcocfg), cmd_get_emvcocfg)) {
1625 if (NFCSTATUS_SUCCESS == nxpncihal_ctrl.p_rx_data[3]) {
1626 if (0x01 & nxpncihal_ctrl.p_rx_data[8]) {
1627 if (NFCSTATUS_SUCCESS ==
1628 phNxpNciHal_send_ext_cmd(sizeof(cmd_reset_emvcocfg),
1629 cmd_reset_emvcocfg)) {
1630 return;
1631 }
1632 } else {
1633 return;
1634 }
1635 }
1636 }
1637 NXPLOG_NCIHAL_E("%s: failed!!", __func__);
1638 return;
1639 }
1640
1641 /******************************************************************************
1642 * Function RemoveNfcDepIntfFromInitResp
1643 *
1644 * Description This function process the NCI_CORE_INIT_RESP & removes
1645 * remove the NFC_DEP interface support and modify the
1646 * CORE_INIT_RESP accordingly.
1647 *
1648 * Returns None
1649 *
1650 ******************************************************************************/
RemoveNfcDepIntfFromInitResp(uint8_t * coreInitResp,uint16_t * coreInitRespLen)1651 void RemoveNfcDepIntfFromInitResp(uint8_t* coreInitResp,
1652 uint16_t* coreInitRespLen) {
1653 /* As per NCI 2.0 index Number of Supported RF interfaces is 13 */
1654 uint8_t indexOfSupportedRfIntf = 13;
1655 /* as per NCI 2.0 Number of Supported RF Interfaces Payload field index is 13
1656 * & 3 bytes for NCI_MSG_HEADER */
1657 uint8_t noOfSupportedInterface =
1658 *(coreInitResp + indexOfSupportedRfIntf + NCI_HEADER_SIZE);
1659 uint8_t rfInterfacesLength =
1660 *coreInitRespLen - (indexOfSupportedRfIntf + 1 + NCI_HEADER_SIZE);
1661 uint8_t* supportedRfInterfaces = NULL;
1662 bool removeNfcDepRequired = false;
1663 if (noOfSupportedInterface) {
1664 supportedRfInterfaces =
1665 coreInitResp + indexOfSupportedRfIntf + 1 + NCI_HEADER_SIZE;
1666 }
1667 uint8_t* supportedRfInterfacesDetails = supportedRfInterfaces;
1668 /* Get the index of Supported RF Interface for NFC-DEP interface in CORE_INIT
1669 * Response*/
1670 for (int i = 0; i < noOfSupportedInterface; i++) {
1671 if (*supportedRfInterfaces == NCI_NFC_DEP_RF_INTF) {
1672 removeNfcDepRequired = true;
1673 break;
1674 }
1675 uint8_t noOfExtensions = *(supportedRfInterfaces + 1);
1676 /* 2 bytes for RF interface type & length of Extensions */
1677 supportedRfInterfaces += (2 + noOfExtensions);
1678 }
1679 /* If NFC-DEP is found in response then remove NFC-DEP from init response and
1680 * frame new CORE_INIT_RESP and send to upper layer*/
1681 if (!removeNfcDepRequired) {
1682 NXPLOG_NCIHAL_E("%s: NFC-DEP Removal is not required !!", __func__);
1683 return;
1684 } else {
1685 coreInitResp[16] = noOfSupportedInterface - 1;
1686 uint8_t noBytesToSkipForNfcDep = 2 + *(supportedRfInterfaces + 1);
1687 memcpy(supportedRfInterfaces,
1688 supportedRfInterfaces + noBytesToSkipForNfcDep,
1689 (rfInterfacesLength -
1690 ((supportedRfInterfaces - supportedRfInterfacesDetails) +
1691 noBytesToSkipForNfcDep)));
1692 *coreInitRespLen -= noBytesToSkipForNfcDep;
1693 coreInitResp[2] -= noBytesToSkipForNfcDep;
1694
1695 /* Print updated CORE_INIT_RESP for debug purpose*/
1696 phNxpNciHal_print_packet("DEBUG", coreInitResp, *coreInitRespLen);
1697 }
1698 }
1699