1 /******************************************************************************
2 *
3 * Copyright (C) 2010-2014 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file contains functions that interface with the NFC NCI transport.
22 * On the receive side, it routes events to the appropriate handler
23 * (callback). On the transmit side, it manages the command transmission.
24 *
25 ******************************************************************************/
26 #include <android-base/logging.h>
27 #include <android-base/stringprintf.h>
28 #include <android/hardware/nfc/1.1/types.h>
29 #include <string.h>
30
31 #include "bt_types.h"
32 #include "ce_int.h"
33 #include "gki.h"
34 #include "nci_hmsgs.h"
35 #include "nfa_sys.h"
36 #include "nfc_api.h"
37 #include "nfc_int.h"
38 #include "nfc_target.h"
39 #include "rw_int.h"
40
41 #if (NFC_RW_ONLY == FALSE)
42
43 /* NFC mandates support for at least one logical connection;
44 * Update max_conn to the NFCC capability on InitRsp */
45 #define NFC_SET_MAX_CONN_DEFAULT() \
46 { nfc_cb.max_conn = 1; }
47
48 #else /* NFC_RW_ONLY */
49 #define ce_init()
50
51 #define NFC_SET_MAX_CONN_DEFAULT()
52
53 #endif /* NFC_RW_ONLY */
54
55 using android::base::StringPrintf;
56 using android::hardware::nfc::V1_1::NfcEvent;
57
58 extern void delete_stack_non_volatile_store(bool forceDelete);
59
60 /****************************************************************************
61 ** Declarations
62 ****************************************************************************/
63 tNFC_CB nfc_cb;
64
65 #if (NFC_RW_ONLY == FALSE)
66 #define NFC_NUM_INTERFACE_MAP 2
67 #else
68 #define NFC_NUM_INTERFACE_MAP 1
69 #endif
70
71 static const tNCI_DISCOVER_MAPS nfc_interface_mapping[NFC_NUM_INTERFACE_MAP] = {
72 /* Protocols that use Frame Interface do not need to be included in the
73 interface mapping */
74 {NCI_PROTOCOL_ISO_DEP, NCI_INTERFACE_MODE_POLL_N_LISTEN,
75 NCI_INTERFACE_ISO_DEP}
76 #if (NFC_RW_ONLY == FALSE)
77 ,
78 /* this can not be set here due to 2079xB0 NFCC issues */
79 {NCI_PROTOCOL_NFC_DEP, NCI_INTERFACE_MODE_POLL_N_LISTEN,
80 NCI_INTERFACE_NFC_DEP}
81 #endif
82 };
83
84 /*******************************************************************************
85 **
86 ** Function nfc_state_name
87 **
88 ** Description This function returns the state name.
89 **
90 ** NOTE conditionally compiled to save memory.
91 **
92 ** Returns pointer to the name
93 **
94 *******************************************************************************/
nfc_state_name(uint8_t state)95 static std::string nfc_state_name(uint8_t state) {
96 switch (state) {
97 case NFC_STATE_NONE:
98 return "NONE";
99 case NFC_STATE_W4_HAL_OPEN:
100 return "W4_HAL_OPEN";
101 case NFC_STATE_CORE_INIT:
102 return "CORE_INIT";
103 case NFC_STATE_W4_POST_INIT_CPLT:
104 return "W4_POST_INIT_CPLT";
105 case NFC_STATE_IDLE:
106 return "IDLE";
107 case NFC_STATE_OPEN:
108 return "OPEN";
109 case NFC_STATE_CLOSING:
110 return "CLOSING";
111 case NFC_STATE_W4_HAL_CLOSE:
112 return "W4_HAL_CLOSE";
113 case NFC_STATE_NFCC_POWER_OFF_SLEEP:
114 return "NFCC_POWER_OFF_SLEEP";
115 default:
116 return "???? UNKNOWN STATE";
117 }
118 }
119
120 /*******************************************************************************
121 **
122 ** Function nfc_hal_event_name
123 **
124 ** Description This function returns the HAL event name.
125 **
126 ** NOTE conditionally compiled to save memory.
127 **
128 ** Returns pointer to the name
129 **
130 *******************************************************************************/
nfc_hal_event_name(uint8_t event)131 static std::string nfc_hal_event_name(uint8_t event) {
132 switch (event) {
133 case HAL_NFC_OPEN_CPLT_EVT:
134 return "HAL_NFC_OPEN_CPLT_EVT";
135 case HAL_NFC_CLOSE_CPLT_EVT:
136 return "HAL_NFC_CLOSE_CPLT_EVT";
137 case HAL_NFC_POST_INIT_CPLT_EVT:
138 return "HAL_NFC_POST_INIT_CPLT_EVT";
139 case HAL_NFC_PRE_DISCOVER_CPLT_EVT:
140 return "HAL_NFC_PRE_DISCOVER_CPLT_EVT";
141 case HAL_NFC_REQUEST_CONTROL_EVT:
142 return "HAL_NFC_REQUEST_CONTROL_EVT";
143 case HAL_NFC_RELEASE_CONTROL_EVT:
144 return "HAL_NFC_RELEASE_CONTROL_EVT";
145 case HAL_NFC_ERROR_EVT:
146 return "HAL_NFC_ERROR_EVT";
147 case HAL_HCI_NETWORK_RESET:
148 return "HCI_NETWORK_RESET";
149 default:
150 return "???? UNKNOWN EVENT";
151 }
152 }
153
154 /*******************************************************************************
155 **
156 ** Function nfc_main_notify_enable_status
157 **
158 ** Description Notify status of Enable/PowerOffSleep/PowerCycle
159 **
160 *******************************************************************************/
nfc_main_notify_enable_status(tNFC_STATUS nfc_status)161 static void nfc_main_notify_enable_status(tNFC_STATUS nfc_status) {
162 tNFC_RESPONSE evt_data;
163
164 evt_data.status = nfc_status;
165
166 if (nfc_cb.p_resp_cback) {
167 /* if getting out of PowerOffSleep mode or restarting NFCC */
168 if (nfc_cb.flags & (NFC_FL_RESTARTING | NFC_FL_POWER_CYCLE_NFCC)) {
169 nfc_cb.flags &= ~(NFC_FL_RESTARTING | NFC_FL_POWER_CYCLE_NFCC);
170 if (nfc_status != NFC_STATUS_OK) {
171 nfc_cb.flags |= NFC_FL_POWER_OFF_SLEEP;
172 }
173 (*nfc_cb.p_resp_cback)(NFC_NFCC_RESTART_REVT, &evt_data);
174 } else {
175 (*nfc_cb.p_resp_cback)(NFC_ENABLE_REVT, &evt_data);
176 }
177 }
178 }
179
180 /*******************************************************************************
181 **
182 ** Function nfc_enabled
183 **
184 ** Description NFCC enabled, proceed with stack start up.
185 **
186 ** Returns void
187 **
188 *******************************************************************************/
nfc_enabled(tNFC_STATUS nfc_status,NFC_HDR * p_init_rsp_msg)189 void nfc_enabled(tNFC_STATUS nfc_status, NFC_HDR* p_init_rsp_msg) {
190 tNFC_RESPONSE evt_data;
191 tNFC_CONN_CB* p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID];
192 int16_t lremain = 0;
193 uint8_t* p;
194 uint8_t num_interfaces = 0, xx;
195 uint8_t num_interface_extensions = 0, zz;
196 uint8_t interface_type;
197 int yy = 0;
198 memset(&evt_data, 0, sizeof(tNFC_RESPONSE));
199
200 if (nfc_status == NCI_STATUS_OK) {
201 nfc_set_state(NFC_STATE_IDLE);
202
203 p = (uint8_t*)(p_init_rsp_msg + 1) + p_init_rsp_msg->offset +
204 NCI_MSG_HDR_SIZE + 1;
205
206 lremain = p_init_rsp_msg->len - NCI_MSG_HDR_SIZE - 1 - sizeof(uint32_t) - 5;
207 if (lremain < 0) {
208 nfc_status = NCI_STATUS_FAILED;
209 goto plen_err;
210 }
211 /* we currently only support NCI of the same version.
212 * We may need to change this, when we support multiple version of NFCC */
213
214 evt_data.enable.nci_version = nfc_cb.nci_version;
215 STREAM_TO_UINT32(evt_data.enable.nci_features, p);
216 if (nfc_cb.nci_version == NCI_VERSION_1_0) {
217 /* this byte is consumed in the top expression */
218 STREAM_TO_UINT8(num_interfaces, p);
219 lremain -= num_interfaces;
220 if (lremain < 0) {
221 nfc_status = NCI_STATUS_FAILED;
222 goto plen_err;
223 }
224 evt_data.enable.nci_interfaces = 0;
225 for (xx = 0; xx < num_interfaces; xx++) {
226 if ((*p) <= NCI_INTERFACE_MAX)
227 evt_data.enable.nci_interfaces |= (1 << (*p));
228 else if (((*p) >= NCI_INTERFACE_FIRST_VS) &&
229 (yy < NFC_NFCC_MAX_NUM_VS_INTERFACE)) {
230 /* save the VS RF interface in control block, if there's still room */
231 nfc_cb.vs_interface[yy++] = *p;
232 }
233 p++;
234 }
235 nfc_cb.nci_interfaces = evt_data.enable.nci_interfaces;
236 memcpy(evt_data.enable.vs_interface, nfc_cb.vs_interface,
237 NFC_NFCC_MAX_NUM_VS_INTERFACE);
238 }
239 /* four bytes below are consumed in the top expression */
240 // Max nb conn = nb static conn + max nb dynamic conn
241 evt_data.enable.max_conn = NCI_MAX_STATIC_CONN_CBS + *p++;
242 STREAM_TO_UINT16(evt_data.enable.max_ce_table, p);
243 #if (NFC_RW_ONLY == FALSE)
244 nfc_cb.max_ce_table = evt_data.enable.max_ce_table;
245 nfc_cb.nci_features = evt_data.enable.nci_features;
246 nfc_cb.max_conn = evt_data.enable.max_conn;
247 #endif
248 nfc_cb.nci_ctrl_size = *p++; /* Max Control Packet Payload Length */
249 p_cb->init_credits = p_cb->num_buff = 0;
250 nfc_set_conn_id(p_cb, NFC_RF_CONN_ID);
251 if (nfc_cb.nci_version >= NCI_VERSION_2_0) {
252 /* one byte is consumed in the top expression and
253 * 3 bytes from uit16+uint8 below */
254 lremain -= 4;
255 if (lremain < 0) {
256 nfc_status = NCI_STATUS_FAILED;
257 goto plen_err;
258 }
259 if (evt_data.enable.nci_features & NCI_FEAT_HCI_NETWORK) {
260 p_cb = &nfc_cb.conn_cb[NFC_HCI_CONN_ID];
261 nfc_set_conn_id(p_cb, NFC_HCI_CONN_ID);
262 p_cb->id = NFC_HCI_CONN_ID;
263 STREAM_TO_UINT8(p_cb->buff_size, p);
264 STREAM_TO_UINT8(p_cb->num_buff, p);
265 p_cb->init_credits = p_cb->num_buff;
266 evt_data.enable.hci_packet_size = p_cb->buff_size;
267 evt_data.enable.hci_conn_credits = p_cb->init_credits;
268 LOG(VERBOSE) << StringPrintf("hci num_buf=%d buf_size=%d", p_cb->num_buff,
269 p_cb->buff_size);
270 } else {
271 /*HCI n/w not enabled skip data buff size and data credit HCI conn */
272 p += 2;
273 }
274 STREAM_TO_UINT16(evt_data.enable.max_nfc_v_size, p);
275 STREAM_TO_UINT8(num_interfaces, p);
276 #if (NFC_RW_ONLY == FALSE)
277 nfc_cb.hci_packet_size = evt_data.enable.hci_packet_size;
278 nfc_cb.hci_conn_credits = evt_data.enable.hci_conn_credits;
279 nfc_cb.nci_max_v_size = evt_data.enable.max_nfc_v_size;
280 #endif
281 evt_data.enable.nci_interfaces = 0;
282
283 for (xx = 0; xx < num_interfaces; xx++) {
284 lremain -= 2;
285 if (lremain < 0) {
286 nfc_status = NCI_STATUS_FAILED;
287 goto plen_err;
288 }
289 if ((*p) <= NCI_INTERFACE_MAX)
290 evt_data.enable.nci_interfaces |= (1 << (*p));
291 else if (((*p) >= NCI_INTERFACE_FIRST_VS) &&
292 (yy < NFC_NFCC_MAX_NUM_VS_INTERFACE)) {
293 /* save the VS RF interface in control block, if there's still room */
294 nfc_cb.vs_interface[yy++] = *p;
295 }
296 interface_type = *p++;
297 num_interface_extensions = *p++;
298 lremain -= num_interface_extensions;
299 if (lremain < 0) {
300 nfc_status = NCI_STATUS_FAILED;
301 goto plen_err;
302 }
303 for (zz = 0; zz < num_interface_extensions; zz++) {
304 if (((*p) < NCI_INTERFACE_EXTENSION_MAX) &&
305 (interface_type <= NCI_INTERFACE_MAX)) {
306 nfc_cb.nci_intf_extensions |= (1 << (*p));
307 nfc_cb.nci_intf_extension_map[*p] = (1 << interface_type);
308 }
309 p++;
310 }
311 }
312
313 nfc_cb.nci_interfaces = evt_data.enable.nci_interfaces;
314 memcpy(evt_data.enable.vs_interface, nfc_cb.vs_interface,
315 NFC_NFCC_MAX_NUM_VS_INTERFACE);
316 } else {
317 /* For VERSION_UNKNOWN one byte is consumed in the top expression */
318 lremain -= sizeof(uint16_t) + NFC_NFCC_INFO_LEN +
319 (nfc_cb.nci_version == NCI_VERSION_1_0 ? 1 : 0);
320 if (lremain < 0) {
321 nfc_status = NCI_STATUS_FAILED;
322 goto plen_err;
323 }
324 STREAM_TO_UINT16(evt_data.enable.max_param_size, p);
325 evt_data.enable.manufacture_id = *p++;
326 STREAM_TO_ARRAY(evt_data.enable.nfcc_info, p, NFC_NFCC_INFO_LEN);
327 }
328 NFC_DiscoveryMap(nfc_cb.num_disc_maps,
329 (tNCI_DISCOVER_MAPS*)nfc_cb.p_disc_maps, nullptr);
330 }
331 /* else not successful. the buffers will be freed in nfc_free_conn_cb () */
332 else {
333 plen_err:
334 if (nfc_cb.flags & NFC_FL_RESTARTING) {
335 nfc_set_state(NFC_STATE_NFCC_POWER_OFF_SLEEP);
336 } else {
337 nfc_free_conn_cb(p_cb);
338
339 /* if NFCC didn't respond to CORE_RESET or CORE_INIT */
340 if (nfc_cb.nfc_state == NFC_STATE_CORE_INIT) {
341 /* report status after closing HAL */
342 nfc_cb.p_hal->close();
343 return;
344 } else
345 nfc_set_state(NFC_STATE_NONE);
346 }
347 }
348
349 nfc_main_notify_enable_status(nfc_status);
350 }
351
352 /*******************************************************************************
353 **
354 ** Function nfc_set_state
355 **
356 ** Description Set the state of NFC stack
357 **
358 ** Returns void
359 **
360 *******************************************************************************/
nfc_set_state(tNFC_STATE nfc_state)361 void nfc_set_state(tNFC_STATE nfc_state) {
362 LOG(VERBOSE) << StringPrintf("nfc_set_state %d (%s)->%d (%s)", nfc_cb.nfc_state,
363 nfc_state_name(nfc_cb.nfc_state).c_str(),
364 nfc_state, nfc_state_name(nfc_state).c_str());
365 nfc_cb.nfc_state = nfc_state;
366 }
367
368 /*******************************************************************************
369 **
370 ** Function nfc_gen_cleanup
371 **
372 ** Description Clean up for both going into low power mode and disabling
373 ** NFC
374 **
375 *******************************************************************************/
nfc_gen_cleanup(void)376 void nfc_gen_cleanup(void) {
377 nfc_cb.flags &= ~NFC_FL_DEACTIVATING;
378
379 /* the HAL pre-discover is still active - clear the pending flag/free the
380 * buffer */
381 if (nfc_cb.flags & NFC_FL_DISCOVER_PENDING) {
382 nfc_cb.flags &= ~NFC_FL_DISCOVER_PENDING;
383 GKI_freebuf(nfc_cb.p_disc_pending);
384 nfc_cb.p_disc_pending = nullptr;
385 }
386
387 nfc_cb.flags &= ~(NFC_FL_CONTROL_REQUESTED | NFC_FL_CONTROL_GRANTED |
388 NFC_FL_HAL_REQUESTED);
389
390 nfc_stop_timer(&nfc_cb.deactivate_timer);
391
392 /* Reset the connection control blocks */
393 nfc_reset_all_conn_cbs();
394
395 if (nfc_cb.p_nci_init_rsp) {
396 GKI_freebuf(nfc_cb.p_nci_init_rsp);
397 nfc_cb.p_nci_init_rsp = nullptr;
398 }
399
400 /* clear any pending CMD/RSP */
401 nfc_main_flush_cmd_queue();
402 }
403
404 /*******************************************************************************
405 **
406 ** Function nfc_main_handle_hal_evt
407 **
408 ** Description Handle BT_EVT_TO_NFC_MSGS
409 **
410 *******************************************************************************/
nfc_main_handle_hal_evt(tNFC_HAL_EVT_MSG * p_msg)411 void nfc_main_handle_hal_evt(tNFC_HAL_EVT_MSG* p_msg) {
412 uint8_t* ps;
413
414 LOG(VERBOSE) << StringPrintf("HAL event=0x%x", p_msg->hal_evt);
415
416 switch (p_msg->hal_evt) {
417 case HAL_NFC_OPEN_CPLT_EVT: /* only for failure case */
418 nfc_enabled(NFC_STATUS_FAILED, nullptr);
419 break;
420
421 case HAL_NFC_CLOSE_CPLT_EVT:
422 if (nfc_cb.p_resp_cback) {
423 if (nfc_cb.nfc_state == NFC_STATE_W4_HAL_CLOSE) {
424 if (nfc_cb.flags & NFC_FL_POWER_OFF_SLEEP) {
425 nfc_cb.flags &= ~NFC_FL_POWER_OFF_SLEEP;
426 nfc_set_state(NFC_STATE_NFCC_POWER_OFF_SLEEP);
427 (*nfc_cb.p_resp_cback)(NFC_NFCC_POWER_OFF_REVT, nullptr);
428 } else {
429 nfc_set_state(NFC_STATE_NONE);
430 (*nfc_cb.p_resp_cback)(NFC_DISABLE_REVT, nullptr);
431 nfc_cb.p_resp_cback = nullptr;
432 }
433 } else {
434 /* found error during initialization */
435 nfc_set_state(NFC_STATE_NONE);
436 nfc_main_notify_enable_status(NFC_STATUS_FAILED);
437 }
438 }
439 break;
440
441 case HAL_NFC_POST_INIT_CPLT_EVT:
442 if (nfc_cb.nfcc_mode == ENABLE_MODE_TRANSPARENT) {
443 nfc_set_state(NFC_STATE_IDLE);
444 nfa_sys_cback_notify_partial_enable_complete(NFA_ID_SYS);
445 } else if (nfc_cb.p_nci_init_rsp) {
446 /*
447 ** if NFC_Disable() is called before receiving
448 ** HAL_NFC_POST_INIT_CPLT_EVT, then wait for HAL_NFC_CLOSE_CPLT_EVT.
449 */
450 if (nfc_cb.nfc_state == NFC_STATE_W4_POST_INIT_CPLT) {
451 if (p_msg->status == HAL_NFC_STATUS_OK) {
452 nfc_enabled(NCI_STATUS_OK, nfc_cb.p_nci_init_rsp);
453 } else /* if post initailization failed */
454 {
455 nfc_enabled(NCI_STATUS_FAILED, nullptr);
456 }
457 }
458
459 GKI_freebuf(nfc_cb.p_nci_init_rsp);
460 nfc_cb.p_nci_init_rsp = nullptr;
461 }
462 break;
463
464 case HAL_NFC_PRE_DISCOVER_CPLT_EVT:
465 /* restore the command window, no matter if the discover command is still
466 * pending */
467 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW;
468 nfc_cb.flags &= ~NFC_FL_CONTROL_GRANTED;
469 if (nfc_cb.flags & NFC_FL_DISCOVER_PENDING) {
470 /* issue the discovery command now, if it is still pending */
471 nfc_cb.flags &= ~NFC_FL_DISCOVER_PENDING;
472 ps = (uint8_t*)nfc_cb.p_disc_pending;
473 nci_snd_discover_cmd(*ps, (tNFC_DISCOVER_PARAMS*)(ps + 1));
474 GKI_freebuf(nfc_cb.p_disc_pending);
475 nfc_cb.p_disc_pending = nullptr;
476 } else {
477 /* check if there's other pending commands */
478 nfc_ncif_check_cmd_queue(nullptr);
479 }
480
481 if (p_msg->status == HAL_NFC_STATUS_ERR_CMD_TIMEOUT)
482 nfc_ncif_event_status(NFC_NFCC_TIMEOUT_REVT, NFC_STATUS_HW_TIMEOUT);
483 break;
484
485 case HAL_NFC_REQUEST_CONTROL_EVT:
486 nfc_cb.flags |= NFC_FL_CONTROL_REQUESTED;
487 nfc_cb.flags |= NFC_FL_HAL_REQUESTED;
488 nfc_ncif_check_cmd_queue(nullptr);
489 break;
490
491 case HAL_NFC_RELEASE_CONTROL_EVT:
492 if (nfc_cb.flags & NFC_FL_CONTROL_GRANTED) {
493 nfc_cb.flags &= ~NFC_FL_CONTROL_GRANTED;
494 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW;
495 nfc_ncif_check_cmd_queue(nullptr);
496
497 if (p_msg->status == HAL_NFC_STATUS_ERR_CMD_TIMEOUT)
498 nfc_ncif_event_status(NFC_NFCC_TIMEOUT_REVT, NFC_STATUS_HW_TIMEOUT);
499 }
500 break;
501
502 case HAL_NFC_ERROR_EVT:
503 switch (p_msg->status) {
504 case HAL_NFC_STATUS_ERR_TRANSPORT:
505 /* Notify app of transport error */
506 if (nfc_cb.p_resp_cback) {
507 (*nfc_cb.p_resp_cback)(NFC_NFCC_TRANSPORT_ERR_REVT, nullptr);
508
509 /* if enabling NFC, notify upper layer of failure after closing HAL
510 */
511 if (nfc_cb.nfc_state < NFC_STATE_IDLE) {
512 nfc_enabled(NFC_STATUS_FAILED, nullptr);
513 }
514 }
515 break;
516
517 case HAL_NFC_STATUS_ERR_CMD_TIMEOUT:
518 nfc_ncif_event_status(NFC_NFCC_TIMEOUT_REVT, NFC_STATUS_HW_TIMEOUT);
519
520 /* if enabling NFC, notify upper layer of failure after closing HAL */
521 if (nfc_cb.nfc_state < NFC_STATE_IDLE) {
522 nfc_enabled(NFC_STATUS_FAILED, nullptr);
523 return;
524 }
525 break;
526
527 default:
528 break;
529 }
530 break;
531
532 case HAL_HCI_NETWORK_RESET:
533 delete_stack_non_volatile_store(true);
534 break;
535
536 default:
537 LOG(ERROR) << StringPrintf("unhandled event (0x%x).", p_msg->hal_evt);
538 break;
539 }
540 }
541
542 /*******************************************************************************
543 **
544 ** Function nfc_main_flush_cmd_queue
545 **
546 ** Description This function is called when setting power off sleep state.
547 **
548 ** Returns void
549 **
550 *******************************************************************************/
nfc_main_flush_cmd_queue(void)551 void nfc_main_flush_cmd_queue(void) {
552 NFC_HDR* p_msg;
553
554 LOG(VERBOSE) << __func__;
555
556 /* initialize command window */
557 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW;
558
559 /* Stop command-pending timer */
560 nfc_stop_timer(&nfc_cb.nci_wait_rsp_timer);
561
562 /* dequeue and free buffer */
563 while ((p_msg = (NFC_HDR*)GKI_dequeue(&nfc_cb.nci_cmd_xmit_q)) != nullptr) {
564 GKI_freebuf(p_msg);
565 }
566 }
567
568 /*******************************************************************************
569 **
570 ** Function nfc_main_post_hal_evt
571 **
572 ** Description This function posts HAL event to NFC_TASK
573 **
574 ** Returns void
575 **
576 *******************************************************************************/
nfc_main_post_hal_evt(uint8_t hal_evt,tHAL_NFC_STATUS status)577 void nfc_main_post_hal_evt(uint8_t hal_evt, tHAL_NFC_STATUS status) {
578 tNFC_HAL_EVT_MSG* p_msg;
579
580 p_msg = (tNFC_HAL_EVT_MSG*)GKI_getbuf(sizeof(tNFC_HAL_EVT_MSG));
581 if (p_msg != nullptr) {
582 /* Initialize NFC_HDR */
583 p_msg->hdr.len = 0;
584 p_msg->hdr.event = BT_EVT_TO_NFC_MSGS;
585 p_msg->hdr.offset = 0;
586 p_msg->hdr.layer_specific = 0;
587 p_msg->hal_evt = hal_evt;
588 p_msg->status = status;
589 GKI_send_msg(NFC_TASK, NFC_MBOX_ID, p_msg);
590 } else {
591 LOG(ERROR) << StringPrintf("No buffer");
592 }
593 }
594
595 /*******************************************************************************
596 **
597 ** Function nfc_main_hal_cback
598 **
599 ** Description HAL event handler
600 **
601 ** Returns void
602 **
603 *******************************************************************************/
nfc_main_hal_cback(uint8_t event,tHAL_NFC_STATUS status)604 static void nfc_main_hal_cback(uint8_t event, tHAL_NFC_STATUS status) {
605 LOG(VERBOSE) << StringPrintf("nfc_main_hal_cback event: %s(0x%x), status=%d",
606 nfc_hal_event_name(event).c_str(), event, status);
607
608 switch (event) {
609 case HAL_NFC_OPEN_CPLT_EVT:
610 /*
611 ** if NFC_Disable() is called before receiving HAL_NFC_OPEN_CPLT_EVT,
612 ** then wait for HAL_NFC_CLOSE_CPLT_EVT.
613 */
614 if (nfc_cb.nfc_state == NFC_STATE_W4_HAL_OPEN) {
615 if (status == HAL_NFC_STATUS_OK) {
616 /* Notify NFC_TASK that NCI tranport is initialized */
617 GKI_send_event(NFC_TASK, NFC_TASK_EVT_TRANSPORT_READY);
618 } else {
619 nfc_main_post_hal_evt(event, status);
620 }
621 }
622 break;
623
624 case HAL_NFC_CLOSE_CPLT_EVT:
625 case HAL_NFC_POST_INIT_CPLT_EVT:
626 case HAL_NFC_PRE_DISCOVER_CPLT_EVT:
627 case HAL_NFC_REQUEST_CONTROL_EVT:
628 case HAL_NFC_RELEASE_CONTROL_EVT:
629 case HAL_NFC_ERROR_EVT:
630 case HAL_HCI_NETWORK_RESET:
631 nfc_main_post_hal_evt(event, status);
632 break;
633
634 default:
635 LOG(VERBOSE) << StringPrintf("nfc_main_hal_cback unhandled event %x",
636 event);
637 break;
638 }
639 }
640
641 /*******************************************************************************
642 **
643 ** Function nfc_main_hal_data_cback
644 **
645 ** Description HAL data event handler
646 **
647 ** Returns void
648 **
649 *******************************************************************************/
nfc_main_hal_data_cback(uint16_t data_len,uint8_t * p_data)650 static void nfc_main_hal_data_cback(uint16_t data_len, uint8_t* p_data) {
651 NFC_HDR* p_msg;
652
653 /* ignore all data while shutting down NFCC */
654 if (nfc_cb.nfc_state == NFC_STATE_W4_HAL_CLOSE) {
655 return;
656 }
657
658 if (p_data) {
659 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
660 // GKI_getpoolbuf returns a fixed size of memory buffer, which is usually
661 // bigger than NFC packets. This may hide OOB issues.
662 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR) + NFC_RECEIVE_MSGS_OFFSET +
663 data_len);
664 #else
665 p_msg = (NFC_HDR*)GKI_getpoolbuf(NFC_NCI_POOL_ID);
666 #endif
667 if (p_msg != nullptr) {
668 /* Initialize NFC_HDR */
669 p_msg->len = data_len;
670 p_msg->event = BT_EVT_TO_NFC_NCI;
671 p_msg->offset = NFC_RECEIVE_MSGS_OFFSET;
672
673 /* no need to check length, it always less than pool size */
674 memcpy((uint8_t*)(p_msg + 1) + p_msg->offset, p_data, p_msg->len);
675
676 GKI_send_msg(NFC_TASK, NFC_MBOX_ID, p_msg);
677 } else {
678 LOG(ERROR) << StringPrintf("No buffer");
679 }
680 }
681 }
682
683 /*******************************************************************************
684 **
685 ** Function NFC_Enable
686 **
687 ** Description This function enables NFC. Prior to calling NFC_Enable:
688 ** - the NFCC must be powered up, and ready to receive
689 ** commands.
690 ** - GKI must be enabled
691 ** - NFC_TASK must be started
692 ** - NCIT_TASK must be started (if using dedicated NCI
693 ** transport)
694 **
695 ** This function opens the NCI transport (if applicable),
696 ** resets the NFC controller, and initializes the NFC
697 ** subsystems.
698 **
699 ** When the NFC startup procedure is completed, an
700 ** NFC_ENABLE_REVT is returned to the application using the
701 ** tNFC_RESPONSE_CBACK.
702 **
703 ** Returns tNFC_STATUS
704 **
705 *******************************************************************************/
NFC_Enable(tNFC_RESPONSE_CBACK * p_cback)706 tNFC_STATUS NFC_Enable(tNFC_RESPONSE_CBACK* p_cback) {
707 LOG(VERBOSE) << __func__;
708
709 /* Validate callback */
710 if (!p_cback) {
711 return (NFC_STATUS_INVALID_PARAM);
712 }
713 nfc_cb.p_resp_cback = p_cback;
714
715 /* Open HAL transport. */
716 nfc_set_state(NFC_STATE_W4_HAL_OPEN);
717 nfc_cb.p_hal->open(nfc_main_hal_cback, nfc_main_hal_data_cback);
718
719 return (NFC_STATUS_OK);
720 }
721
722 /*******************************************************************************
723 **
724 ** Function NFC_Disable
725 **
726 ** Description This function performs clean up routines for shutting down
727 ** NFC and closes the NCI transport (if using dedicated NCI
728 ** transport).
729 **
730 ** When the NFC shutdown procedure is completed, an
731 ** NFC_DISABLED_REVT is returned to the application using the
732 ** tNFC_RESPONSE_CBACK.
733 **
734 ** Returns nothing
735 **
736 *******************************************************************************/
NFC_Disable(void)737 void NFC_Disable(void) {
738 LOG(VERBOSE) << StringPrintf("nfc_state = %d", nfc_cb.nfc_state);
739
740 if ((nfc_cb.nfc_state == NFC_STATE_NONE) ||
741 (nfc_cb.nfc_state == NFC_STATE_NFCC_POWER_OFF_SLEEP)) {
742 nfc_set_state(NFC_STATE_NONE);
743 if (nfc_cb.p_resp_cback) {
744 (*nfc_cb.p_resp_cback)(NFC_DISABLE_REVT, nullptr);
745 nfc_cb.p_resp_cback = nullptr;
746 }
747 return;
748 }
749
750 /* Close transport and clean up */
751 nfc_task_shutdown_nfcc();
752 }
753
754 /*******************************************************************************
755 **
756 ** Function NFC_Init
757 **
758 ** Description This function initializes control block for NFC
759 **
760 ** Returns nothing
761 **
762 *******************************************************************************/
NFC_Init(tHAL_NFC_ENTRY * p_hal_entry_tbl)763 void NFC_Init(tHAL_NFC_ENTRY* p_hal_entry_tbl) {
764 int xx;
765
766 /* Clear nfc control block */
767 memset(&nfc_cb, 0, sizeof(tNFC_CB));
768
769 /* Reset the nfc control block */
770 for (xx = 0; xx < NCI_MAX_CONN_CBS; xx++) {
771 nfc_cb.conn_cb[xx].conn_id = NFC_ILLEGAL_CONN_ID;
772 }
773
774 /* NCI init */
775 nfc_cb.p_hal = p_hal_entry_tbl;
776 nfc_cb.nfc_state = NFC_STATE_NONE;
777 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW;
778 nfc_cb.nci_wait_rsp_tout = NFC_CMD_CMPL_TIMEOUT;
779 nfc_cb.p_disc_maps = nfc_interface_mapping;
780 nfc_cb.num_disc_maps = NFC_NUM_INTERFACE_MAP;
781 nfc_cb.nci_ctrl_size = NCI_CTRL_INIT_SIZE;
782 nfc_cb.reassembly = true;
783 nfc_cb.nci_version = NCI_VERSION_UNKNOWN;
784 GKI_init_timer_list(&nfc_cb.timer_queue);
785 GKI_init_timer_list(&nfc_cb.quick_timer_queue);
786 rw_init();
787 ce_init();
788 NFC_SET_MAX_CONN_DEFAULT();
789 }
790
791 /*******************************************************************************
792 **
793 ** Function NFC_GetLmrtSize
794 **
795 ** Description Called by application wto query the Listen Mode Routing
796 ** Table size supported by NFCC
797 **
798 ** Returns Listen Mode Routing Table size
799 **
800 *******************************************************************************/
NFC_GetLmrtSize(void)801 uint16_t NFC_GetLmrtSize(void) {
802 uint16_t size = 0;
803 #if (NFC_RW_ONLY == FALSE)
804 size = nfc_cb.max_ce_table;
805 #endif
806 return size;
807 }
808
809 /*******************************************************************************
810 **
811 ** Function NFC_SetConfig
812 **
813 ** Description This function is called to send the configuration parameter
814 ** TLV to NFCC. The response from NFCC is reported by
815 ** tNFC_RESPONSE_CBACK as NFC_SET_CONFIG_REVT.
816 **
817 ** Parameters tlv_size - the length of p_param_tlvs.
818 ** p_param_tlvs - the parameter ID/Len/Value list
819 **
820 ** Returns tNFC_STATUS
821 **
822 *******************************************************************************/
NFC_SetConfig(uint8_t tlv_size,uint8_t * p_param_tlvs)823 tNFC_STATUS NFC_SetConfig(uint8_t tlv_size, uint8_t* p_param_tlvs) {
824 return nci_snd_core_set_config(p_param_tlvs, tlv_size);
825 }
826
827 /*******************************************************************************
828 **
829 ** Function NFC_GetConfig
830 **
831 ** Description This function is called to retrieve the parameter TLV from
832 ** NFCC. The response from NFCC is reported by
833 ** tNFC_RESPONSE_CBACK as NFC_GET_CONFIG_REVT.
834 **
835 ** Parameters num_ids - the number of parameter IDs
836 ** p_param_ids - the parameter ID list.
837 **
838 ** Returns tNFC_STATUS
839 **
840 *******************************************************************************/
NFC_GetConfig(uint8_t num_ids,uint8_t * p_param_ids)841 tNFC_STATUS NFC_GetConfig(uint8_t num_ids, uint8_t* p_param_ids) {
842 return nci_snd_core_get_config(p_param_ids, num_ids);
843 }
844
845 /*******************************************************************************
846 **
847 ** Function NFC_DiscoveryMap
848 **
849 ** Description This function is called to set the discovery interface
850 ** mapping. The response from NFCC is reported by
851 ** tNFC_DISCOVER_CBACK as NFC_MAP_DEVT.
852 **
853 ** Parameters num - the number of items in p_params.
854 ** p_maps - the discovery interface mappings
855 ** p_cback - the discovery callback function
856 **
857 ** Returns tNFC_STATUS
858 **
859 *******************************************************************************/
NFC_DiscoveryMap(uint8_t num,tNFC_DISCOVER_MAPS * p_maps,tNFC_DISCOVER_CBACK * p_cback)860 tNFC_STATUS NFC_DiscoveryMap(uint8_t num, tNFC_DISCOVER_MAPS* p_maps,
861 tNFC_DISCOVER_CBACK* p_cback) {
862 uint8_t num_disc_maps = num;
863 uint8_t xx, yy, num_intf, intf_mask;
864 tNFC_DISCOVER_MAPS
865 max_maps[NFC_NFCC_MAX_NUM_VS_INTERFACE + NCI_INTERFACE_MAX];
866 bool is_supported;
867
868 nfc_cb.p_discv_cback = p_cback;
869 num_intf = 0;
870 LOG(VERBOSE) << StringPrintf("nci_interfaces supported by NFCC: 0x%x",
871 nfc_cb.nci_interfaces);
872
873 for (xx = 0; xx < NFC_NFCC_MAX_NUM_VS_INTERFACE + NCI_INTERFACE_MAX; xx++) {
874 memset(&max_maps[xx], 0x00, sizeof(tNFC_DISCOVER_MAPS));
875 }
876
877 for (xx = 0; xx < num_disc_maps; xx++) {
878 is_supported = false;
879 if (p_maps[xx].intf_type > NCI_INTERFACE_MAX) {
880 for (yy = 0; yy < NFC_NFCC_MAX_NUM_VS_INTERFACE; yy++) {
881 if (nfc_cb.vs_interface[yy] == p_maps[xx].intf_type)
882 is_supported = true;
883 }
884 LOG(VERBOSE) << StringPrintf("[%d]: vs intf_type:0x%x is_supported:%d", xx,
885 p_maps[xx].intf_type, is_supported);
886 } else {
887 intf_mask = (1 << (p_maps[xx].intf_type));
888 if (intf_mask & nfc_cb.nci_interfaces) {
889 is_supported = true;
890 }
891 LOG(VERBOSE) << StringPrintf(
892 "[%d]: intf_type:%d intf_mask: 0x%x is_supported:%d", xx,
893 p_maps[xx].intf_type, intf_mask, is_supported);
894 }
895 if (is_supported)
896 memcpy(&max_maps[num_intf++], &p_maps[xx], sizeof(tNFC_DISCOVER_MAPS));
897 else {
898 LOG(WARNING) << StringPrintf(
899 "NFC_DiscoveryMap interface=0x%x is not supported by NFCC",
900 p_maps[xx].intf_type);
901 }
902 }
903
904 return nci_snd_discover_map_cmd(num_intf, (tNCI_DISCOVER_MAPS*)max_maps);
905 }
906
907 /*******************************************************************************
908 **
909 ** Function NFC_DiscoveryStart
910 **
911 ** Description This function is called to start Polling and/or Listening.
912 ** The response from NFCC is reported by tNFC_DISCOVER_CBACK as
913 ** NFC_START_DEVT. The notification from NFCC is reported by
914 ** tNFC_DISCOVER_CBACK as NFC_RESULT_DEVT.
915 **
916 ** Parameters num_params - the number of items in p_params.
917 ** p_params - the discovery parameters
918 ** p_cback - the discovery callback function
919 **
920 ** Returns tNFC_STATUS
921 **
922 *******************************************************************************/
NFC_DiscoveryStart(uint8_t num_params,tNFC_DISCOVER_PARAMS * p_params,tNFC_DISCOVER_CBACK * p_cback)923 tNFC_STATUS NFC_DiscoveryStart(uint8_t num_params,
924 tNFC_DISCOVER_PARAMS* p_params,
925 tNFC_DISCOVER_CBACK* p_cback) {
926 uint8_t* p;
927 int params_size;
928 tNFC_STATUS status = NFC_STATUS_NO_BUFFERS;
929
930 LOG(VERBOSE) << __func__;
931 if (nfc_cb.p_disc_pending) {
932 LOG(ERROR) << StringPrintf("There's pending NFC_DiscoveryStart");
933 status = NFC_STATUS_BUSY;
934 } else {
935 nfc_cb.p_discv_cback = p_cback;
936 nfc_cb.flags |= NFC_FL_DISCOVER_PENDING;
937 nfc_cb.flags |= NFC_FL_CONTROL_REQUESTED;
938 params_size = sizeof(tNFC_DISCOVER_PARAMS) * num_params;
939 nfc_cb.p_disc_pending =
940 GKI_getbuf((uint16_t)(NFC_HDR_SIZE + 1 + params_size));
941 if (nfc_cb.p_disc_pending) {
942 p = (uint8_t*)nfc_cb.p_disc_pending;
943 *p++ = num_params;
944 memcpy(p, p_params, params_size);
945 status = NFC_STATUS_CMD_STARTED;
946 nfc_ncif_check_cmd_queue(nullptr);
947 }
948 }
949
950 LOG(VERBOSE) << StringPrintf("NFC_DiscoveryStart status: 0x%x", status);
951 return status;
952 }
953
954 /*******************************************************************************
955 **
956 ** Function NFC_DiscoverySelect
957 **
958 ** Description If tNFC_DISCOVER_CBACK reports status=NFC_MULTIPLE_PROT,
959 ** the application needs to use this function to select the
960 ** the logical endpoint to continue. The response from NFCC is
961 ** reported by tNFC_DISCOVER_CBACK as NFC_SELECT_DEVT.
962 **
963 ** Parameters rf_disc_id - The ID identifies the remote device.
964 ** protocol - the logical endpoint on the remote device
965 ** rf_interface - the RF interface to communicate with NFCC
966 **
967 ** Returns tNFC_STATUS
968 **
969 *******************************************************************************/
NFC_DiscoverySelect(uint8_t rf_disc_id,uint8_t protocol,uint8_t rf_interface)970 tNFC_STATUS NFC_DiscoverySelect(uint8_t rf_disc_id, uint8_t protocol,
971 uint8_t rf_interface) {
972 return nci_snd_discover_select_cmd(rf_disc_id, protocol, rf_interface);
973 }
974
975 /*******************************************************************************
976 **
977 ** Function NFC_StartPowerTransfert
978 **
979 ** Description If tNFC_DISCOVER_CBACK reports status=NFC_MULTIPLE_PROT,
980 ** the application needs to use this function to select the
981 ** the logical endpoint to continue. The response from NFCC is
982 ** reported by tNFC_DISCOVER_CBACK as NFC_SELECT_DEVT.
983 **
984 ** Parameters rf_disc_id - The ID identifies the remote device.
985 ** protocol - the logical endpoint on the remote device
986 ** rf_interface - the RF interface to communicate with NFCC
987 **
988 ** Returns tNFC_STATUS
989 **
990 *******************************************************************************/
NFC_StartPowerTransfert(uint8_t * p_param,uint8_t param_len)991 tNFC_STATUS NFC_StartPowerTransfert(uint8_t* p_param, uint8_t param_len) {
992 return nci_snd_rf_wpt_control_cmd(p_param, param_len);
993 }
994
995 /*******************************************************************************
996 **
997 ** Function NFC_ConnCreate
998 **
999 ** Description This function is called to create a logical connection with
1000 ** NFCC for data exchange.
1001 **
1002 ** Parameters dest_type - the destination type
1003 ** id - the NFCEE ID or RF Discovery ID .
1004 ** protocol - the protocol.
1005 ** p_cback - the connection callback function
1006 **
1007 ** Returns tNFC_STATUS
1008 **
1009 *******************************************************************************/
NFC_ConnCreate(uint8_t dest_type,uint8_t id,uint8_t protocol,tNFC_CONN_CBACK * p_cback)1010 tNFC_STATUS NFC_ConnCreate(uint8_t dest_type, uint8_t id, uint8_t protocol,
1011 tNFC_CONN_CBACK* p_cback) {
1012 tNFC_STATUS status = NFC_STATUS_FAILED;
1013 tNFC_CONN_CB* p_cb;
1014 uint8_t num_tlv = 0, tlv_size = 0;
1015 uint8_t param_tlvs[4], *pp;
1016
1017 p_cb = nfc_alloc_conn_cb(p_cback);
1018 if (p_cb) {
1019 p_cb->id = id;
1020 pp = param_tlvs;
1021 if (dest_type == NCI_DEST_TYPE_NFCEE) {
1022 num_tlv = 1;
1023 UINT8_TO_STREAM(pp, NCI_CON_CREATE_TAG_NFCEE_VAL);
1024 UINT8_TO_STREAM(pp, 2);
1025 UINT8_TO_STREAM(pp, id);
1026 UINT8_TO_STREAM(pp, protocol);
1027 tlv_size = 4;
1028 } else if (dest_type == NCI_DEST_TYPE_REMOTE) {
1029 num_tlv = 1;
1030 UINT8_TO_STREAM(pp, NCI_CON_CREATE_TAG_RF_DISC_ID);
1031 UINT8_TO_STREAM(pp, 1);
1032 UINT8_TO_STREAM(pp, id);
1033 tlv_size = 3;
1034 } else if (dest_type == NCI_DEST_TYPE_NFCC) {
1035 p_cb->id = NFC_TEST_ID;
1036 }
1037 /* Add handling of NCI_DEST_TYPE_REMOTE when more RF interface definitions
1038 * are added */
1039 p_cb->act_protocol = protocol;
1040 p_cb->p_cback = p_cback;
1041 status = nci_snd_core_conn_create(dest_type, num_tlv, tlv_size, param_tlvs);
1042 if (status == NFC_STATUS_FAILED) nfc_free_conn_cb(p_cb);
1043 }
1044 return status;
1045 }
1046
1047 /*******************************************************************************
1048 **
1049 ** Function NFC_ConnClose
1050 **
1051 ** Description This function is called to close a logical connection with
1052 ** NFCC.
1053 **
1054 ** Parameters conn_id - the connection id.
1055 **
1056 ** Returns tNFC_STATUS
1057 **
1058 *******************************************************************************/
NFC_ConnClose(uint8_t conn_id)1059 tNFC_STATUS NFC_ConnClose(uint8_t conn_id) {
1060 tNFC_CONN_CB* p_cb = nfc_find_conn_cb_by_conn_id(conn_id);
1061 tNFC_STATUS status = NFC_STATUS_FAILED;
1062
1063 if (p_cb) {
1064 status = nci_snd_core_conn_close(conn_id);
1065 }
1066 return status;
1067 }
1068
1069 /*******************************************************************************
1070 **
1071 ** Function NFC_SetStaticRfCback
1072 **
1073 ** Description This function is called to update the data callback function
1074 ** to receive the data for the given connection id.
1075 **
1076 ** Parameters p_cback - the connection callback function
1077 **
1078 ** Returns Nothing
1079 **
1080 *******************************************************************************/
NFC_SetStaticRfCback(tNFC_CONN_CBACK * p_cback)1081 void NFC_SetStaticRfCback(tNFC_CONN_CBACK* p_cback) {
1082 tNFC_CONN_CB* p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID];
1083
1084 p_cb->p_cback = p_cback;
1085 /* just in case DH has received NCI data before the data callback is set
1086 * check if there's any data event to report on this connection id */
1087 nfc_data_event(p_cb);
1088 }
1089
1090 /*******************************************************************************
1091 **
1092 ** Function NFC_SetStaticT4tNfceeCback
1093 **
1094 ** Description This function is called to update the data callback function
1095 ** to receive the data for the given connection id.
1096 **
1097 ** Parameters p_cback - the connection callback function
1098 ** connId - connection ID for T4T NFCEE
1099 **
1100 ** Returns Nothing
1101 **
1102 *******************************************************************************/
NFC_SetStaticT4tNfceeCback(tNFC_CONN_CBACK * p_cback,uint8_t connId)1103 void NFC_SetStaticT4tNfceeCback(tNFC_CONN_CBACK* p_cback, uint8_t connId) {
1104 // tNFC_CONN_CB * p_cb = &nfc_cb.conn_cb[];
1105 tNFC_CONN_CB* p_cb = nfc_find_conn_cb_by_conn_id(connId);
1106 if (p_cb != NULL) {
1107 p_cb->p_cback = p_cback;
1108 /* just in case DH has received NCI data before the data callback is set
1109 * check if there's any data event to report on this connection id */
1110 nfc_data_event(p_cb);
1111 LOG(DEBUG) << StringPrintf("%s = %p, p_cb->p_cback = %p", __func__, p_cb,
1112 p_cb->p_cback);
1113 }
1114 }
1115
1116 /*******************************************************************************
1117 **
1118 ** Function NFC_SetReassemblyFlag
1119 **
1120 ** Description This function is called to set if nfc will reassemble
1121 ** nci packet as much as its buffer can hold or it should not
1122 ** reassemble but forward the fragmented nci packet to layer
1123 ** above. If nci data pkt is fragmented, nfc may send multiple
1124 ** NFC_DATA_CEVT with status NFC_STATUS_CONTINUE before sending
1125 ** NFC_DATA_CEVT with status NFC_STATUS_OK based on reassembly
1126 ** configuration and reassembly buffer size
1127 **
1128 ** Parameters reassembly - flag to indicate if nfc may reassemble or not
1129 **
1130 ** Returns Nothing
1131 **
1132 *******************************************************************************/
NFC_SetReassemblyFlag(bool reassembly)1133 void NFC_SetReassemblyFlag(bool reassembly) { nfc_cb.reassembly = reassembly; }
1134
1135 /*******************************************************************************
1136 **
1137 ** Function NFC_SendData
1138 **
1139 ** Description This function is called to send the given data packet
1140 ** to the connection identified by the given connection id.
1141 **
1142 ** Parameters conn_id - the connection id.
1143 ** p_data - the data packet.
1144 ** p_data->offset must be >= NCI_MSG_OFFSET_SIZE +
1145 ** NCI_DATA_HDR_SIZE
1146 ** The data payload starts at
1147 ** ((uint8_t *) (p_data + 1) + p_data->offset)
1148 **
1149 ** Returns tNFC_STATUS
1150 **
1151 *******************************************************************************/
NFC_SendData(uint8_t conn_id,NFC_HDR * p_data)1152 tNFC_STATUS NFC_SendData(uint8_t conn_id, NFC_HDR* p_data) {
1153 tNFC_STATUS status = NFC_STATUS_FAILED;
1154 tNFC_CONN_CB* p_cb = nfc_find_conn_cb_by_conn_id(conn_id);
1155
1156 if (p_cb && p_data &&
1157 p_data->offset >= NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE) {
1158 status = nfc_ncif_send_data(p_cb, p_data);
1159 }
1160
1161 if (status != NFC_STATUS_OK) GKI_freebuf(p_data);
1162
1163 return status;
1164 }
1165
1166 /*******************************************************************************
1167 **
1168 ** Function NFC_FlushData
1169 **
1170 ** Description This function is called to discard the tx data queue of
1171 ** the given connection id.
1172 **
1173 ** Parameters conn_id - the connection id.
1174 **
1175 ** Returns tNFC_STATUS
1176 **
1177 *******************************************************************************/
NFC_FlushData(uint8_t conn_id)1178 tNFC_STATUS NFC_FlushData(uint8_t conn_id) {
1179 tNFC_STATUS status = NFC_STATUS_FAILED;
1180 tNFC_CONN_CB* p_cb = nfc_find_conn_cb_by_conn_id(conn_id);
1181 void* p_buf;
1182
1183 if (p_cb) {
1184 status = NFC_STATUS_OK;
1185 while ((p_buf = GKI_dequeue(&p_cb->tx_q)) != nullptr) GKI_freebuf(p_buf);
1186 }
1187
1188 return status;
1189 }
1190
1191 /*******************************************************************************
1192 **
1193 ** Function NFC_Deactivate
1194 **
1195 ** Description This function is called to stop the discovery process or
1196 ** put the listen device in sleep mode or terminate the NFC
1197 ** link.
1198 **
1199 ** The response from NFCC is reported by tNFC_DISCOVER_CBACK
1200 ** as NFC_DEACTIVATE_DEVT.
1201 **
1202 ** Parameters deactivate_type - NFC_DEACTIVATE_TYPE_IDLE, to IDLE mode.
1203 ** NFC_DEACTIVATE_TYPE_SLEEP to SLEEP mode.
1204 ** NFC_DEACTIVATE_TYPE_SLEEP_AF to SLEEP_AF
1205 ** mode.
1206 **
1207 ** Returns tNFC_STATUS
1208 **
1209 *******************************************************************************/
NFC_Deactivate(tNFC_DEACT_TYPE deactivate_type)1210 tNFC_STATUS NFC_Deactivate(tNFC_DEACT_TYPE deactivate_type) {
1211 tNFC_CONN_CB* p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID];
1212 tNFC_STATUS status = NFC_STATUS_OK;
1213
1214 LOG(VERBOSE) << StringPrintf(
1215 "NFC_Deactivate %d (%s) deactivate_type:%d", nfc_cb.nfc_state,
1216 nfc_state_name(nfc_cb.nfc_state).c_str(), deactivate_type);
1217
1218 if (nfc_cb.flags & NFC_FL_DISCOVER_PENDING) {
1219 /* the HAL pre-discover is still active - clear the pending flag */
1220 nfc_cb.flags &= ~NFC_FL_DISCOVER_PENDING;
1221 if (!(nfc_cb.flags & NFC_FL_HAL_REQUESTED)) {
1222 /* if HAL did not request for control, clear this bit now */
1223 nfc_cb.flags &= ~NFC_FL_CONTROL_REQUESTED;
1224 }
1225 GKI_freebuf(nfc_cb.p_disc_pending);
1226 nfc_cb.p_disc_pending = nullptr;
1227 return NFC_STATUS_OK;
1228 }
1229
1230 if (nfc_cb.nfc_state == NFC_STATE_OPEN) {
1231 nfc_set_state(NFC_STATE_CLOSING);
1232 LOG(VERBOSE) << StringPrintf("act_protocol %d credits:%d/%d",
1233 p_cb->act_protocol, p_cb->init_credits,
1234 p_cb->num_buff);
1235 if ((p_cb->act_protocol == NCI_PROTOCOL_NFC_DEP) &&
1236 (p_cb->init_credits != p_cb->num_buff)) {
1237 nfc_cb.flags |= NFC_FL_DEACTIVATING;
1238 nfc_cb.deactivate_timer.param = (uintptr_t)deactivate_type;
1239 nfc_start_timer(&nfc_cb.deactivate_timer,
1240 (uint16_t)(NFC_TTYPE_WAIT_2_DEACTIVATE),
1241 NFC_DEACTIVATE_TIMEOUT);
1242 return status;
1243 }
1244 }
1245
1246 status = nci_snd_deactivate_cmd(deactivate_type);
1247 return status;
1248 }
1249 /*******************************************************************************
1250 **
1251 ** Function NFC_SetPowerSubState
1252 **
1253 ** Description This function is called to send the power sub state (screen
1254 ** state) to NFCC. The response from NFCC is reported by
1255 ** tNFC_RESPONSE_CBACK as NFC_SET_POWER_STATE_REVT.
1256 **
1257 ** Parameters scree_state
1258 **
1259 ** Returns tNFC_STATUS
1260 **
1261 *******************************************************************************/
NFC_SetPowerSubState(uint8_t screen_state)1262 tNFC_STATUS NFC_SetPowerSubState(uint8_t screen_state) {
1263 return nci_snd_core_set_power_sub_state(screen_state);
1264 }
1265 /*******************************************************************************
1266 **
1267 ** Function NFC_UpdateRFCommParams
1268 **
1269 ** Description This function is called to update RF Communication
1270 ** parameters once the Frame RF Interface has been activated.
1271 **
1272 ** The response from NFCC is reported by tNFC_RESPONSE_CBACK
1273 ** as NFC_RF_COMM_PARAMS_UPDATE_REVT.
1274 **
1275 ** Returns tNFC_STATUS
1276 **
1277 *******************************************************************************/
NFC_UpdateRFCommParams(tNFC_RF_COMM_PARAMS * p_params)1278 tNFC_STATUS NFC_UpdateRFCommParams(tNFC_RF_COMM_PARAMS* p_params) {
1279 uint8_t tlvs[12];
1280 uint8_t* p = tlvs;
1281 uint8_t data_exch_config;
1282
1283 /* RF Technology and Mode */
1284 if (p_params->include_rf_tech_mode) {
1285 UINT8_TO_STREAM(p, NCI_RF_PARAM_ID_TECH_N_MODE);
1286 UINT8_TO_STREAM(p, 1);
1287 UINT8_TO_STREAM(p, p_params->rf_tech_n_mode);
1288 }
1289
1290 /* Transmit Bit Rate */
1291 if (p_params->include_tx_bit_rate) {
1292 UINT8_TO_STREAM(p, NCI_RF_PARAM_ID_TX_BIT_RATE);
1293 UINT8_TO_STREAM(p, 1);
1294 UINT8_TO_STREAM(p, p_params->tx_bit_rate);
1295 }
1296
1297 /* Receive Bit Rate */
1298 if (p_params->include_tx_bit_rate) {
1299 UINT8_TO_STREAM(p, NCI_RF_PARAM_ID_RX_BIT_RATE);
1300 UINT8_TO_STREAM(p, 1);
1301 UINT8_TO_STREAM(p, p_params->rx_bit_rate);
1302 }
1303
1304 /* NFC-B Data Exchange Configuration */
1305 if (p_params->include_nfc_b_config) {
1306 UINT8_TO_STREAM(p, NCI_RF_PARAM_ID_B_DATA_EX_PARAM);
1307 UINT8_TO_STREAM(p, 1);
1308
1309 data_exch_config = (p_params->min_tr0 & 0x03) << 6; /* b7b6 : Mininum TR0 */
1310 data_exch_config |= (p_params->min_tr1 & 0x03)
1311 << 4; /* b5b4 : Mininum TR1 */
1312 data_exch_config |= (p_params->suppression_eos & 0x01)
1313 << 3; /* b3 : Suppression of EoS */
1314 data_exch_config |= (p_params->suppression_sos & 0x01)
1315 << 2; /* b2 : Suppression of SoS */
1316 data_exch_config |= (p_params->min_tr2 & 0x03); /* b1b0 : Mininum TR2 */
1317
1318 UINT8_TO_STREAM(p, data_exch_config);
1319 }
1320
1321 return nci_snd_parameter_update_cmd(tlvs, (uint8_t)(p - tlvs));
1322 }
1323
1324 /*******************************************************************************
1325 **
1326 ** Function NFC_SetPowerOffSleep
1327 **
1328 ** Description This function closes/opens transport and turns off/on NFCC.
1329 **
1330 ** Returns tNFC_STATUS
1331 **
1332 *******************************************************************************/
NFC_SetPowerOffSleep(bool enable)1333 tNFC_STATUS NFC_SetPowerOffSleep(bool enable) {
1334 LOG(VERBOSE) << StringPrintf("enable = %d", enable);
1335
1336 if ((enable == false) &&
1337 (nfc_cb.nfc_state == NFC_STATE_NFCC_POWER_OFF_SLEEP)) {
1338 nfc_cb.flags |= NFC_FL_RESTARTING;
1339
1340 /* open transport */
1341 nfc_set_state(NFC_STATE_W4_HAL_OPEN);
1342 nfc_cb.p_hal->open(nfc_main_hal_cback, nfc_main_hal_data_cback);
1343
1344 return NFC_STATUS_OK;
1345 } else if ((enable == true) && (nfc_cb.nfc_state == NFC_STATE_IDLE)) {
1346 /* close transport to turn off NFCC and clean up */
1347 nfc_cb.flags |= NFC_FL_POWER_OFF_SLEEP;
1348 nfc_task_shutdown_nfcc();
1349
1350 return NFC_STATUS_OK;
1351 }
1352
1353 LOG(ERROR) << StringPrintf("invalid state = %d", nfc_cb.nfc_state);
1354 return NFC_STATUS_FAILED;
1355 }
1356
1357 /*******************************************************************************
1358 **
1359 ** Function NFC_PowerCycleNFCC
1360 **
1361 ** Description This function turns off and then on NFCC.
1362 **
1363 ** Returns tNFC_STATUS
1364 **
1365 *******************************************************************************/
NFC_PowerCycleNFCC(void)1366 tNFC_STATUS NFC_PowerCycleNFCC(void) {
1367 LOG(VERBOSE) << __func__;
1368
1369 if (nfc_cb.nfc_state == NFC_STATE_IDLE) {
1370 /* power cycle NFCC */
1371 nfc_cb.flags |= NFC_FL_POWER_CYCLE_NFCC;
1372 nfc_task_shutdown_nfcc();
1373
1374 return NFC_STATUS_OK;
1375 }
1376
1377 LOG(ERROR) << StringPrintf("invalid state = %d", nfc_cb.nfc_state);
1378 return NFC_STATUS_FAILED;
1379 }
1380
1381 /*******************************************************************************
1382 **
1383 ** Function NFC_GetNCIVersion
1384 **
1385 ** Description Called by higher layer to get the current nci
1386 ** version of nfc.
1387 **
1388 ** Returns NCI version NCI2.0 / NCI1.0
1389 **
1390 *******************************************************************************/
NFC_GetNCIVersion()1391 uint8_t NFC_GetNCIVersion() { return nfc_cb.nci_version; }
1392
1393 /*******************************************************************************
1394 **
1395 ** Function NFC_ISODEPNakPresCheck
1396 **
1397 ** Description This function is called to send the ISO DEP nak presenc
1398 ** check cmd to check that the remote end point in RF field.
1399 **
1400 ** The response from NFCC is reported by call back.The ntf
1401 ** indicates success if card is present in field or failed
1402 ** if card is lost.
1403 **
1404 ** Returns tNFC_STATUS
1405 **
1406 *******************************************************************************/
NFC_ISODEPNakPresCheck()1407 tNFC_STATUS NFC_ISODEPNakPresCheck() {
1408 return nci_snd_iso_dep_nak_presence_check_cmd();
1409 }
1410
1411 /*******************************************************************************
1412 **
1413 ** Function NFC_SetStaticHciCback
1414 **
1415 ** Description This function is called to update the data callback function
1416 ** to receive the data for the static Hci connection id.
1417 **
1418 ** Parameters p_cback - the connection callback function
1419 **
1420 ** Returns Nothing
1421 **
1422 *******************************************************************************/
NFC_SetStaticHciCback(tNFC_CONN_CBACK * p_cback)1423 void NFC_SetStaticHciCback(tNFC_CONN_CBACK* p_cback) {
1424 LOG(VERBOSE) << StringPrintf("%s dest: %d", __func__, NCI_DEST_TYPE_NFCEE);
1425 tNFC_CONN_CB* p_cb = &nfc_cb.conn_cb[NFC_HCI_CONN_ID];
1426 tNFC_CONN evt_data;
1427
1428 p_cb->p_cback = p_cback;
1429 if (p_cback && p_cb->buff_size && p_cb->num_buff) {
1430 LOG(VERBOSE) << StringPrintf("%s dest: %d", __func__, NCI_DEST_TYPE_NFCEE);
1431 evt_data.conn_create.status = NFC_STATUS_OK;
1432 evt_data.conn_create.dest_type = NCI_DEST_TYPE_NFCEE;
1433 evt_data.conn_create.id = p_cb->id;
1434 evt_data.conn_create.buff_size = p_cb->buff_size;
1435 evt_data.conn_create.num_buffs = p_cb->num_buff;
1436 (*p_cback)(NFC_HCI_CONN_ID, NFC_CONN_CREATE_CEVT, &evt_data);
1437 }
1438 }
1439
1440 /*******************************************************************************
1441 **
1442 ** Function NFC_GetStatusName
1443 **
1444 ** Description This function returns the status name.
1445 **
1446 ** NOTE conditionally compiled to save memory.
1447 **
1448 ** Returns pointer to the name
1449 **
1450 *******************************************************************************/
NFC_GetStatusName(tNFC_STATUS status)1451 std::string NFC_GetStatusName(tNFC_STATUS status) {
1452 switch (status) {
1453 case NFC_STATUS_OK:
1454 return "OK";
1455 case NFC_STATUS_REJECTED:
1456 return "REJECTED";
1457 case NFC_STATUS_MSG_CORRUPTED:
1458 return "CORRUPTED";
1459 case NFC_STATUS_BUFFER_FULL:
1460 return "BUFFER_FULL";
1461 case NFC_STATUS_FAILED:
1462 return "FAILED";
1463 case NFC_STATUS_NOT_INITIALIZED:
1464 return "NOT_INITIALIZED";
1465 case NFC_STATUS_SYNTAX_ERROR:
1466 return "SYNTAX_ERROR";
1467 case NFC_STATUS_SEMANTIC_ERROR:
1468 return "SEMANTIC_ERROR";
1469 case NFC_STATUS_UNKNOWN_GID:
1470 return "UNKNOWN_GID";
1471 case NFC_STATUS_UNKNOWN_OID:
1472 return "UNKNOWN_OID";
1473 case NFC_STATUS_INVALID_PARAM:
1474 return "INVALID_PARAM";
1475 case NFC_STATUS_MSG_SIZE_TOO_BIG:
1476 return "MSG_SIZE_TOO_BIG";
1477 case NFC_STATUS_ALREADY_STARTED:
1478 return "ALREADY_STARTED";
1479 case NFC_STATUS_ACTIVATION_FAILED:
1480 return "ACTIVATION_FAILED";
1481 case NFC_STATUS_TEAR_DOWN:
1482 return "TEAR_DOWN";
1483 case NFC_STATUS_RF_TRANSMISSION_ERR:
1484 return "RF_TRANSMISSION_ERR";
1485 case NFC_STATUS_RF_PROTOCOL_ERR:
1486 return "RF_PROTOCOL_ERR";
1487 case NFC_STATUS_TIMEOUT:
1488 return "TIMEOUT";
1489 case NFC_STATUS_EE_INTF_ACTIVE_FAIL:
1490 return "EE_INTF_ACTIVE_FAIL";
1491 case NFC_STATUS_EE_TRANSMISSION_ERR:
1492 return "EE_TRANSMISSION_ERR";
1493 case NFC_STATUS_EE_PROTOCOL_ERR:
1494 return "EE_PROTOCOL_ERR";
1495 case NFC_STATUS_EE_TIMEOUT:
1496 return "EE_TIMEOUT";
1497 case NFC_STATUS_CMD_STARTED:
1498 return "CMD_STARTED";
1499 case NFC_STATUS_HW_TIMEOUT:
1500 return "HW_TIMEOUT";
1501 case NFC_STATUS_CONTINUE:
1502 return "CONTINUE";
1503 case NFC_STATUS_REFUSED:
1504 return "REFUSED";
1505 case NFC_STATUS_BAD_RESP:
1506 return "BAD_RESP";
1507 case NFC_STATUS_CMD_NOT_CMPLTD:
1508 return "CMD_NOT_CMPLTD";
1509 case NFC_STATUS_NO_BUFFERS:
1510 return "NO_BUFFERS";
1511 case NFC_STATUS_WRONG_PROTOCOL:
1512 return "WRONG_PROTOCOL";
1513 case NFC_STATUS_BUSY:
1514 return "BUSY";
1515 case NFC_STATUS_LINK_LOSS:
1516 return "LINK_LOSS";
1517 case NFC_STATUS_BAD_LENGTH:
1518 return "BAD_LENGTH";
1519 case NFC_STATUS_BAD_HANDLE:
1520 return "BAD_HANDLE";
1521 case NFC_STATUS_CONGESTED:
1522 return "CONGESTED";
1523 default:
1524 return "UNKNOWN";
1525 }
1526 }
1527