1 /*
2 * Copyright (C) 2012-2014 NXP Semiconductors
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
17 #ifdef NXP_HW_SELF_TEST
18
19
20 #include <phNxpNciHal_SelfTest.h>
21 #include <phNxpLog.h>
22 #include <pthread.h>
23 #include <phOsalNfc_Timer.h>
24
25 #define HAL_WRITE_RSP_TIMEOUT (2000) /* Timeout value to wait for response from PN54X */
26 #define HAL_WRITE_MAX_RETRY (10)
27
28 /******************* Structures and definitions *******************************/
29
30 typedef uint8_t (*st_validator_t)(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
31
32 phAntenna_St_Resp_t phAntenna_resp;
33
34 typedef struct nci_test_data
35 {
36 nci_data_t cmd;
37 nci_data_t exp_rsp;
38 nci_data_t exp_ntf;
39 st_validator_t rsp_validator;
40 st_validator_t ntf_validator;
41
42 }nci_test_data_t;
43
44 /******************* Global variables *****************************************/
45
46 static int thread_running = 0;
47 static uint32_t timeoutTimerId = 0;
48 static int hal_write_timer_fired = 0;
49
50 /* TML Context */
51 extern phTmlNfc_Context_t *gpphTmlNfc_Context;
52
53 /* Global HAL Ref */
54 extern phNxpNciHal_Control_t nxpncihal_ctrl;
55
56 /* Driver parameters */
57 phLibNfc_sConfig_t gDrvCfg;
58
59 NFCSTATUS gtxldo_status = NFCSTATUS_FAILED;
60 NFCSTATUS gagc_value_status = NFCSTATUS_FAILED;
61 NFCSTATUS gagc_nfcld_status = NFCSTATUS_FAILED;
62 NFCSTATUS gagc_differential_status = NFCSTATUS_FAILED;
63
64
65 static uint8_t st_validator_testEquals(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
66 static uint8_t st_validator_null(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
67 static uint8_t st_validator_testSWP1_vltg(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
68 static uint8_t st_validator_testAntenna_Txldo(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
69 static uint8_t st_validator_testAntenna_AgcVal(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
70 static uint8_t st_validator_testAntenna_AgcVal_FixedNfcLd(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
71 static uint8_t st_validator_testAntenna_AgcVal_Differential(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
72
73 #if(NFC_NXP_CHIP_TYPE != PN547C2)
74 NFCSTATUS phNxpNciHal_getPrbsCmd (phNxpNfc_PrbsType_t prbs_type, phNxpNfc_PrbsHwType_t hw_prbs_type,
75 uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len);
76 #else
77 NFCSTATUS phNxpNciHal_getPrbsCmd (uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len);
78 #endif
79 /* Test data to validate SWP line 2*/
80 static nci_test_data_t swp2_test_data[] = {
81 {
82 {
83 0x04, {0x20,0x00,0x01,0x01} /* cmd */
84 },
85 {
86 #if(NFC_NXP_CHIP_TYPE != PN547C2)
87 0x06, {0x40,0x00,0x03,0x00,0x11,0x01} /* exp_rsp */
88 #else
89 0x06, {0x40,0x00,0x03,0x00,0x10,0x01} /* exp_rsp */
90 #endif
91 },
92 {
93 0x00, {0x00} /* ext_ntf */
94 },
95 st_validator_testEquals, /* validator */
96 st_validator_null
97 },
98 {
99 {
100 #if(NFC_NXP_CHIP_TYPE != PN547C2)
101 0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
102 #else
103 0x03, {0x20,0x01,0x00}
104 #endif
105 },
106 {
107 #if(NFC_NXP_CHIP_TYPE != PN547C2)
108 0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
109 #else
110 0x4, {0x40,0x01,0x17,0x00 }
111 #endif
112 },
113 {
114 0x00, {0x00} /* ext_ntf */
115 },
116 st_validator_testEquals, /* validator */
117 st_validator_null
118 },
119 {
120 {
121 0x03, {0x2F,0x02,0x00} /* cmd */
122 },
123 {
124 0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
125 },
126 {
127 0x00, {0x00} /* ext_ntf */
128 },
129 st_validator_testEquals, /* validator */
130 st_validator_null
131 },
132 {
133 {
134 0x04, {0x2F,0x3E,0x01,0x01} /* cmd */
135 },
136 {
137 0x04, {0x4F,0x3E,0x01,0x00} /* exp_rsp */
138 },
139 {
140 0x04, {0x6F,0x3E,0x02,0x00} /* ext_ntf */
141 },
142 st_validator_testEquals, /* validator */
143 st_validator_testEquals
144 },
145
146 };
147
148 /* Test data to validate SWP line 1*/
149 static nci_test_data_t swp1_test_data[] = {
150
151 {
152 {
153 0x04, {0x20,0x00,0x01,0x01} /* cmd */
154 },
155 {
156 #if(NFC_NXP_CHIP_TYPE != PN547C2)
157 0x06, {0x40,0x00,0x03,0x00,0x11,0x01} /* exp_rsp */
158 #else
159 0x06, {0x40,0x00,0x03,0x00,0x10,0x01} /* exp_rsp */
160 #endif
161 },
162 {
163 0x00, {0x00} /* ext_ntf */
164 },
165 st_validator_testEquals, /* validator */
166 st_validator_null
167 },
168 {
169 {
170 #if(NFC_NXP_CHIP_TYPE != PN547C2)
171 0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
172 #else
173 0x03, {0x20,0x01,0x00}
174 #endif
175 },
176 {
177 #if(NFC_NXP_CHIP_TYPE != PN547C2)
178 0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
179 #else
180 0x4, {0x40,0x01,0x17,0x00 }
181 #endif
182 },
183 {
184 0x00, {0x00} /* ext_ntf */
185 },
186 st_validator_testEquals, /* validator */
187 st_validator_null
188 },
189 {
190 {
191 0x03, {0x2F,0x02,0x00} /* cmd */
192 },
193 {
194 0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
195 },
196 {
197 0x00, {0x00} /* ext_ntf */
198 },
199 st_validator_testEquals, /* validator */
200 st_validator_null
201 },
202 {
203 {
204 0x04, {0x2F,0x3E,0x01,0x00} /* cmd */
205 },
206 {
207 0x04, {0x4F,0x3E,0x01,0x00} /* exp_rsp */
208 },
209 {
210 0x04, {0x6F,0x3E,0x02,0x00} /* ext_ntf */
211 },
212
213 st_validator_testEquals, /* validator */
214 st_validator_testSWP1_vltg
215 },
216 };
217
218 static nci_test_data_t prbs_test_data[] = {
219 {
220 {
221 0x04, {0x20,0x00,0x01,0x00} /* cmd */
222 },
223 {
224 #if(NFC_NXP_CHIP_TYPE != PN547C2)
225 0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
226 #else
227 0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
228 #endif
229 },
230 {
231 0x00, {0x00} /* ext_ntf */
232 },
233 st_validator_testEquals, /* validator */
234 st_validator_null
235 },
236 {
237 {
238 #if(NFC_NXP_CHIP_TYPE != PN547C2)
239 0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
240 #else
241 0x03, {0x20,0x01,0x00} /* cmd */
242 #endif
243 },
244 {
245 #if(NFC_NXP_CHIP_TYPE != PN547C2)
246 0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
247 #else
248 0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
249 #endif
250 },
251 {
252 0x00, {0x00} /* ext_ntf */
253 },
254 st_validator_testEquals, /* validator */
255 st_validator_null
256 #if(NFC_NXP_CHIP_TYPE != PN547C2)
257 },
258 {
259 {
260 0x04, {0x2F,0x00,0x01,0x00} /* cmd */
261 },
262 {
263 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
264 },
265 {
266 0x00, {0x00} /* ext_ntf */
267 },
268 st_validator_testEquals, /* validator */
269 st_validator_null
270 #endif
271 }
272 };
273
274 /* for rf field test, first requires to disable the standby mode */
275 static nci_test_data_t rf_field_on_test_data[] = {
276 {
277 {
278 0x04, {0x20,0x00,0x01,0x00} /* cmd */
279 },
280 {
281 #if(NFC_NXP_CHIP_TYPE != PN547C2)
282 0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
283 #else
284 0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
285 #endif
286 },
287 {
288 0x00, {0x00} /* ext_ntf */
289 },
290 st_validator_testEquals, /* validator */
291 st_validator_null
292 },
293 {
294 {
295 #if(NFC_NXP_CHIP_TYPE != PN547C2)
296 0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
297 #else
298 0x03, {0x20,0x01,0x00} /* cmd */
299 #endif
300 },
301 {
302 #if(NFC_NXP_CHIP_TYPE != PN547C2)
303 0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
304 #else
305 0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
306 #endif
307 },
308 {
309 0x00, {0x00} /* ext_ntf */
310 },
311 st_validator_testEquals, /* validator */
312 st_validator_null
313 },
314 #if(NFC_NXP_CHIP_TYPE != PN547C2)
315 {
316 {
317 0x03, {0x2F,0x02,0x00} /* cmd */
318 },
319 {
320 0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
321 },
322 {
323 0x00, {0x00} /* ext_ntf */
324 },
325 st_validator_testEquals, /* validator */
326 st_validator_null
327 },
328 {
329 {
330 0x04, {0x2F,0x00,0x01,0x00} /* cmd */
331 },
332 {
333 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
334 },
335 {
336 0x00, {0x00} /* ext_ntf */
337 },
338 st_validator_testEquals, /* validator */
339 st_validator_null
340 },
341 #endif
342 {
343 {
344 #if(NFC_NXP_CHIP_TYPE != PN547C2)
345 0x05, {0x2F,0x3D,0x02,0x20,0x01} /* cmd */
346 #else
347 0x08, {0x2F,0x3D,0x05,0x20,0x01,0x00,0x00,0x00} /* cmd */
348 #endif
349 },
350 {
351 0x04, {0x4F,0x3D,0x05,0x00} /* exp_rsp */
352 },
353 {
354 0x00, {0x00} /* ext_ntf */
355 },
356 st_validator_testEquals, /* validator */
357 st_validator_null
358 #if(NFC_NXP_CHIP_TYPE != PN547C2)
359 },
360 {
361 {
362 0x04, {0x2F,0x00,0x01,0x01} /* cmd */
363 },
364 {
365 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
366 },
367 {
368 0x00, {0x00} /* ext_ntf */
369 },
370 st_validator_testEquals, /* validator */
371 st_validator_null
372 #endif
373 }
374 };
375
376 static nci_test_data_t rf_field_off_test_data[] = {
377 {
378 {
379 0x04, {0x20,0x00,0x01,0x00} /* cmd */
380 },
381 {
382 #if(NFC_NXP_CHIP_TYPE != PN547C2)
383 0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
384 #else
385 0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
386 #endif
387 },
388 {
389 0x00, {0x00} /* ext_ntf */
390 },
391 st_validator_testEquals, /* validator */
392 st_validator_null
393 },
394 {
395 {
396 #if(NFC_NXP_CHIP_TYPE != PN547C2)
397 0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
398 #else
399 0x03, {0x20,0x01,0x00} /* cmd */
400 #endif
401 },
402 {
403 #if(NFC_NXP_CHIP_TYPE != PN547C2)
404 0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
405 #else
406 0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
407 #endif
408 },
409 {
410 0x00, {0x00} /* ext_ntf */
411 },
412 st_validator_testEquals, /* validator */
413 st_validator_null
414 },
415 #if(NFC_NXP_CHIP_TYPE != PN547C2)
416 {
417 {
418 0x03, {0x2F,0x02,0x00} /* cmd */
419 },
420 {
421 0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
422 },
423 {
424 0x00, {0x00} /* ext_ntf */
425 },
426 st_validator_testEquals, /* validator */
427 st_validator_null
428 },
429 {
430 {
431 0x04, {0x2F,0x00,0x01,0x00} /* cmd */
432 },
433 {
434 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
435 },
436 {
437 0x00, {0x00} /* ext_ntf */
438 },
439 st_validator_testEquals, /* validator */
440 st_validator_null
441 },
442 #endif
443 {
444 {
445 #if(NFC_NXP_CHIP_TYPE != PN547C2)
446 0x05, {0x2F,0x3D,0x02,0x20,0x00} /* cmd */
447 #else
448 0x08, {0x2F,0x3D,0x05,0x20,0x00,0x00,0x00,0x00} /* cmd */
449 #endif
450 },
451 {
452 0x04, {0x4F,0x3D,0x05,0x00} /* exp_rsp */
453 },
454 {
455 0x00, {0x00} /* ext_ntf */
456 },
457 st_validator_testEquals, /* validator */
458 st_validator_null
459 #if(NFC_NXP_CHIP_TYPE != PN547C2)
460 },
461 {
462 {
463 0x04, {0x2F,0x00,0x01,0x01} /* cmd */
464 },
465 {
466 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
467 },
468 {
469 0x00, {0x00} /* ext_ntf */
470 },
471 st_validator_testEquals, /* validator */
472 st_validator_null
473 #endif
474 }
475 };
476
477 /* Download pin test data 1 */
478 static nci_test_data_t download_pin_test_data1[] = {
479 {
480 {
481 0x04, {0x20,0x00,0x01,0x01} /* cmd */
482 },
483 {
484 #if(NFC_NXP_CHIP_TYPE != PN547C2)
485 0x06, {0x40,0x00,0x03,0x00,0x11,0x01} /* exp_rsp */
486 #else
487 0x06, {0x40,0x00,0x03,0x00,0x10,0x01} /* exp_rsp */
488 #endif
489 },
490 {
491 0x00, {0x00} /* ext_ntf */
492 },
493 st_validator_testEquals, /* validator */
494 st_validator_null
495 },
496 };
497
498 /* Download pin test data 2 */
499 static nci_test_data_t download_pin_test_data2[] = {
500 {
501 {
502 0x08, {0x00, 0x04, 0xD0, 0x11, 0x00, 0x00, 0x5B, 0x46} /* cmd */
503 },
504 {
505 0x08, {0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x87, 0x16} /* exp_rsp */
506 },
507 {
508 0x00, {0x00} /* ext_ntf */
509 },
510 st_validator_testEquals, /* validator */
511 st_validator_null
512 },
513 };
514 /* Antenna self test data*/
515 static nci_test_data_t antenna_self_test_data[] = {
516 {
517 {
518 0x04, {0x20,0x00,0x01,0x00} /* cmd */
519 },
520 {
521 #if(NFC_NXP_CHIP_TYPE != PN547C2)
522 0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
523 #else
524 0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
525 #endif
526 },
527 {
528 0x00, {0x00} /* ext_ntf */
529 },
530 st_validator_testEquals, /* validator */
531 st_validator_null
532 },
533 {
534 {
535 #if(NFC_NXP_CHIP_TYPE != PN547C2)
536 0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
537 #else
538 0x03, {0x20,0x01,0x00} /* cmd */
539 #endif
540 },
541 {
542 #if(NFC_NXP_CHIP_TYPE != PN547C2)
543 0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
544 #else
545 0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
546 #endif
547 },
548 {
549 0x00, {0x00} /* ext_ntf */
550 },
551 st_validator_testEquals, /* validator */
552 st_validator_null
553 },
554 {
555 {
556 0x03, {0x2F,0x02,0x00} /* cmd */
557 },
558 {
559 0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
560 },
561 {
562 0x00, {0x00} /* ext_ntf */
563 },
564 st_validator_testEquals, /* validator */
565 st_validator_null
566 },
567 #if(NFC_NXP_CHIP_TYPE != PN547C2)
568 {
569 {
570 0x04, {0x2F,0x00,0x01,0x00} /* cmd */
571 },
572 {
573 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
574 },
575 {
576 0x00, {0x00} /* ext_ntf */
577 },
578 st_validator_testEquals, /* validator */
579 st_validator_null
580 },
581 #endif
582 {
583 {
584 0x05, {0x2F, 0x3D, 0x02, 0x01, 0x80} /* TxLDO cureent measurement cmd */
585 },
586 {
587 0x03, {0x4F, 0x3D, 05} /* exp_rsp */
588 },
589 {
590 0x00, {0x00} /* ext_ntf */
591 },
592 st_validator_testAntenna_Txldo,
593 st_validator_null
594 },
595 {
596 {
597 #if(NFC_NXP_CHIP_TYPE != PN547C2)
598 0x07, {0x2F, 0x3D, 0x04, 0x02, 0xC8, 0x60, 0x03} /* AGC measurement cmd */
599 #else
600 0x07, {0x2F, 0x3D, 0x04, 0x02, 0xCD, 0x60, 0x03} /* AGC measurement cmd */
601 #endif
602 },
603 {
604 0x03, {0x4F, 0x3D, 05} /* exp_rsp */
605 },
606 {
607 0x00, {0x00} /* ext_ntf */
608 },
609 st_validator_testAntenna_AgcVal,
610 st_validator_null
611 },
612 {
613 {
614 0x07, {0x2F, 0x3D, 0x04, 0x04, 0x20, 0x08, 0x20} /* AGC with NFCLD measurement cmd */
615 },
616 {
617 0x03, {0x4F, 0x3D, 05} /* exp_rsp */
618 },
619 {
620 0x00, {0x00} /* ext_ntf */
621 },
622 st_validator_testAntenna_AgcVal_FixedNfcLd,
623 st_validator_null
624 },
625 {
626 {
627 0x07, {0x2F, 0x3D, 0x04, 0x08, 0x8C, 0x60, 0x03} /* AGC with NFCLD measurement cmd */
628 },
629 {
630 0x03, {0x4F, 0x3D, 05} /* exp_rsp */
631 },
632 {
633 0x00, {0x00} /* ext_ntf */
634 },
635 st_validator_testAntenna_AgcVal_Differential,
636 st_validator_null
637 #if(NFC_NXP_CHIP_TYPE != PN547C2)
638 },
639 {
640 {
641 0x04, {0x2F,0x00,0x01,0x01} /* cmd */
642 },
643 {
644 0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
645 },
646 {
647 0x00, {0x00} /* ext_ntf */
648 },
649 st_validator_testEquals, /* validator */
650 st_validator_null
651 #endif
652 }
653 };
654
655
656 /************** Self test functions ***************************************/
657
658 static uint8_t st_validator_testEquals(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
659 static void hal_write_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo);
660 static void hal_write_rsp_timeout_cb(uint32_t TimerId, void *pContext);
661 static void hal_read_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo);
662
663 /*******************************************************************************
664 **
665 ** Function st_validator_null
666 **
667 ** Description Null Validator
668 **
669 ** Returns One
670 **
671 *******************************************************************************/
st_validator_null(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)672 static uint8_t st_validator_null(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
673 {
674 UNUSED(exp);
675 UNUSED(act);
676 return 1;
677 }
678
679 /*******************************************************************************
680 **
681 ** Function st_validator_testSWP1_vltg
682 **
683 ** Description Validator function to validate swp1 connection.
684 **
685 ** Returns One if successful otherwise Zero.
686 **
687 *******************************************************************************/
st_validator_testSWP1_vltg(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)688 static uint8_t st_validator_testSWP1_vltg(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
689 {
690 uint8_t result = 0;
691
692 if(NULL == exp || NULL == act)
693 {
694 return result;
695 }
696
697 if( (act->wLength == 0x05) &&
698 (memcmp(exp->p_data,act->pBuff,exp->len) == 0))
699 {
700 if(act->pBuff[4] == 0x01 || act->pBuff[4] == 0x02)
701 {
702 result = 1;
703 }
704 }
705
706 return result;
707 }
708
709 /*******************************************************************************
710 **
711 ** Function st_validator_testAntenna_Txldo
712 **
713 ** Description Validator function to validate Antenna TxLDO current measurement.
714 **
715 ** Returns One if successful otherwise Zero.
716 **
717 *******************************************************************************/
st_validator_testAntenna_Txldo(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)718 static uint8_t st_validator_testAntenna_Txldo(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
719 {
720 uint8_t result = 0;
721 uint8_t mesuredrange =0;
722 long measured_val = 0;
723 int tolerance = 0;
724
725 if(NULL == exp || NULL == act)
726 {
727 return result;
728 }
729
730 NXPLOG_NCIHAL_D("st_validator_testAntenna_Txldo = 0x%x", act->pBuff[3]);
731 if (0x05 == act->pBuff[2])
732 {
733 if (NFCSTATUS_SUCCESS == act->pBuff[3])
734 {
735 result = 1;
736 NXPLOG_NCIHAL_D("Antenna: TxLDO current measured raw value in mA : 0x%x", act->pBuff[4]);
737 if(0x00 == act->pBuff[5])
738 {
739 NXPLOG_NCIHAL_D("Measured range : 0x00 = 50 - 100 mA");
740 measured_val = ((0.40 * act->pBuff[4]) + 50);
741 NXPLOG_NCIHAL_D("TxLDO current absolute value in mA = %ld", measured_val);
742 }
743 else
744 {
745 NXPLOG_NCIHAL_D("Measured range : 0x01 = 20 - 70 mA");
746 measured_val = ((0.40 * act->pBuff[4]) + 20);
747 NXPLOG_NCIHAL_D("TxLDO current absolute value in mA = %ld", measured_val);
748 }
749
750 tolerance = (phAntenna_resp.wTxdoMeasuredRangeMax *
751 phAntenna_resp.wTxdoMeasuredTolerance)/100;
752 if ((measured_val <= phAntenna_resp.wTxdoMeasuredRangeMax + tolerance))
753 {
754 tolerance = (phAntenna_resp.wTxdoMeasuredRangeMin *
755 phAntenna_resp.wTxdoMeasuredTolerance)/100;
756 if((measured_val >= phAntenna_resp.wTxdoMeasuredRangeMin - tolerance))
757 {
758 gtxldo_status = NFCSTATUS_SUCCESS;
759 NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement PASS");
760 }
761 else
762 {
763 gtxldo_status = NFCSTATUS_FAILED;
764 NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement FAIL");
765 }
766 }
767 else
768 {
769 gtxldo_status = NFCSTATUS_FAILED;
770 NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement FAIL");
771 }
772 }
773 else
774 {
775 gtxldo_status = NFCSTATUS_FAILED;
776 NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement failed: Invalid status");
777 }
778
779 }
780 else
781 {
782 gtxldo_status = NFCSTATUS_FAILED;
783 NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement failed: Invalid payload length");
784 }
785
786 return result;
787 }
788
789 /*******************************************************************************
790 **
791 ** Function st_validator_testAntenna_AgcVal
792 **
793 ** Description Validator function reads AGC value of antenna and print the info
794 **
795 ** Returns One if successful otherwise Zero.
796 **
797 *******************************************************************************/
st_validator_testAntenna_AgcVal(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)798 static uint8_t st_validator_testAntenna_AgcVal(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
799 {
800 uint8_t result = 0;
801 int agc_tolerance = 0;
802 long agc_val = 0;
803
804 if(NULL == exp || NULL == act)
805 {
806 return result;
807 }
808
809 if (0x05 == act->pBuff[2])
810 {
811 if (NFCSTATUS_SUCCESS == act->pBuff[3])
812 {
813 result = 1;
814 agc_tolerance = (phAntenna_resp.wAgcValue * phAntenna_resp.wAgcValueTolerance)/100;
815 agc_val = ((act->pBuff[5] << 8) | (act->pBuff[4]));
816 NXPLOG_NCIHAL_D("AGC value : %ld", agc_val);
817 if(((phAntenna_resp.wAgcValue - agc_tolerance) <= agc_val) &&
818 (agc_val <= (phAntenna_resp.wAgcValue + agc_tolerance)))
819 {
820 gagc_value_status = NFCSTATUS_SUCCESS;
821 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values PASS");
822 }
823 else
824 {
825 gagc_value_status = NFCSTATUS_FAILED;
826 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values FAIL");
827 }
828 }
829 else
830 {
831 gagc_value_status = NFCSTATUS_FAILED;
832 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values FAIL");
833 }
834 }
835 else
836 {
837 gagc_value_status = NFCSTATUS_FAILED;
838 NXPLOG_NCIHAL_E("Test Antenna Response for AGC value failed: Invalid payload length");
839 }
840
841 return result;
842 }
843 /*******************************************************************************
844 **
845 ** Function st_validator_testAntenna_AgcVal_FixedNfcLd
846 **
847 ** Description Validator function reads and print AGC value of
848 ** antenna with fixed NFCLD
849 **
850 ** Returns One if successful otherwise Zero.
851 **
852 *******************************************************************************/
st_validator_testAntenna_AgcVal_FixedNfcLd(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)853 static uint8_t st_validator_testAntenna_AgcVal_FixedNfcLd(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
854 {
855 uint8_t result = 0;
856 int agc_nfcld_tolerance = 0;
857 long agc_nfcld = 0;
858
859 if(NULL == exp || NULL == act)
860 {
861 return result;
862 }
863
864 if(0x05 == act->pBuff[2])
865 {
866 if(NFCSTATUS_SUCCESS == act->pBuff[3])
867 {
868 result = 1;
869 agc_nfcld_tolerance = (phAntenna_resp.wAgcValuewithfixedNFCLD *
870 phAntenna_resp.wAgcValuewithfixedNFCLDTolerance)/100;
871 agc_nfcld = ((act->pBuff[5] << 8) | (act->pBuff[4]));
872 NXPLOG_NCIHAL_D("AGC value with Fixed Nfcld : %ld", agc_nfcld);
873
874 if(((phAntenna_resp.wAgcValuewithfixedNFCLD - agc_nfcld_tolerance) <= agc_nfcld) &&
875 (agc_nfcld <= (phAntenna_resp.wAgcValuewithfixedNFCLD + agc_nfcld_tolerance)))
876 {
877 gagc_nfcld_status = NFCSTATUS_SUCCESS;
878 NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD PASS");
879 }
880 else
881 {
882 gagc_nfcld_status = NFCSTATUS_FAILED;
883 NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD FAIL");
884 }
885 }
886 else
887 {
888 gagc_nfcld_status = NFCSTATUS_FAILED;
889 NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD failed: Invalid status");
890 }
891 }
892 else
893 {
894 gagc_nfcld_status = NFCSTATUS_FAILED;
895 NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD failed: Invalid payload length");
896 }
897
898 return result;
899 }
900
901 /*******************************************************************************
902 **
903 ** Function st_validator_testAntenna_AgcVal_Differential
904 **
905 ** Description Reads the AGC value with open/short RM from buffer and print
906 **
907 ** Returns One if successful otherwise Zero.
908 **
909 *******************************************************************************/
st_validator_testAntenna_AgcVal_Differential(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)910 static uint8_t st_validator_testAntenna_AgcVal_Differential(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
911 {
912 uint8_t result = 0;
913 int agc_toleranceopne1 = 0;
914 int agc_toleranceopne2 = 0;
915 long agc_differentialOpne1 = 0;
916 long agc_differentialOpne2 = 0;
917
918 if(NULL == exp || NULL == act)
919 {
920 return result;
921 }
922
923 if (0x05 == act->pBuff[2])
924 {
925 if (NFCSTATUS_SUCCESS == act->pBuff[3])
926 {
927 result = 1;
928 agc_toleranceopne1=(phAntenna_resp.wAgcDifferentialWithOpen1 *
929 phAntenna_resp.wAgcDifferentialWithOpenTolerance1)/100;
930 agc_toleranceopne2=(phAntenna_resp.wAgcDifferentialWithOpen2 *
931 phAntenna_resp.wAgcDifferentialWithOpenTolerance2)/100;
932 agc_differentialOpne1 = ((act->pBuff[5] << 8) | (act->pBuff[4]));
933 agc_differentialOpne2 = ((act->pBuff[7] << 8) | (act->pBuff[6]));
934 NXPLOG_NCIHAL_D("AGC value differential Opne 1 : %ld", agc_differentialOpne1);
935 NXPLOG_NCIHAL_D("AGC value differentialOpne 2 : %ld", agc_differentialOpne2);
936
937 if(((agc_differentialOpne1 >= phAntenna_resp.wAgcDifferentialWithOpen1 - agc_toleranceopne1) &&
938 (agc_differentialOpne1 <= phAntenna_resp.wAgcDifferentialWithOpen1 + agc_toleranceopne1)) &&
939 ((agc_differentialOpne2 >= phAntenna_resp.wAgcDifferentialWithOpen2 - agc_toleranceopne2) &&
940 (agc_differentialOpne2 <= phAntenna_resp.wAgcDifferentialWithOpen2 + agc_toleranceopne2)))
941 {
942 gagc_differential_status = NFCSTATUS_SUCCESS;
943 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential Open PASS");
944 }
945 else
946 {
947 gagc_differential_status = NFCSTATUS_FAILED;
948 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential Open FAIL");
949 }
950 }
951 else
952 {
953 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential failed: Invalid status");
954 gagc_differential_status = NFCSTATUS_FAILED;
955 }
956
957 }
958 else
959 {
960 NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential failed: Invalid payload length");
961 gagc_differential_status = NFCSTATUS_FAILED;
962 }
963
964 return result;
965 }
966 /*******************************************************************************
967 **
968 ** Function st_validator_testEquals
969 **
970 ** Description Validator function to validate for equality between actual
971 ** and expected values.
972 **
973 ** Returns One if successful otherwise Zero.
974 **
975 *******************************************************************************/
st_validator_testEquals(nci_data_t * exp,phTmlNfc_TransactInfo_t * act)976 static uint8_t st_validator_testEquals(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
977 {
978 uint8_t result = 0;
979
980 if(NULL == exp || NULL == act)
981 {
982 return result;
983 }
984 if(exp->len <= act->wLength &&
985 (memcmp(exp->p_data,act->pBuff,exp->len) == 0))
986 {
987 result = 1;
988 }
989
990 return result;
991 }
992
993 /*******************************************************************************
994 **
995 ** Function hal_write_rsp_timeout_cb
996 **
997 ** Description Callback function for hal write response timer.
998 **
999 ** Returns None
1000 **
1001 *******************************************************************************/
hal_write_rsp_timeout_cb(uint32_t timerId,void * pContext)1002 static void hal_write_rsp_timeout_cb(uint32_t timerId, void *pContext)
1003 {
1004 UNUSED(timerId);
1005 NXPLOG_NCIHAL_E("hal_write_rsp_timeout_cb - write timeout!!!");
1006 hal_write_timer_fired = 1;
1007 hal_read_cb(pContext,NULL);
1008 }
1009
1010 /*******************************************************************************
1011 **
1012 ** Function hal_write_cb
1013 **
1014 ** Description Callback function for hal write.
1015 **
1016 ** Returns None
1017 **
1018 *******************************************************************************/
hal_write_cb(void * pContext,phTmlNfc_TransactInfo_t * pInfo)1019 static void hal_write_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo)
1020 {
1021 phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
1022
1023 if (pInfo->wStatus == NFCSTATUS_SUCCESS)
1024 {
1025 NXPLOG_NCIHAL_D("write successful status = 0x%x", pInfo->wStatus);
1026 }
1027 else
1028 {
1029 NXPLOG_NCIHAL_E("write error status = 0x%x", pInfo->wStatus);
1030 }
1031
1032 p_cb_data->status = pInfo->wStatus;
1033 SEM_POST(p_cb_data);
1034
1035 return;
1036 }
1037
1038 /*******************************************************************************
1039 **
1040 ** Function hal_read_cb
1041 **
1042 ** Description Callback function for hal read.
1043 **
1044 ** Returns None
1045 **
1046 *******************************************************************************/
hal_read_cb(void * pContext,phTmlNfc_TransactInfo_t * pInfo)1047 static void hal_read_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo)
1048 {
1049 phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
1050 NFCSTATUS status;
1051 if(hal_write_timer_fired == 1)
1052 {
1053 NXPLOG_NCIHAL_D("hal_read_cb - response timeout occurred");
1054
1055 hal_write_timer_fired = 0;
1056 p_cb_data->status = NFCSTATUS_RESPONSE_TIMEOUT;
1057 status = phTmlNfc_ReadAbort();
1058 }
1059 else
1060 {
1061 NFCSTATUS status = phOsalNfc_Timer_Stop(timeoutTimerId);
1062
1063 if (NFCSTATUS_SUCCESS == status)
1064 {
1065 NXPLOG_NCIHAL_D("Response timer stopped");
1066 }
1067 else
1068 {
1069 NXPLOG_NCIHAL_E("Response timer stop ERROR!!!");
1070 p_cb_data->status = NFCSTATUS_FAILED;
1071 }
1072
1073 if (pInfo->wStatus == NFCSTATUS_SUCCESS)
1074 {
1075 NXPLOG_NCIHAL_D("hal_read_cb successful status = 0x%x", pInfo->wStatus);
1076 p_cb_data->status = NFCSTATUS_SUCCESS;
1077 }
1078 else
1079 {
1080 NXPLOG_NCIHAL_E("hal_read_cb error status = 0x%x", pInfo->wStatus);
1081 p_cb_data->status = NFCSTATUS_FAILED;
1082 }
1083
1084 p_cb_data->status = pInfo->wStatus;
1085
1086 nci_test_data_t *test_data = (nci_test_data_t*) p_cb_data->pContext;
1087
1088 if(test_data->exp_rsp.len == 0)
1089 {
1090 /* Compare the actual notification with expected notification.*/
1091 if( test_data->ntf_validator(&(test_data->exp_ntf),pInfo) == 1 )
1092 {
1093 p_cb_data->status = NFCSTATUS_SUCCESS;
1094 }
1095 else
1096 {
1097 p_cb_data->status = NFCSTATUS_FAILED;
1098
1099 }
1100 }
1101
1102 /* Compare the actual response with expected response.*/
1103 else if( test_data->rsp_validator(&(test_data->exp_rsp),pInfo) == 1)
1104 {
1105 p_cb_data->status = NFCSTATUS_SUCCESS;
1106 }
1107 else
1108 {
1109 p_cb_data->status = NFCSTATUS_FAILED;
1110 }
1111 test_data->exp_rsp.len = 0;
1112 }
1113
1114 SEM_POST(p_cb_data);
1115
1116 return;
1117 }
1118
1119 /*******************************************************************************
1120 **
1121 ** Function phNxpNciHal_test_rx_thread
1122 **
1123 ** Description Thread to fetch and process messages from message queue.
1124 **
1125 ** Returns NULL
1126 **
1127 *******************************************************************************/
phNxpNciHal_test_rx_thread(void * arg)1128 static void *phNxpNciHal_test_rx_thread(void *arg)
1129 {
1130 phLibNfc_Message_t msg;
1131 UNUSED(arg);
1132 NXPLOG_NCIHAL_D("Self test thread started");
1133
1134 thread_running = 1;
1135
1136 while (thread_running == 1)
1137 {
1138 /* Fetch next message from the NFC stack message queue */
1139 if (phDal4Nfc_msgrcv(gDrvCfg.nClientId,
1140 &msg, 0, 0) == -1)
1141 {
1142 NXPLOG_NCIHAL_E("Received bad message");
1143 continue;
1144 }
1145
1146 if(thread_running == 0)
1147 {
1148 break;
1149 }
1150
1151 switch (msg.eMsgType)
1152 {
1153 case PH_LIBNFC_DEFERREDCALL_MSG:
1154 {
1155 phLibNfc_DeferredCall_t *deferCall =
1156 (phLibNfc_DeferredCall_t *) (msg.pMsgData);
1157
1158 REENTRANCE_LOCK();
1159 deferCall->pCallback(deferCall->pParameter);
1160 REENTRANCE_UNLOCK();
1161
1162 break;
1163 }
1164 }
1165 }
1166
1167 NXPLOG_NCIHAL_D("Self test thread stopped");
1168
1169 return NULL;
1170 }
1171
1172 /*******************************************************************************
1173 **
1174 ** Function phNxpNciHal_readLocked
1175 **
1176 ** Description Reads response and notification from NFCC and waits for
1177 ** read completion, for a definitive timeout value.
1178 **
1179 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED,
1180 ** NFCSTATUS_RESPONSE_TIMEOUT in case of timeout.
1181 **
1182 *******************************************************************************/
phNxpNciHal_readLocked(nci_test_data_t * pData)1183 static NFCSTATUS phNxpNciHal_readLocked(nci_test_data_t *pData )
1184 {
1185 NFCSTATUS status = NFCSTATUS_SUCCESS;
1186 phNxpNciHal_Sem_t cb_data;
1187 uint16_t read_len = 16;
1188 /* RX Buffer */
1189 uint32_t rx_data[NCI_MAX_DATA_LEN];
1190
1191 /* Create the local semaphore */
1192 if (phNxpNciHal_init_cb_data(&cb_data, pData) != NFCSTATUS_SUCCESS)
1193 {
1194 NXPLOG_NCIHAL_D("phTmlNfc_Read Create cb data failed");
1195 status = NFCSTATUS_FAILED;
1196 goto clean_and_return;
1197 }
1198
1199 /* call read pending */
1200 status = phTmlNfc_Read(
1201 (uint8_t *) rx_data,
1202 (uint16_t) read_len,
1203 (pphTmlNfc_TransactCompletionCb_t) &hal_read_cb,
1204 &cb_data);
1205
1206 if (status != NFCSTATUS_PENDING)
1207 {
1208 NXPLOG_NCIHAL_E("TML Read status error status = %x", status);
1209 status = NFCSTATUS_FAILED;
1210 goto clean_and_return;
1211 }
1212
1213 status = phOsalNfc_Timer_Start(timeoutTimerId,
1214 HAL_WRITE_RSP_TIMEOUT,
1215 &hal_write_rsp_timeout_cb,
1216 &cb_data);
1217
1218 if (NFCSTATUS_SUCCESS == status)
1219 {
1220 NXPLOG_NCIHAL_D("Response timer started");
1221 }
1222 else
1223 {
1224 NXPLOG_NCIHAL_E("Response timer not started");
1225 status = NFCSTATUS_FAILED;
1226 goto clean_and_return;
1227 }
1228
1229 /* Wait for callback response */
1230 if (SEM_WAIT(cb_data))
1231 {
1232 NXPLOG_NCIHAL_E("phTmlNfc_Read semaphore error");
1233 status = NFCSTATUS_FAILED;
1234 goto clean_and_return;
1235 }
1236
1237 if(cb_data.status == NFCSTATUS_RESPONSE_TIMEOUT)
1238 {
1239 NXPLOG_NCIHAL_E("Response timeout!!!");
1240 status = NFCSTATUS_RESPONSE_TIMEOUT;
1241 goto clean_and_return;
1242
1243 }
1244
1245 if (cb_data.status != NFCSTATUS_SUCCESS)
1246 {
1247 NXPLOG_NCIHAL_E("phTmlNfc_Read failed ");
1248 status = NFCSTATUS_FAILED;
1249 goto clean_and_return;
1250 }
1251
1252 clean_and_return:
1253 phNxpNciHal_cleanup_cb_data(&cb_data);
1254
1255 return status;
1256 }
1257
1258 /*******************************************************************************
1259 **
1260 ** Function phNxpNciHal_writeLocked
1261 **
1262 ** Description Send command to NFCC and waits for cmd write completion, for
1263 ** a definitive timeout value.
1264 **
1265 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED,
1266 ** NFCSTATUS_RESPONSE_TIMEOUT in case of timeout.
1267 **
1268 *******************************************************************************/
phNxpNciHal_writeLocked(nci_test_data_t * pData)1269 static NFCSTATUS phNxpNciHal_writeLocked(nci_test_data_t *pData )
1270 {
1271 NFCSTATUS status = NFCSTATUS_SUCCESS;
1272
1273 phNxpNciHal_Sem_t cb_data;
1274 int retryCnt = 0;
1275
1276 /* Create the local semaphore */
1277 if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
1278 {
1279 NXPLOG_NCIHAL_D("phTmlNfc_Write Create cb data failed");
1280 goto clean_and_return;
1281 }
1282
1283 retry:
1284 status = phTmlNfc_Write(pData->cmd.p_data, pData->cmd.len,
1285 (pphTmlNfc_TransactCompletionCb_t) &hal_write_cb, &cb_data);
1286
1287 if (status != NFCSTATUS_PENDING)
1288 {
1289 NXPLOG_NCIHAL_E("phTmlNfc_Write status error");
1290 goto clean_and_return;
1291 }
1292
1293 /* Wait for callback response */
1294 if (SEM_WAIT(cb_data))
1295 {
1296 NXPLOG_NCIHAL_E("write_unlocked semaphore error");
1297 status = NFCSTATUS_FAILED;
1298 goto clean_and_return;
1299 }
1300
1301 if (cb_data.status != NFCSTATUS_SUCCESS && retryCnt < HAL_WRITE_MAX_RETRY)
1302 {
1303 retryCnt++;
1304 NXPLOG_NCIHAL_E("write_unlocked failed - PN54X Maybe in Standby Mode - Retry %d",retryCnt);
1305 goto retry;
1306 }
1307
1308 status = cb_data.status;
1309
1310 clean_and_return:
1311 phNxpNciHal_cleanup_cb_data(&cb_data);
1312
1313 return status;
1314 }
1315
1316 /*******************************************************************************
1317 **
1318 ** Function phNxpNciHal_performTest
1319 **
1320 ** Description Performs a single cycle of command,response and
1321 ** notification.
1322 **
1323 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED,
1324 **
1325 *******************************************************************************/
phNxpNciHal_performTest(nci_test_data_t * pData)1326 NFCSTATUS phNxpNciHal_performTest(nci_test_data_t *pData )
1327 {
1328 NFCSTATUS status = NFCSTATUS_SUCCESS;
1329
1330 if(NULL == pData)
1331 {
1332 return NFCSTATUS_FAILED;
1333 }
1334
1335 CONCURRENCY_LOCK();
1336
1337 status = phNxpNciHal_writeLocked(pData);
1338
1339 if(status == NFCSTATUS_RESPONSE_TIMEOUT)
1340 {
1341 goto clean_and_return;
1342 }
1343 if(status != NFCSTATUS_SUCCESS)
1344 {
1345 goto clean_and_return;
1346 }
1347
1348 status = phNxpNciHal_readLocked(pData);
1349
1350 if(status != NFCSTATUS_SUCCESS)
1351 {
1352 goto clean_and_return;
1353 }
1354
1355 if(0 != pData->exp_ntf.len)
1356 {
1357 status = phNxpNciHal_readLocked(pData);
1358
1359 if(status != NFCSTATUS_SUCCESS)
1360 {
1361 goto clean_and_return;
1362 }
1363 }
1364
1365 clean_and_return:
1366 CONCURRENCY_UNLOCK();
1367 return status;
1368 }
1369
1370 /*******************************************************************************
1371 **
1372 ** Function phNxpNciHal_TestMode_open
1373 **
1374 ** Description It opens the physical connection with NFCC (PN54X) and
1375 ** creates required client thread for operation.
1376 **
1377 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
1378 **
1379 *******************************************************************************/
phNxpNciHal_TestMode_open(void)1380 NFCSTATUS phNxpNciHal_TestMode_open (void)
1381 {
1382 /* Thread */
1383 pthread_t test_rx_thread;
1384
1385 phOsalNfc_Config_t tOsalConfig;
1386 phTmlNfc_Config_t tTmlConfig;
1387 NFCSTATUS status = NFCSTATUS_SUCCESS;
1388 uint16_t read_len = 255;
1389
1390 /* initialize trace level */
1391 phNxpLog_InitializeLogLevel();
1392
1393 if (phNxpNciHal_init_monitor() == NULL)
1394 {
1395 NXPLOG_NCIHAL_E("Init monitor failed");
1396 return NFCSTATUS_FAILED;
1397 }
1398
1399 CONCURRENCY_LOCK();
1400
1401 memset(&tOsalConfig, 0x00, sizeof(tOsalConfig));
1402 memset(&tTmlConfig, 0x00, sizeof(tTmlConfig));
1403
1404 gDrvCfg.nClientId = phDal4Nfc_msgget(0, 0600);
1405 gDrvCfg.nLinkType = ENUM_LINK_TYPE_I2C;/* For PN54X */
1406 tTmlConfig.pDevName = (int8_t *) "/dev/pn54x";
1407 tOsalConfig.dwCallbackThreadId = (uintptr_t) gDrvCfg.nClientId;
1408 tOsalConfig.pLogFile = NULL;
1409 tTmlConfig.dwGetMsgThreadId = (uintptr_t) gDrvCfg.nClientId;
1410 nxpncihal_ctrl.gDrvCfg.nClientId = (uintptr_t) gDrvCfg.nClientId;
1411
1412 /* Initialize TML layer */
1413 status = phTmlNfc_Init(&tTmlConfig);
1414 if (status != NFCSTATUS_SUCCESS)
1415 {
1416 NXPLOG_NCIHAL_E("phTmlNfc_Init Failed");
1417 goto clean_and_return;
1418 }
1419
1420 pthread_attr_t attr;
1421 pthread_attr_init(&attr);
1422 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
1423 if (pthread_create(&test_rx_thread, &attr,
1424 phNxpNciHal_test_rx_thread, NULL) != 0)
1425 {
1426 NXPLOG_NCIHAL_E("pthread_create failed");
1427 phTmlNfc_Shutdown();
1428 goto clean_and_return;
1429 }
1430
1431 timeoutTimerId = phOsalNfc_Timer_Create();
1432
1433 if(timeoutTimerId == 0xFFFF)
1434 {
1435 NXPLOG_NCIHAL_E("phOsalNfc_Timer_Create failed");
1436 }
1437 else
1438 {
1439 NXPLOG_NCIHAL_D("phOsalNfc_Timer_Create SUCCESS");
1440 }
1441 CONCURRENCY_UNLOCK();
1442
1443 return NFCSTATUS_SUCCESS;
1444
1445 clean_and_return:
1446 CONCURRENCY_UNLOCK();
1447 phNxpNciHal_cleanup_monitor();
1448 return NFCSTATUS_FAILED;
1449 }
1450
1451 /*******************************************************************************
1452 **
1453 ** Function phNxpNciHal_TestMode_close
1454 **
1455 ** Description This function close the NFCC interface and free all
1456 ** resources.
1457 **
1458 ** Returns None.
1459 **
1460 *******************************************************************************/
1461
phNxpNciHal_TestMode_close()1462 void phNxpNciHal_TestMode_close ()
1463 {
1464
1465 NFCSTATUS status = NFCSTATUS_SUCCESS;
1466
1467 CONCURRENCY_LOCK();
1468
1469 if (NULL != gpphTmlNfc_Context->pDevHandle)
1470 {
1471 /* Abort any pending read and write */
1472 status = phTmlNfc_ReadAbort();
1473 status = phTmlNfc_WriteAbort();
1474
1475 phOsalNfc_Timer_Cleanup();
1476
1477 status = phTmlNfc_Shutdown();
1478
1479 NXPLOG_NCIHAL_D("phNxpNciHal_close return status = %d", status);
1480
1481 thread_running = 0;
1482
1483 phDal4Nfc_msgrelease(gDrvCfg.nClientId);
1484
1485 status = phOsalNfc_Timer_Delete(timeoutTimerId);
1486 }
1487
1488 CONCURRENCY_UNLOCK();
1489
1490 phNxpNciHal_cleanup_monitor();
1491
1492 /* Return success always */
1493 return;
1494 }
1495
1496 /*******************************************************************************
1497 **
1498 ** Function phNxpNciHal_SwpTest
1499 **
1500 ** Description Test function to validate the SWP line. SWP line number is
1501 ** is sent as parameter to the API.
1502 **
1503 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
1504 **
1505 *******************************************************************************/
1506
phNxpNciHal_SwpTest(uint8_t swp_line)1507 NFCSTATUS phNxpNciHal_SwpTest(uint8_t swp_line)
1508 {
1509 NFCSTATUS status = NFCSTATUS_SUCCESS;
1510 int len = 0;
1511 int cnt = 0;
1512
1513 NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - start\n");
1514
1515 if(swp_line == 0x01)
1516 {
1517 len = (sizeof(swp1_test_data)/sizeof(swp1_test_data[0]));
1518
1519 for(cnt = 0; cnt < len; cnt++)
1520 {
1521 status = phNxpNciHal_performTest(&(swp1_test_data[cnt]));
1522 if(status == NFCSTATUS_RESPONSE_TIMEOUT ||
1523 status == NFCSTATUS_FAILED
1524 )
1525 {
1526 break;
1527 }
1528 }
1529 }
1530 else if(swp_line == 0x02)
1531 {
1532 len = (sizeof(swp2_test_data)/sizeof(swp2_test_data[0]));
1533
1534 for(cnt = 0; cnt < len; cnt++)
1535 {
1536 status = phNxpNciHal_performTest(&(swp2_test_data[cnt]));
1537 if(status == NFCSTATUS_RESPONSE_TIMEOUT ||
1538 status == NFCSTATUS_FAILED
1539 )
1540 {
1541 break;
1542 }
1543 }
1544 }
1545 else
1546 {
1547 status = NFCSTATUS_FAILED;
1548 }
1549
1550 if( status == NFCSTATUS_SUCCESS)
1551 {
1552 NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - SUCCESSS\n");
1553 }
1554 else
1555 {
1556 NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - FAILED\n");
1557 }
1558
1559 NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - end\n");
1560
1561 return status;
1562 }
1563
1564 /*******************************************************************************
1565 **
1566 ** Function phNxpNciHal_PrbsTestStart
1567 **
1568 ** Description Test function start RF generation for RF technology and bit
1569 ** rate. RF technology and bit rate are sent as parameter to
1570 ** the API.
1571 **
1572 ** Returns NFCSTATUS_SUCCESS if RF generation successful,
1573 ** otherwise NFCSTATUS_FAILED.
1574 **
1575 *******************************************************************************/
1576
1577 #if(NFC_NXP_CHIP_TYPE != PN547C2)
phNxpNciHal_PrbsTestStart(phNxpNfc_PrbsType_t prbs_type,phNxpNfc_PrbsHwType_t hw_prbs_type,phNxpNfc_Tech_t tech,phNxpNfc_Bitrate_t bitrate)1578 NFCSTATUS phNxpNciHal_PrbsTestStart (phNxpNfc_PrbsType_t prbs_type, phNxpNfc_PrbsHwType_t hw_prbs_type,
1579 phNxpNfc_Tech_t tech, phNxpNfc_Bitrate_t bitrate)
1580 #else
1581 NFCSTATUS phNxpNciHal_PrbsTestStart (phNxpNfc_Tech_t tech, phNxpNfc_Bitrate_t bitrate)
1582 #endif
1583 {
1584 NFCSTATUS status = NFCSTATUS_FAILED;
1585
1586 nci_test_data_t prbs_cmd_data;
1587
1588 #if(NFC_NXP_CHIP_TYPE != PN547C2)
1589 uint8_t rsp_cmd_info[] = {0x4F, 0x30, 0x01, 0x00};
1590 prbs_cmd_data.cmd.len = 0x09;
1591 #else
1592 uint8_t rsp_cmd_info[] = {0x4F, 0x30, 0x01, 0x00};
1593 prbs_cmd_data.cmd.len = 0x07;
1594 #endif
1595
1596 memcpy(prbs_cmd_data.exp_rsp.p_data, &rsp_cmd_info[0], sizeof(rsp_cmd_info));
1597 prbs_cmd_data.exp_rsp.len = sizeof(rsp_cmd_info);
1598
1599 //prbs_cmd_data.exp_rsp.len = 0x00;
1600 prbs_cmd_data.exp_ntf.len = 0x00;
1601 prbs_cmd_data.rsp_validator = st_validator_testEquals;
1602 prbs_cmd_data.ntf_validator = st_validator_null;
1603
1604 uint8_t len = 0;
1605 uint8_t cnt = 0;
1606
1607 // [NCI] -> [0x2F 0x30 0x04 0x00 0x00 0x01 0xFF]
1608
1609 #if(NFC_NXP_CHIP_TYPE != PN547C2)
1610 status = phNxpNciHal_getPrbsCmd(prbs_type, hw_prbs_type, tech, bitrate,
1611 prbs_cmd_data.cmd.p_data,prbs_cmd_data.cmd.len);
1612 #else
1613 status = phNxpNciHal_getPrbsCmd(tech, bitrate,prbs_cmd_data.cmd.p_data,prbs_cmd_data.cmd.len);
1614 #endif
1615
1616 if( status == NFCSTATUS_FAILED)
1617 {
1618 //Invalid Param.
1619 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - INVALID_PARAM\n");
1620
1621 goto clean_and_return;
1622 }
1623
1624 len = (sizeof(prbs_test_data)/sizeof(prbs_test_data[0]));
1625
1626 for(cnt = 0; cnt < len; cnt++)
1627 {
1628 status = phNxpNciHal_performTest(&(prbs_test_data[cnt]));
1629 if(status == NFCSTATUS_RESPONSE_TIMEOUT ||
1630 status == NFCSTATUS_FAILED
1631 )
1632 {
1633 break;
1634 }
1635 }
1636
1637 /* Ignoring status, as there will be no response - Applicable till FW version 8.1.1*/
1638 status = phNxpNciHal_performTest(&prbs_cmd_data);
1639 clean_and_return:
1640
1641 if( status == NFCSTATUS_SUCCESS)
1642 {
1643 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - SUCCESSS\n");
1644 }
1645 else
1646 {
1647 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - FAILED\n");
1648 }
1649
1650 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - end\n");
1651
1652 return status;
1653 }
1654
1655 /*******************************************************************************
1656 **
1657 ** Function phNxpNciHal_PrbsTestStop
1658 **
1659 ** Description Test function stop RF generation for RF technology started
1660 ** by phNxpNciHal_PrbsTestStart.
1661 **
1662 ** Returns NFCSTATUS_SUCCESS if operation successful,
1663 ** otherwise NFCSTATUS_FAILED.
1664 **
1665 *******************************************************************************/
1666
phNxpNciHal_PrbsTestStop()1667 NFCSTATUS phNxpNciHal_PrbsTestStop ()
1668 {
1669 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - Start\n");
1670
1671 NFCSTATUS status = NFCSTATUS_SUCCESS;
1672
1673 status = phTmlNfc_IoCtl(phTmlNfc_e_ResetDevice);
1674
1675 if(NFCSTATUS_SUCCESS == status)
1676 {
1677 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - SUCCESS\n");
1678 }
1679 else
1680 {
1681 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - FAILED\n");
1682
1683 }
1684 NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - end\n");
1685
1686 return status;
1687 }
1688
1689 /*******************************************************************************
1690 **
1691 ** Function phNxpNciHal_getPrbsCmd
1692 **
1693 ** Description Test function frames the PRBS command.
1694 **
1695 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
1696 **
1697 *******************************************************************************/
1698 #if(NFC_NXP_CHIP_TYPE != PN547C2)
phNxpNciHal_getPrbsCmd(phNxpNfc_PrbsType_t prbs_type,phNxpNfc_PrbsHwType_t hw_prbs_type,uint8_t tech,uint8_t bitrate,uint8_t * prbs_cmd,uint8_t prbs_cmd_len)1699 NFCSTATUS phNxpNciHal_getPrbsCmd (phNxpNfc_PrbsType_t prbs_type, phNxpNfc_PrbsHwType_t hw_prbs_type,
1700 uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len)
1701 #else
1702 NFCSTATUS phNxpNciHal_getPrbsCmd (uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len)
1703 #endif
1704 {
1705 NFCSTATUS status = NFCSTATUS_SUCCESS;
1706 int position_tech_param = 0;
1707 int position_bit_param = 0;
1708
1709 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - tech 0x%x bitrate = 0x%x", tech, bitrate);
1710 if(NULL == prbs_cmd ||
1711 #if(NFC_NXP_CHIP_TYPE != PN547C2)
1712 prbs_cmd_len != 0x09)
1713 #else
1714 prbs_cmd_len != 0x07)
1715 #endif
1716 {
1717 return status;
1718 }
1719
1720 prbs_cmd[0] = 0x2F;
1721 prbs_cmd[1] = 0x30;
1722 #if(NFC_NXP_CHIP_TYPE != PN547C2)
1723 prbs_cmd[2] = 0x06;
1724 prbs_cmd[3] = (uint8_t)prbs_type;
1725 //0xFF Error value used for validation.
1726 prbs_cmd[4] = (uint8_t)hw_prbs_type;
1727 prbs_cmd[5] = 0xFF;//TECH
1728 prbs_cmd[6] = 0xFF;//BITRATE
1729 prbs_cmd[7] = 0x01;
1730 prbs_cmd[8] = 0xFF;
1731 position_tech_param = 5;
1732 position_bit_param = 6;
1733 #else
1734 prbs_cmd[2] = 0x04;
1735 //0xFF Error value used for validation.
1736 prbs_cmd[3] = 0xFF;//TECH
1737 //0xFF Error value used for validation.
1738 prbs_cmd[4] = 0xFF;//BITRATE
1739 prbs_cmd[5] = 0x01;
1740 prbs_cmd[6] = 0xFF;
1741 position_tech_param = 3;
1742 position_bit_param = 4;
1743 #endif
1744
1745 switch (tech) {
1746 case NFC_RF_TECHNOLOGY_A:
1747 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_A");
1748 prbs_cmd[position_tech_param] = 0x00;
1749 break;
1750 case NFC_RF_TECHNOLOGY_B:
1751 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_B");
1752 prbs_cmd[position_tech_param] = 0x01;
1753 break;
1754 case NFC_RF_TECHNOLOGY_F:
1755 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_F");
1756 prbs_cmd[position_tech_param] = 0x02;
1757 break;
1758 default:
1759 break;
1760 }
1761
1762 switch (bitrate)
1763 {
1764 case NFC_BIT_RATE_106:
1765 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_106");
1766 if(prbs_cmd[position_tech_param] != 0x02)
1767 {
1768 prbs_cmd[position_bit_param] = 0x00;
1769 }
1770 break;
1771 case NFC_BIT_RATE_212:
1772 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_212");
1773 prbs_cmd[position_bit_param] = 0x01;
1774 break;
1775 case NFC_BIT_RATE_424:
1776 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_424");
1777 prbs_cmd[position_bit_param] = 0x02;
1778 break;
1779 case NFC_BIT_RATE_848:
1780 NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_848");
1781 if(prbs_cmd[position_tech_param] != 0x02)
1782 {
1783 prbs_cmd[position_bit_param] = 0x03;
1784 }
1785 break;
1786 default:
1787 break;
1788 }
1789
1790 if(prbs_cmd[position_tech_param] == 0xFF || prbs_cmd[position_bit_param] == 0xFF)
1791 {
1792 //Invalid Param.
1793 status = NFCSTATUS_FAILED;
1794 }
1795
1796 return status;
1797 }
1798
1799 /*******************************************************************************
1800 **
1801 ** Function phNxpNciHal_RfFieldTest
1802 **
1803 ** Description Test function performs RF filed test.
1804 **
1805 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
1806 **
1807 *******************************************************************************/
phNxpNciHal_RfFieldTest(uint8_t on)1808 NFCSTATUS phNxpNciHal_RfFieldTest (uint8_t on)
1809 {
1810 NFCSTATUS status = NFCSTATUS_SUCCESS;
1811 int len = 0;
1812 int cnt = 0;
1813
1814 NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - start %x\n",on);
1815
1816 if(on == 0x01)
1817 {
1818 len = (sizeof(rf_field_on_test_data)/sizeof(rf_field_on_test_data[0]));
1819
1820 for(cnt = 0; cnt < len; cnt++)
1821 {
1822 status = phNxpNciHal_performTest(&(rf_field_on_test_data[cnt]));
1823 if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
1824 {
1825 break;
1826 }
1827 }
1828 }
1829 else if(on == 0x00)
1830 {
1831 len = (sizeof(rf_field_off_test_data)/sizeof(rf_field_off_test_data[0]));
1832
1833 for(cnt = 0; cnt < len; cnt++)
1834 {
1835 status = phNxpNciHal_performTest(&(rf_field_off_test_data[cnt]));
1836 if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
1837 {
1838 break;
1839 }
1840 }
1841 }
1842 else
1843 {
1844 status = NFCSTATUS_FAILED;
1845 }
1846
1847 if( status == NFCSTATUS_SUCCESS)
1848 {
1849 NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - SUCCESSS\n");
1850 }
1851 else
1852 {
1853 NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - FAILED\n");
1854 }
1855
1856 NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - end\n");
1857
1858 return status;
1859 }
1860
1861 /*******************************************************************************
1862 **
1863 ** Function phNxpNciHal_AntennaTest
1864 **
1865 ** Description
1866 **
1867 ** Returns
1868 **
1869 *******************************************************************************/
phNxpNciHal_AntennaTest()1870 NFCSTATUS phNxpNciHal_AntennaTest ()
1871 {
1872 NFCSTATUS status = NFCSTATUS_FAILED;
1873
1874 return status;
1875 }
1876
1877 /*******************************************************************************
1878 **
1879 ** Function phNxpNciHal_DownloadPinTest
1880 **
1881 ** Description Test function to validate the FW download pin connection.
1882 **
1883 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
1884 **
1885 *******************************************************************************/
phNxpNciHal_DownloadPinTest(void)1886 NFCSTATUS phNxpNciHal_DownloadPinTest(void)
1887 {
1888 NFCSTATUS status = NFCSTATUS_FAILED;
1889 int len = 0;
1890 int cnt = 0;
1891
1892 NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - start\n");
1893
1894 len = (sizeof(download_pin_test_data1)/sizeof(download_pin_test_data1[0]));
1895
1896 for(cnt = 0; cnt < len; cnt++)
1897 {
1898 status = phNxpNciHal_performTest(&(download_pin_test_data1[cnt]));
1899 if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
1900 {
1901 break;
1902 }
1903 }
1904
1905 if (status != NFCSTATUS_SUCCESS)
1906 {
1907 NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n");
1908 return status;
1909 }
1910
1911 status = NFCSTATUS_FAILED;
1912 status = phTmlNfc_IoCtl(phTmlNfc_e_EnableDownloadMode);
1913 if (NFCSTATUS_SUCCESS != status)
1914 {
1915 NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n");
1916 return status;
1917 }
1918
1919 status = NFCSTATUS_FAILED;
1920 len = (sizeof(download_pin_test_data2)/sizeof(download_pin_test_data2[0]));
1921
1922 for(cnt = 0; cnt < len; cnt++)
1923 {
1924 status = phNxpNciHal_performTest(&(download_pin_test_data2[cnt]));
1925 if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
1926 {
1927 break;
1928 }
1929 }
1930
1931 if( status == NFCSTATUS_SUCCESS)
1932 {
1933 NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - SUCCESSS\n");
1934 }
1935 else
1936 {
1937 NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n");
1938 }
1939
1940 NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - end\n");
1941
1942 return status;
1943 }
1944 /*******************************************************************************
1945 **
1946 ** Function phNxpNciHal_AntennaSelfTest
1947 **
1948 ** Description Test function to validate the Antenna's discrete
1949 ** components connection.
1950 **
1951 ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
1952 **
1953 *******************************************************************************/
phNxpNciHal_AntennaSelfTest(phAntenna_St_Resp_t * phAntenna_St_Resp)1954 NFCSTATUS phNxpNciHal_AntennaSelfTest(phAntenna_St_Resp_t * phAntenna_St_Resp )
1955 {
1956 NFCSTATUS status = NFCSTATUS_FAILED;
1957 NFCSTATUS antenna_st_status = NFCSTATUS_FAILED;
1958 int len = 0;
1959 int cnt = 0;
1960
1961 NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - start\n");
1962 memcpy(&phAntenna_resp, phAntenna_St_Resp, sizeof(phAntenna_St_Resp_t));
1963 len = (sizeof(antenna_self_test_data)/sizeof(antenna_self_test_data[0]));
1964
1965 for(cnt = 0; cnt < len; cnt++)
1966 {
1967 status = phNxpNciHal_performTest(&(antenna_self_test_data[cnt]));
1968 if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
1969 {
1970 NXPLOG_NCIHAL_E("phNxpNciHal_AntennaSelfTest: commnad execution - FAILED\n");
1971 break;
1972 }
1973 }
1974
1975 if(status == NFCSTATUS_SUCCESS)
1976 {
1977 if((gtxldo_status == NFCSTATUS_SUCCESS) && (gagc_value_status == NFCSTATUS_SUCCESS) &&
1978 (gagc_nfcld_status == NFCSTATUS_SUCCESS) && (gagc_differential_status == NFCSTATUS_SUCCESS))
1979 {
1980 antenna_st_status = NFCSTATUS_SUCCESS;
1981 NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - SUCESS\n");
1982 }
1983 else
1984 {
1985 NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - FAILED\n");
1986 }
1987 }
1988 else
1989 {
1990 NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - FAILED\n");
1991 }
1992
1993 NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - end\n");
1994
1995 return antenna_st_status;
1996 }
1997
1998 #endif /*#ifdef NXP_HW_SELF_TEST*/
1999