1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Copyright 2021 NXP.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * You may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #include <stdlib.h>
20 #include <string.h>
21
22 #include "uci_defs.h"
23 #include "uci_hmsgs.h"
24 #include "uci_log.h"
25 #include "uci_test_defs.h"
26 #include "uwa_dm_int.h"
27 #include "uwa_sys.h"
28 #include "uwb_api.h"
29 #include "uwb_config.h"
30 #include "uwb_hal_api.h"
31 #include "uwb_hal_int.h"
32 #include "uwb_int.h"
33 #include "uwb_osal_common.h"
34 #include "uwb_target.h"
35
36 #define NORMAL_MODE_LENGTH_OFFSET 0x03
37 #define MAC_SHORT_ADD_LEN 2
38 #define MAC_EXT_ADD_LEN 8
39 #define PDOA_LEN 4
40 #define AOA_LEN 4
41 #define AOA_DEST_LEN 4
42 #define CONFIG_TLV_OFFSET 2
43 #define TWO_WAY_MEASUREMENT_LENGTH 31
44 #define ONE_WAY_MEASUREMENT_LENGTH 36
45 #define RANGING_DATA_LENGTH 25
46
47 #define VENDOR_SPEC_INFO_LEN 2
48
49 uint8_t last_cmd_buff[UCI_MAX_PAYLOAD_SIZE];
50 uint8_t last_data_buff[4096];
51 static uint8_t device_info_buffer[MAX_NUM_OF_TDOA_MEASURES]
52 [UCI_MAX_PAYLOAD_SIZE];
53 static uint8_t blink_payload_buffer[MAX_NUM_OF_TDOA_MEASURES]
54 [UCI_MAX_PAYLOAD_SIZE];
55 static uint8_t range_data_ntf_buffer[2048];
56 static uint8_t range_data_ntf_len =0;
57
58 struct chained_uci_packet {
59 uint8_t buffer[4192];
60 uint8_t oid;
61 uint8_t gid;
62 uint16_t offset;
63 uint8_t is_first_frgmnt_done;
64 };
65
66 typedef struct chained_uci_packet chained_uci_packet;
67
68 /*******************************************************************************
69 **
70 ** Function uwb_ucif_update_cmd_window
71 **
72 ** Description Update tx cmd window to indicate that UWBC can received
73 **
74 ** Returns void
75 **
76 *******************************************************************************/
uwb_ucif_update_cmd_window(void)77 void uwb_ucif_update_cmd_window(void) {
78 /* Sanity check - see if we were expecting a update_window */
79 if (uwb_cb.uci_cmd_window == UCI_MAX_CMD_WINDOW) {
80 if (uwb_cb.uwb_state != UWB_STATE_W4_HAL_CLOSE) {
81 UCI_TRACE_E("uwb_ucif_update_window: Unexpected call");
82 }
83 return;
84 }
85 /* Stop command-pending timer */
86 uwb_stop_quick_timer(&uwb_cb.uci_wait_rsp_timer);
87
88 uwb_cb.p_raw_cmd_cback = NULL;
89 uwb_cb.uci_cmd_window++;
90 uwb_cb.is_resp_pending = false;
91 uwb_cb.cmd_retry_count = 0; /* reset the retry count as response is received*/
92
93 uwb_ucif_check_cmd_queue(NULL);
94 }
95
96 /*******************************************************************************
97 **
98 ** Function uwb_ucif_cmd_timeout
99 **
100 ** Description Handle a command timeout
101 **
102 ** Returns void
103 **
104 *******************************************************************************/
uwb_ucif_cmd_timeout(void)105 void uwb_ucif_cmd_timeout(void) {
106 UCI_TRACE_I("uwb_ucif_cmd_timeout");
107 /* if enabling UWB, notify upper layer of failure */
108 if (uwb_cb.is_resp_pending &&
109 (uwb_cb.cmd_retry_count < UCI_CMD_MAX_RETRY_COUNT)) {
110 uwb_stop_quick_timer(
111 &uwb_cb.uci_wait_rsp_timer); /*stop the pending timer */
112 uwb_ucif_retransmit_cmd(uwb_cb.pLast_cmd_buf);
113 uwb_cb.cmd_retry_count++;
114 } else {
115 uwb_ucif_event_status(UWB_UWBS_RESP_TIMEOUT_REVT, UWB_STATUS_FAILED);
116 uwb_ucif_uwb_recovery();
117 }
118 }
119
120 /*******************************************************************************
121 **
122 ** Function uwb_ucif_retransmit_cmd
123 **
124 ** Description Retransmission of last packet
125 **
126 ** Returns void
127 **
128 *******************************************************************************/
uwb_ucif_retransmit_cmd(UWB_HDR * p_buf)129 void uwb_ucif_retransmit_cmd(UWB_HDR* p_buf) {
130 UCI_TRACE_I("uwb_ucif_retransmit_cmd");
131 if (p_buf == NULL) {
132 UCI_TRACE_E("uwb_ucif_retransmit_cmd: p_data is NULL");
133 return;
134 }
135 HAL_RE_WRITE(p_buf);
136 /* start UWB command-timeout timer */
137 uwb_start_quick_timer(&uwb_cb.uci_wait_rsp_timer,
138 (uint16_t)(UWB_TTYPE_UCI_WAIT_RSP),
139 uwb_cb.retry_rsp_timeout);
140 }
141
142 /*******************************************************************************
143 **
144 ** Function uwb_ucif_check_cmd_queue
145 **
146 ** Description Send UCI command to the transport
147 **
148 ** Returns void
149 **
150 *******************************************************************************/
uwb_ucif_check_cmd_queue(UWB_HDR * p_buf)151 void uwb_ucif_check_cmd_queue(UWB_HDR* p_buf) {
152 uint8_t* ps;
153 uint8_t* pTemp;
154 // tUWB_CONN_CB* p_cb = NULL;
155 UCI_TRACE_I("uwb_ucif_check_cmd_queue()");
156
157 if (uwb_cb.uwb_state == UWB_STATE_W4_HAL_CLOSE ||
158 uwb_cb.uwb_state == UWB_STATE_NONE) {
159 UCI_TRACE_E("%s: HAL is not initialized", __func__);
160 phUwb_GKI_freebuf(p_buf);
161 return;
162 }
163
164 /* If there are commands waiting in the xmit queue, or if the UWBS
165 * cannot accept any more commands, */
166 /* then enqueue this command */
167 if (p_buf) {
168 if ((uwb_cb.uci_cmd_xmit_q.count) || (uwb_cb.uci_cmd_window == 0)) {
169 phUwb_GKI_enqueue(&uwb_cb.uci_cmd_xmit_q, p_buf);
170 if (p_buf != NULL) {
171 UCI_TRACE_E("uwb_ucif_check_cmd_queue : making p_buf NULL.");
172 p_buf = NULL;
173 }
174 }
175 }
176
177 /* If Helios can accept another command, then send the next command */
178 if (uwb_cb.uci_cmd_window > 0) {
179 /* If no command was provided, or if older commands were in the queue, then
180 * get cmd from the queue */
181 if (!p_buf) p_buf = (UWB_HDR*)phUwb_GKI_dequeue(&uwb_cb.uci_cmd_xmit_q);
182
183 if (p_buf) {
184 /* save the message header to double check the response */
185 ps = (uint8_t*)(p_buf + 1) + p_buf->offset;
186 uint8_t pbf = (*(ps)&UCI_PBF_MASK) >> UCI_PBF_SHIFT;
187 memcpy(uwb_cb.last_hdr, ps, UWB_SAVED_HDR_SIZE);
188 memcpy(uwb_cb.last_cmd, ps + UCI_MSG_HDR_SIZE, UWB_SAVED_HDR_SIZE);
189 /* copying command to temp buff for retransmission */
190 uwb_cb.pLast_cmd_buf = (UWB_HDR*)last_cmd_buff;
191 uwb_cb.pLast_cmd_buf->offset = p_buf->offset;
192 pTemp =
193 (uint8_t*)(uwb_cb.pLast_cmd_buf + 1) + uwb_cb.pLast_cmd_buf->offset;
194 uwb_cb.pLast_cmd_buf->len = p_buf->len;
195 memcpy(pTemp, ps, p_buf->len);
196 if (p_buf->layer_specific == UWB_WAIT_RSP_RAW_CMD) {
197 /* save the callback for RAW VS */
198 uwb_cb.p_raw_cmd_cback = (void*)((tUWB_UCI_RAW_MSG*)p_buf)->p_cback;
199 uwb_cb.rawCmdCbflag = true;
200 }
201
202 /* Indicate command is pending */
203 uwb_cb.uci_cmd_window--;
204 uwb_cb.is_resp_pending = true;
205 uwb_cb.cmd_retry_count = 0;
206
207 /* send to HAL */
208 HAL_WRITE(p_buf);
209 if (!(pbf && uwb_cb.IsConformaceTestEnabled)) { // if pbf bit is set for
210 // conformance test skip
211 // timer start.
212 /* start UWB command-timeout timer */
213 uwb_start_quick_timer(&uwb_cb.uci_wait_rsp_timer,
214 (uint16_t)(UWB_TTYPE_UCI_WAIT_RSP),
215 uwb_cb.uci_wait_rsp_tout);
216 }
217 }
218 }
219 }
220
221 /*******************************************************************************
222 **
223 ** Function uwb_ucif_send_cmd
224 **
225 ** Description Send UCI command to the UCIT task
226 **
227 ** Returns void
228 **
229 *******************************************************************************/
uwb_ucif_send_cmd(UWB_HDR * p_buf)230 void uwb_ucif_send_cmd(UWB_HDR* p_buf) {
231 UCI_TRACE_I("uwb_ucif_send_cmd.");
232 if (p_buf == NULL) {
233 UCI_TRACE_E("p_buf is NULL.");
234 return;
235 }
236 /* post the p_buf to UCIT task */
237 p_buf->event = BT_EVT_TO_UWB_UCI;
238 p_buf->layer_specific = 0;
239 uwb_ucif_check_cmd_queue(p_buf);
240 }
241
242 /*******************************************************************************
243 **
244 ** Function uwb_ucif_process_event
245 **
246 ** Description This function is called to process the
247 ** data/response/notification from UWBC
248 **
249 ** Returns true if need to free buffer
250 **
251 *******************************************************************************/
uwb_ucif_process_event(UWB_HDR * p_msg)252 bool uwb_ucif_process_event(UWB_HDR* p_msg) {
253 uint8_t mt, pbf, gid, oid, *p, *pp;
254 bool free = true;
255 uint16_t payload_length;
256 uint8_t *p_old, old_gid, old_oid, old_mt;
257 static chained_uci_packet chained_packet;
258
259 p = (uint8_t*)(p_msg + 1) + p_msg->offset;
260 pp = p;
261
262 if ((p != NULL) & (pp != NULL)) {
263 UCI_MSG_PRS_HDR0(pp, mt, pbf, gid);
264 UCI_MSG_PRS_HDR1(pp, oid);
265 pp = pp + 2; // Skip payload fields
266 UCI_TRACE_E("uwb_ucif_process_event enter gid:0x%x status:0x%x", p[0],
267 pp[0]);
268 payload_length = p[NORMAL_MODE_LENGTH_OFFSET];
269
270 if (!uwb_cb.IsConformaceTestEnabled) {
271 if (pbf) {
272 if (!chained_packet.is_first_frgmnt_done) {
273 chained_packet.oid = oid;
274 chained_packet.gid = gid;
275 memcpy(&chained_packet.buffer[chained_packet.offset], p,
276 p_msg->len); // Copy first fragment(uci packet with header)(p)
277 chained_packet.offset = p_msg->len;
278 chained_packet.is_first_frgmnt_done = true;
279 } else {
280 // if first fragment is copied, then copy only uci payload(pp) for
281 // subsequent fragments
282 if ((chained_packet.oid == oid) && (chained_packet.gid == gid)) {
283 memcpy(&chained_packet.buffer[chained_packet.offset], pp,
284 payload_length);
285 chained_packet.offset =
286 (uint16_t)(chained_packet.offset + payload_length);
287 } else {
288 UCI_TRACE_E(
289 "uwb_ucif_process_event: unexpected chain packet: "
290 "chained_packed_gid: 0x%x, chained_packet_oid=0x%x, received "
291 "packet gid:0x%x, recived packet oid:0x%x",
292 chained_packet.gid, chained_packet.oid, gid, oid);
293 }
294 }
295 return (free);
296 } else {
297 if (chained_packet.is_first_frgmnt_done) {
298 if ((chained_packet.oid == oid) && (chained_packet.gid == gid)) {
299 memcpy(&chained_packet.buffer[chained_packet.offset], pp,
300 payload_length); // Append only payload to chained packet
301 chained_packet.offset =
302 (uint16_t)(chained_packet.offset + payload_length);
303
304 // Update P & PP
305 p = &chained_packet
306 .buffer[0]; // p -> points to complete UCI packet
307 pp = p + 2; // Skip oid & gid bytes
308 payload_length =
309 (uint16_t)(chained_packet.offset - UCI_MSG_HDR_SIZE);
310 UINT16_TO_STREAM(pp,
311 payload_length); // Update overall payload length
312 // into the chained packet
313
314 // Clear flags
315 chained_packet.offset = 0;
316 chained_packet.is_first_frgmnt_done = false;
317 chained_packet.oid = 0xFF;
318 chained_packet.gid = 0xFF;
319 }
320 }
321 }
322 }
323
324 if ((uwb_cb.rawCmdCbflag == true) && (mt != UCI_MT_NTF)) {
325 uci_proc_raw_cmd_rsp(p, p_msg->len);
326 uwb_cb.rawCmdCbflag = false;
327 return (free);
328 }
329
330 switch (mt) {
331 case UCI_MT_RSP:
332 UCI_TRACE_I("uwb_ucif_process_event: UWB received rsp gid:%d", gid);
333 p_old = uwb_cb.last_hdr;
334 UCI_MSG_PRS_HDR0(p_old, old_mt, pbf, old_gid);
335 UCI_MSG_PRS_HDR1(p_old, old_oid);
336 (void)old_mt; // Dummy conversion to fix the warning
337 /* make sure this is the RSP we are waiting for before updating the
338 * command window */
339 if ((old_gid != gid) || (old_oid != oid)) {
340 UCI_TRACE_E(
341 "uwb_ucif_process_event unexpected rsp: gid:0x%x, oid:0x%x", gid,
342 oid);
343 return true;
344 }
345
346 switch (gid) {
347 case UCI_GID_CORE: /* 0000b UCI Core group */
348 free = uwb_proc_core_rsp(oid, pp, payload_length);
349 break;
350 case UCI_GID_SESSION_MANAGE: /* 0001b UCI Session Config group */
351 uci_proc_session_management_rsp(oid, pp, payload_length);
352 break;
353 case UCI_GID_RANGE_MANAGE: /* 0010b UCI Range group */
354 uci_proc_rang_management_rsp(oid, pp, payload_length);
355 break;
356 case UCI_GID_ANDROID: /* 1110b UCI vendor Android group */
357 uci_proc_android_rsp(oid, pp, payload_length);
358 break;
359 case UCI_GID_TEST: /* 1101b test group */
360 uci_proc_test_management_rsp(oid, pp, payload_length);
361 break;
362 default:
363 UCI_TRACE_E("uwb_ucif_process_event: Unknown gid:%d", gid);
364 break;
365 }
366
367 uwb_ucif_update_cmd_window();
368 break;
369
370 case UCI_MT_NTF:
371 UCI_TRACE_I("uwb_ucif_process_event: UWB received ntf gid:%d", gid);
372 if ((!(gid == UCI_GID_CORE && oid == UCI_MSG_CORE_GENERIC_ERROR_NTF &&
373 pp[0] == UCI_STATUS_COMMAND_RETRY)) &&
374 uwb_cb.IsConformaceTestEnabled) {
375 // handling of ntf for conformance test
376 uwb_ucif_proc_conformance_ntf(p, payload_length + 4);
377 return (free);
378 }
379
380 switch (gid) {
381 case UCI_GID_CORE:
382 uci_proc_core_management_ntf(oid, pp, payload_length);
383 break;
384 case UCI_GID_SESSION_MANAGE: /* 0010b UCI management group */
385 uci_proc_session_management_ntf(oid, pp, payload_length);
386 break;
387 case UCI_GID_RANGE_MANAGE: /* 0011b UCI Range management group */
388 range_data_ntf_len = p_msg->len;
389 for (int i=0; i<p_msg->len;i++) {
390 range_data_ntf_buffer[i] = p[i];
391 }
392 uci_proc_rang_management_ntf(oid, pp, payload_length);
393 break;
394 case UCI_GID_TEST: /* 1101b test group */
395 //uci_proc_test_management_ntf(oid, pp, payload_length);
396 //send vendor specific ntf as it is handled by vendor extension
397 uci_proc_vendor_specific_ntf(gid, p, (payload_length + UCI_MSG_HDR_SIZE));
398 break;
399 case UCI_GID_VENDOR_SPECIFIC_0x09:
400 case UCI_GID_VENDOR_SPECIFIC_0x0A:
401 case UCI_GID_VENDOR_SPECIFIC_0x0B:
402 case UCI_GID_VENDOR_SPECIFIC_0x0C:
403 case UCI_GID_VENDOR_SPECIFIC_0x0E:
404 case UCI_GID_VENDOR_SPECIFIC_0x0F:
405 uci_proc_vendor_specific_ntf(gid, p, (payload_length + UCI_MSG_HDR_SIZE));
406 break;
407 default:
408 UCI_TRACE_E("uwb_ucif_process_event: UWB Unknown gid:%d", gid);
409 break;
410 }
411 break;
412 default:
413 UCI_TRACE_E(
414 "uwb_ucif_process_event: UWB received unknown mt:0x%x, gid:%d", mt,
415 gid);
416 }
417 } else {
418 UCI_TRACE_E("uwb_ucif_process_event: NULL pointer");
419 }
420 return (free);
421 }
422
423 /*******************************************************************************
424 **
425 ** Function uwb_ucif_proc_core_device_reset_rsp_status
426 **
427 ** Description This function is called to report UWB_DEVICE_RESET_REVT
428 **
429 ** Returns void
430 **
431 *******************************************************************************/
uwb_ucif_proc_core_device_reset_rsp_status(uint8_t * p_buf,uint16_t len)432 void uwb_ucif_proc_core_device_reset_rsp_status(uint8_t* p_buf, uint16_t len) {
433 tUWB_RESPONSE evt_data;
434 tUWB_STATUS status;
435
436 if (len == 0) {
437 UCI_TRACE_E("%s: len is zero", __func__);
438 return;
439 }
440 status = (tUWB_STATUS)*p_buf;
441 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
442 status);
443 if (uwb_cb.p_resp_cback == NULL) {
444 UCI_TRACE_E("%s: response callback is null", __func__);
445 return;
446 }
447 evt_data.sDevice_reset.status = status;
448 if (status == UWA_STATUS_OK) {
449 UCI_TRACE_I("%s: Device Reset Successful", __func__);
450 } else {
451 UCI_TRACE_E("%s: Device Reset Failed", __func__);
452 }
453 (*uwb_cb.p_resp_cback)(UWB_DEVICE_RESET_REVT, &evt_data);
454 }
455
456 /*******************************************************************************
457 **
458 ** Function uwb_ucif_proc_core_set_config_status
459 **
460 ** Description This function is called to report UWB_SET_CORE_CONFIG_REVT
461 **
462 ** Returns void
463 **
464 *******************************************************************************/
uwb_ucif_proc_core_set_config_status(uint8_t * p_buf,uint16_t len)465 void uwb_ucif_proc_core_set_config_status(uint8_t* p_buf, uint16_t len) {
466 tUWB_RESPONSE evt_data;
467 tUWB_STATUS status;
468 uint8_t* p = p_buf;
469 if (len == 0) {
470 UCI_TRACE_E("%s: len is zero", __func__);
471 return;
472 }
473 status = (tUWB_STATUS)*p++;
474 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
475 status);
476 if (uwb_cb.p_resp_cback == NULL) {
477 UCI_TRACE_E("%s: response callback is null", __func__);
478 return;
479 }
480 evt_data.sCore_set_config.status = status;
481 evt_data.sCore_set_config.num_param_id = *p++;
482 evt_data.sCore_set_config.tlv_size = (uint16_t)(len - CONFIG_TLV_OFFSET);
483 if (evt_data.sCore_set_config.tlv_size > 0) {
484 STREAM_TO_ARRAY(evt_data.sCore_set_config.param_ids, p,
485 evt_data.sCore_set_config.tlv_size);
486 }
487 (*uwb_cb.p_resp_cback)(UWB_SET_CORE_CONFIG_REVT, &evt_data);
488 }
489
490 /*******************************************************************************
491 **
492 ** Function uwb_ucif_proc_core_get_config_rsp
493 **
494 ** Description This function is called to process get config response
495 **
496 ** Returns void
497 **
498 *******************************************************************************/
uwb_ucif_proc_core_get_config_rsp(uint8_t * p_buf,uint16_t len)499 void uwb_ucif_proc_core_get_config_rsp(uint8_t* p_buf, uint16_t len) {
500 tUWB_RESPONSE evt_data;
501 tUWB_STATUS status;
502 uint8_t* p = p_buf;
503 if (len == 0) {
504 UCI_TRACE_E("%s: len is zero", __func__);
505 return;
506 }
507 status = *p++;
508 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
509 status);
510 if (uwb_cb.p_resp_cback == NULL) {
511 UCI_TRACE_E("%s: response callback is null", __func__);
512 return;
513 }
514 evt_data.sCore_get_config.status = status;
515 evt_data.sCore_get_config.no_of_ids = *p++;
516 evt_data.sCore_get_config.tlv_size = (uint16_t)(len - CONFIG_TLV_OFFSET);
517 if (evt_data.sCore_get_config.tlv_size > 0) {
518 memcpy(evt_data.sCore_get_config.p_param_tlvs, p,
519 evt_data.sCore_get_config.tlv_size);
520 }
521
522 (*uwb_cb.p_resp_cback)(UWB_GET_CORE_CONFIG_REVT, &evt_data);
523 }
524
525 /*******************************************************************************
526 **
527 ** Function uwb_ucif_session_management_status
528 **
529 ** Description This function is called to process session command
530 *responses
531 **
532 ** Returns void
533 **
534 *******************************************************************************/
uwb_ucif_session_management_status(tUWB_RESPONSE_EVT event,uint8_t * p_buf,uint16_t len)535 void uwb_ucif_session_management_status(tUWB_RESPONSE_EVT event, uint8_t* p_buf,
536 uint16_t len) {
537 tUWB_RESPONSE evt_data;
538 tUWB_RESPONSE_EVT evt = 0;
539 tUWB_STATUS status;
540 uint8_t* p = p_buf;
541
542 if (len == 0) {
543 UCI_TRACE_E("%s: len is zero", __func__);
544 return;
545 }
546 if (uwb_cb.p_resp_cback == NULL) {
547 UCI_TRACE_E("%s: response callback is null", __func__);
548 return;
549 }
550 status = *p++;
551 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
552 status);
553 switch (event) {
554 case UWB_SESSION_INIT_REVT:
555 evt = UWB_SESSION_INIT_REVT;
556 evt_data.status = status;
557 break;
558 case UWB_SESSION_DEINIT_REVT:
559 evt = UWB_SESSION_DEINIT_REVT;
560 evt_data.status = status;
561 break;
562 case UWB_SESSION_GET_COUNT_REVT:
563 evt = UWB_SESSION_GET_COUNT_REVT;
564 evt_data.sGet_session_cnt.status = status;
565 evt_data.sGet_session_cnt.count = *p;
566 break;
567 case UWB_SESSION_GET_STATE_REVT:
568 evt = UWB_SESSION_GET_STATE_REVT;
569 evt_data.sGet_session_state.status = status;
570 evt_data.sGet_session_state.session_state = *p;
571 break;
572 case UWB_SESSION_UPDATE_MULTICAST_LIST_REVT:
573 evt = UWB_SESSION_UPDATE_MULTICAST_LIST_REVT;
574 evt_data.status = status;
575 break;
576 default:
577 UCI_TRACE_E("unknown response event %x", event);
578 }
579 if (evt) {
580 (*uwb_cb.p_resp_cback)(evt, &evt_data);
581 }
582 }
583 /*******************************************************************************
584 **
585 ** Function uwb_ucif_proc_app_get_config_status
586 **
587 ** Description This function is called to process get config response
588 **
589 ** Returns void
590 **
591 *******************************************************************************/
uwb_ucif_proc_app_get_config_status(uint8_t * p_buf,uint16_t len)592 void uwb_ucif_proc_app_get_config_status(uint8_t* p_buf, uint16_t len) {
593 tUWB_RESPONSE evt_data;
594 tUWB_STATUS status;
595 uint8_t* p = p_buf;
596
597 if (len == 0) {
598 UCI_TRACE_E("%s: len is zero", __func__);
599 return;
600 }
601 status = *p++;
602 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
603 status);
604 if (uwb_cb.p_resp_cback == NULL) {
605 UCI_TRACE_E("%s: response callback is null", __func__);
606 return;
607 }
608 evt_data.sApp_get_config.status = status;
609 evt_data.sApp_get_config.no_of_ids = *p++;
610 evt_data.sApp_get_config.tlv_size = (uint16_t)(len - CONFIG_TLV_OFFSET);
611 if (evt_data.sApp_get_config.tlv_size > 0) {
612 memcpy(evt_data.sApp_get_config.p_param_tlvs, p,
613 evt_data.sApp_get_config.tlv_size);
614 }
615 (*uwb_cb.p_resp_cback)(UWB_GET_APP_CONFIG_REVT, &evt_data);
616 }
617
618 /*******************************************************************************
619 **
620 ** Function uwb_ucif_proc_app_set_config_status
621 **
622 ** Description This function is called to report UWB_SET_APP_CONFIG_REVT
623 **
624 ** Returns void
625 **
626 *******************************************************************************/
uwb_ucif_proc_app_set_config_status(uint8_t * p_buf,uint16_t len)627 void uwb_ucif_proc_app_set_config_status(uint8_t* p_buf, uint16_t len) {
628 tUWB_RESPONSE evt_data;
629 tUWB_STATUS status;
630 uint8_t* p = p_buf;
631
632 if (len == 0) {
633 UCI_TRACE_E("%s: len is zero", __func__);
634 return;
635 }
636 status = *p++;
637 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
638 status);
639 if (uwb_cb.p_resp_cback == NULL) {
640 UCI_TRACE_E("%s: response callback is null", __func__);
641 return;
642 }
643 evt_data.sApp_set_config.status = status;
644 evt_data.sApp_set_config.num_param_id = *p++;
645 evt_data.sApp_set_config.tlv_size = (uint16_t)(len - CONFIG_TLV_OFFSET);
646 if (evt_data.sApp_set_config.tlv_size > 0) {
647 STREAM_TO_ARRAY(evt_data.sApp_set_config.param_ids, p,
648 evt_data.sApp_set_config.tlv_size);
649 }
650
651 (*uwb_cb.p_resp_cback)(UWB_SET_APP_CONFIG_REVT, &evt_data);
652 }
653
654 /*******************************************************************************
655 **
656 ** Function uwb_ucif_range_management_status
657 **
658 ** Description This function is called to process raning start/stop
659 *command responses
660 **
661 ** Returns void
662 **
663 *******************************************************************************/
uwb_ucif_range_management_status(tUWB_RESPONSE_EVT event,uint8_t * p_buf,uint16_t len)664 void uwb_ucif_range_management_status(tUWB_RESPONSE_EVT event, uint8_t* p_buf,
665 uint16_t len) {
666 tUWB_RESPONSE evt_data;
667 tUWB_RESPONSE_EVT evt = 0;
668 uint8_t status = *p_buf;
669
670 if (len == 0) {
671 UCI_TRACE_E("%s: len is zero", __func__);
672 return;
673 }
674 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
675 status);
676 if (uwb_cb.p_resp_cback == NULL) {
677 UCI_TRACE_E("%s: response callback is null", __func__);
678 return;
679 }
680 switch (event) {
681 case UWB_START_RANGE_REVT:
682 evt = UWB_START_RANGE_REVT;
683 break;
684 case UWB_STOP_RANGE_REVT:
685 evt = UWB_STOP_RANGE_REVT;
686 break;
687 case UWB_BLINK_DATA_TX_REVT:
688 evt = UWB_BLINK_DATA_TX_REVT;
689 break;
690 default:
691 UCI_TRACE_E("unknown response event %x", event);
692 }
693 if (evt) {
694 evt_data.status = status;
695 (*uwb_cb.p_resp_cback)(evt, &evt_data);
696 }
697 }
698
699 /*******************************************************************************
700 **
701 ** Function uwb_ucif_get_range_count_status
702 **
703 ** Description This function is called to process get range command
704 ** responses
705 **
706 ** Returns void
707 **
708 *******************************************************************************/
uwb_ucif_get_range_count_status(tUWB_RESPONSE_EVT event,uint8_t * p_buf,uint16_t len)709 void uwb_ucif_get_range_count_status(tUWB_RESPONSE_EVT event, uint8_t* p_buf,
710 uint16_t len) {
711 tUWB_RESPONSE evt_data;
712 tUWB_RESPONSE_EVT evt = 0;
713 tUWB_GET_RANGE_COUNT_REVT get_count;
714 uint8_t* p = p_buf;
715
716 if (len == 0) {
717 UCI_TRACE_E("%s: len is zero", __func__);
718 return;
719 }
720 if (uwb_cb.p_resp_cback == NULL) {
721 UCI_TRACE_E("%s: response callback is null", __func__);
722 return;
723 }
724 switch (event) {
725 case UWB_GET_RANGE_COUNT_REVT:
726 STREAM_TO_UINT8(get_count.status, p);
727 STREAM_TO_UINT32(get_count.count, p);
728 UCI_TRACE_I("get_count status = %d", get_count.status);
729 evt_data.sGet_range_cnt = get_count;
730 evt = UWB_GET_RANGE_COUNT_REVT;
731 break;
732 default:
733 UCI_TRACE_E("unknown response event %x", event);
734 }
735 if (evt) {
736 evt_data.status = get_count.status;
737 (*uwb_cb.p_resp_cback)(evt, &evt_data);
738 }
739 }
740
741 /*******************************************************************************
742 **
743 ** Function uwb_ucif_proc_core_device_status
744 **
745 ** Description This function is called to device status notification
746 **
747 ** Returns void
748 **
749 *******************************************************************************/
uwb_ucif_proc_core_device_status(uint8_t * p_buf,uint16_t len)750 void uwb_ucif_proc_core_device_status(uint8_t* p_buf, uint16_t len) {
751 tUWB_RESPONSE uwb_response;
752 if (len == 0) {
753 UCI_TRACE_E("%s: len is zero", __func__);
754 return;
755 }
756 uint8_t status = *p_buf;
757
758 UCI_TRACE_I("uwb_ucif_proc_core_device_status dev_status = %x", status);
759 uwb_response.sDevice_status.status = status;
760 uwb_cb.device_state = status;
761
762 (*uwb_cb.p_resp_cback)(UWB_DEVICE_STATUS_REVT, &uwb_response);
763 if (status == UWBS_STATUS_ERROR) {
764 uwb_stop_quick_timer(&uwb_cb.uci_wait_rsp_timer);
765 uwb_ucif_uwb_recovery();
766 }
767 }
768
769 /*******************************************************************************
770 **
771 ** Function uwb_ucif_proc_core_generic_error_ntf
772 **
773 ** Description This function is called to process core generic error
774 ** notification
775 **
776 ** Returns void
777 **
778 *******************************************************************************/
uwb_ucif_proc_core_generic_error_ntf(uint8_t * p_buf,uint16_t len)779 void uwb_ucif_proc_core_generic_error_ntf(uint8_t* p_buf, uint16_t len) {
780 tUWB_RESPONSE uwb_response;
781 if (len == 0) {
782 UCI_TRACE_E("%s: len is zero", __func__);
783 return;
784 }
785 uint8_t status = *p_buf;
786 if (uwb_cb.p_resp_cback == NULL) {
787 UCI_TRACE_E("%s: response callback is null", __func__);
788 return;
789 }
790 UCI_TRACE_I("uwb_ucif_proc_core_generic_error_ntf: status = %x", status);
791 uwb_response.sCore_gen_err_status.status = status;
792 if ((status == UCI_STATUS_COMMAND_RETRY) && uwb_cb.is_resp_pending) {
793 uwb_stop_quick_timer(
794 &uwb_cb.uci_wait_rsp_timer); /*stop the pending timer */
795 uwb_ucif_retransmit_cmd(uwb_cb.pLast_cmd_buf);
796 uwb_cb.cmd_retry_count++;
797 } else {
798 (*uwb_cb.p_resp_cback)(UWB_CORE_GEN_ERR_STATUS_REVT, &uwb_response);
799 }
800 }
801
802 /*******************************************************************************
803 **
804 ** Function uwb_ucif_proc_ranging_data
805 **
806 ** Description This function is called to process ranging data
807 ** notifications
808 **
809 ** Returns void
810 **
811 *******************************************************************************/
uwb_ucif_proc_ranging_data(uint8_t * p,uint16_t len)812 void uwb_ucif_proc_ranging_data(uint8_t* p, uint16_t len) {
813 tUWB_RANGE_DATA_REVT sRange_data;
814 tUWB_RESPONSE uwb_response;
815 int16_t ranging_measures_length = 0;
816 if (len == 0) {
817 UCI_TRACE_E("%s: len is zero", __func__);
818 return;
819 }
820 if (uwb_cb.p_resp_cback == NULL) {
821 UCI_TRACE_E("%s: response callback is null", __func__);
822 return;
823 }
824 memset(&sRange_data, 0, sizeof(tUWB_RANGE_DATA_REVT));
825 sRange_data.range_data_len = len;
826 STREAM_TO_UINT32(sRange_data.seq_counter, p);
827 STREAM_TO_UINT32(sRange_data.session_id, p);
828 STREAM_TO_UINT8(sRange_data.rcr_indication, p);
829 STREAM_TO_UINT32(sRange_data.curr_range_interval, p);
830 STREAM_TO_UINT8(sRange_data.ranging_measure_type, p);
831 STREAM_TO_UINT8(sRange_data.rfu, p);
832 STREAM_TO_UINT8(sRange_data.mac_addr_mode_indicator, p);
833 STREAM_TO_ARRAY(&sRange_data.reserved[0], p, 8);
834 STREAM_TO_UINT8(sRange_data.no_of_measurements, p);
835 ranging_measures_length = len - RANGING_DATA_LENGTH;
836 if (sRange_data.ranging_measure_type == MEASUREMENT_TYPE_TWOWAY &&
837 sRange_data.no_of_measurements > MAX_NUM_RESPONDERS) {
838 UCI_TRACE_E(
839 "%s: MEASUREMENT_TYPE_TWOWAY Wrong number of measurements received:%d",
840 __func__, sRange_data.no_of_measurements);
841 return;
842 } else if (sRange_data.ranging_measure_type == MEASUREMENT_TYPE_ONEWAY &&
843 sRange_data.no_of_measurements > MAX_NUM_OF_TDOA_MEASURES) {
844 UCI_TRACE_E(
845 "%s: MEASUREMENT_TYPE_ONEWAY Wrong number of measurements received:%d",
846 __func__, sRange_data.no_of_measurements);
847 return;
848 }
849 if (sRange_data.ranging_measure_type == MEASUREMENT_TYPE_TWOWAY) {
850 for (uint8_t i = 0; i < sRange_data.no_of_measurements; i++) {
851 tUWA_TWR_RANGING_MEASR* twr_range_measr =
852 (tUWA_TWR_RANGING_MEASR*)&sRange_data.ranging_measures
853 .twr_range_measr[i];
854 if (ranging_measures_length < TWO_WAY_MEASUREMENT_LENGTH) {
855 UCI_TRACE_E("%s: Invalid ranging_measures_length = %x", __func__,
856 ranging_measures_length);
857 return;
858 }
859 ranging_measures_length -= TWO_WAY_MEASUREMENT_LENGTH;
860 if (sRange_data.mac_addr_mode_indicator == SHORT_MAC_ADDRESS) {
861 STREAM_TO_ARRAY(&twr_range_measr->mac_addr[0], p, MAC_SHORT_ADD_LEN);
862 } else if (sRange_data.mac_addr_mode_indicator == EXTENDED_MAC_ADDRESS) {
863 STREAM_TO_ARRAY(&twr_range_measr->mac_addr[0], p, MAC_EXT_ADD_LEN);
864 } else {
865 UCI_TRACE_E("%s: Invalid mac addressing indicator", __func__);
866 return;
867 }
868 STREAM_TO_UINT8(twr_range_measr->status, p);
869 STREAM_TO_UINT8(twr_range_measr->nLos, p);
870 STREAM_TO_UINT16(twr_range_measr->distance, p);
871 STREAM_TO_UINT16(twr_range_measr->aoa_azimuth, p);
872 STREAM_TO_UINT8(twr_range_measr->aoa_azimuth_FOM, p);
873 STREAM_TO_UINT16(twr_range_measr->aoa_elevation, p);
874 STREAM_TO_UINT8(twr_range_measr->aoa_elevation_FOM, p);
875 STREAM_TO_UINT16(twr_range_measr->aoa_dest_azimuth, p);
876 STREAM_TO_UINT8(twr_range_measr->aoa_dest_azimuth_FOM, p);
877 STREAM_TO_UINT16(twr_range_measr->aoa_dest_elevation, p);
878 STREAM_TO_UINT8(twr_range_measr->aoa_dest_elevation_FOM, p);
879 STREAM_TO_UINT8(twr_range_measr->slot_index, p);
880 /* Read & Ignore RFU bytes
881 if mac address format is short, then 12 bytes
882 if mac address format is extended, then read 6 bytes */
883 if (sRange_data.mac_addr_mode_indicator == SHORT_MAC_ADDRESS) {
884 STREAM_TO_ARRAY(&twr_range_measr->rfu[0], p, 12);
885 } else {
886 STREAM_TO_ARRAY(&twr_range_measr->rfu[0], p, 6);
887 }
888 }
889 } else if (sRange_data.ranging_measure_type == MEASUREMENT_TYPE_ONEWAY) {
890 for (uint8_t i = 0; i < sRange_data.no_of_measurements; i++) {
891 tUWA_TDoA_RANGING_MEASR* tdoa_range_measr =
892 (tUWA_TDoA_RANGING_MEASR*)&sRange_data.ranging_measures
893 .tdoa_range_measr[i];
894 uint16_t blink_payload_length = 0;
895 uint16_t device_info_length = 0;
896 if (ranging_measures_length < ONE_WAY_MEASUREMENT_LENGTH) {
897 UCI_TRACE_E("%s: Invalid ranging_measures_length = %x", __func__,
898 ranging_measures_length);
899 return;
900 }
901 ranging_measures_length -= ONE_WAY_MEASUREMENT_LENGTH;
902 if (sRange_data.mac_addr_mode_indicator == SHORT_MAC_ADDRESS) {
903 STREAM_TO_ARRAY(&tdoa_range_measr->mac_addr[0], p, MAC_SHORT_ADD_LEN);
904 } else if (sRange_data.mac_addr_mode_indicator == EXTENDED_MAC_ADDRESS) {
905 STREAM_TO_ARRAY(&tdoa_range_measr->mac_addr[0], p, MAC_EXT_ADD_LEN);
906 } else {
907 UCI_TRACE_E("%s: Invalid mac addressing indicator", __func__);
908 return;
909 }
910 STREAM_TO_UINT8(tdoa_range_measr->frame_type, p);
911 STREAM_TO_UINT8(tdoa_range_measr->nLos, p);
912 STREAM_TO_UINT16(tdoa_range_measr->aoa_azimuth, p);
913 STREAM_TO_UINT8(tdoa_range_measr->aoa_azimuth_FOM, p);
914 STREAM_TO_UINT16(tdoa_range_measr->aoa_elevation, p);
915 STREAM_TO_UINT8(tdoa_range_measr->aoa_elevation_FOM, p);
916 STREAM_TO_UINT64(tdoa_range_measr->timeStamp, p);
917 STREAM_TO_UINT32(tdoa_range_measr->blink_frame_number, p);
918 if (sRange_data.mac_addr_mode_indicator == SHORT_MAC_ADDRESS) {
919 STREAM_TO_ARRAY(&tdoa_range_measr->rfu[0], p, 12);
920 } else {
921 STREAM_TO_ARRAY(&tdoa_range_measr->rfu[0], p, 6);
922 }
923 STREAM_TO_UINT8(tdoa_range_measr->device_info_size, p);
924 device_info_length = tdoa_range_measr->device_info_size;
925 ranging_measures_length -= device_info_length;
926 if (ranging_measures_length < device_info_length) {
927 UCI_TRACE_E(
928 "%s: Invalid ranging_measures_length to copy device_info_length = "
929 "%x",
930 __func__, ranging_measures_length);
931 return;
932 }
933 STREAM_TO_ARRAY(&device_info_buffer[i][0], p,
934 tdoa_range_measr->device_info_size);
935 tdoa_range_measr->device_info = &device_info_buffer[i][0];
936 STREAM_TO_UINT8(tdoa_range_measr->blink_payload_size, p);
937 blink_payload_length = tdoa_range_measr->blink_payload_size;
938 ranging_measures_length -= blink_payload_length;
939 if (ranging_measures_length < blink_payload_length) {
940 UCI_TRACE_E(
941 "%s: Invalid ranging_measures_length to copy blink_payload_length "
942 "= %x",
943 __func__, ranging_measures_length);
944 return;
945 }
946 STREAM_TO_ARRAY(&blink_payload_buffer[i][0], p,
947 tdoa_range_measr->blink_payload_size);
948 tdoa_range_measr->blink_payload_data = &blink_payload_buffer[i][0];
949 }
950 } else {
951 UCI_TRACE_E("%s: Measurement type not matched", __func__);
952 }
953 uwb_response.sRange_data = sRange_data;
954
955 (*uwb_cb.p_resp_cback)(UWB_RANGE_DATA_REVT, &uwb_response);
956
957 UCI_TRACE_I("%s: ranging_measures_length = %d range_data_ntf_len = %d", __func__,ranging_measures_length,range_data_ntf_len);
958 if (ranging_measures_length >= VENDOR_SPEC_INFO_LEN) {
959 uint16_t vendor_specific_length =0;
960 STREAM_TO_UINT16(vendor_specific_length, p);
961 if (vendor_specific_length > 0) {
962 if (vendor_specific_length > MAX_VENDOR_INFO_LENGTH) {
963 UCI_TRACE_E("%s: Invalid Range_data vendor_specific_length = %x",
964 __func__, vendor_specific_length);
965 return;
966 }
967
968 uint8_t *range_data_with_vendor_info = range_data_ntf_buffer;
969 uwb_response.sVendor_specific_ntf.len = range_data_ntf_len;
970 STREAM_TO_ARRAY(uwb_response.sVendor_specific_ntf.data, range_data_with_vendor_info, range_data_ntf_len);
971 (*uwb_cb.p_resp_cback)(UWB_VENDOR_SPECIFIC_UCI_NTF_EVT, &uwb_response);
972 }
973 }
974 }
975
976 /*******************************************************************************
977 **
978 ** Function uwb_ucif_proc_send_blink_data_ntf
979 **
980 ** Description This function is called to process blink data tx
981 ** notification
982 **
983 ** Returns void
984 **
985 *******************************************************************************/
uwb_ucif_proc_send_blink_data_ntf(uint8_t * p_buf,uint16_t len)986 void uwb_ucif_proc_send_blink_data_ntf(uint8_t* p_buf, uint16_t len) {
987 tUWB_SEND_BLINK_DATA_NTF_REVT blink_data_tx_ntf;
988 tUWB_RESPONSE uwb_response;
989 if (len == 0) {
990 UCI_TRACE_E("%s: len is zero", __func__);
991 return;
992 }
993 if (uwb_cb.p_resp_cback == NULL) {
994 UCI_TRACE_E("%s: response callback is null", __func__);
995 return;
996 }
997 memset(&blink_data_tx_ntf, 0, sizeof(tUWB_SEND_BLINK_DATA_NTF_REVT));
998 if (len != 0) {
999 STREAM_TO_UINT8(blink_data_tx_ntf.repetition_count_status, p_buf);
1000 } else {
1001 UCI_TRACE_E("blink_data_tx ntf error");
1002 }
1003 uwb_response.sSend_blink_data_ntf = blink_data_tx_ntf;
1004
1005 (*uwb_cb.p_resp_cback)(UWB_BLINK_DATA_TX_NTF_REVT, &uwb_response);
1006 }
1007
1008 /*******************************************************************************
1009 **
1010 ** Function uwb_ucif_proc_android_set_country_code_status
1011 **
1012 ** Description This function is called to set country code status
1013 ** notification
1014 **
1015 ** Returns void
1016 **
1017 *******************************************************************************/
uwb_ucif_proc_android_set_country_code_status(uint8_t * p_buf,uint16_t len)1018 void uwb_ucif_proc_android_set_country_code_status(uint8_t* p_buf,
1019 uint16_t len) {
1020 tUWB_RESPONSE uwb_response;
1021 if (len == 0) {
1022 UCI_TRACE_E("%s: len is zero", __func__);
1023 return;
1024 }
1025 uint8_t status = *p_buf;
1026
1027 UCI_TRACE_I("uwb_ucif_proc_android_set_country_code_status country code status = %x", status);
1028 uwb_response.sSet_country_code_status.status = status;
1029 uwb_cb.device_state = status;
1030
1031 (*uwb_cb.p_resp_cback)(UWB_SET_COUNTRY_CODE_REVT, &uwb_response);
1032 if (status == UWBS_STATUS_ERROR) {
1033 uwb_stop_quick_timer(&uwb_cb.uci_wait_rsp_timer);
1034 uwb_ucif_uwb_recovery();
1035 }
1036 }
1037
1038 /*******************************************************************************
1039 **
1040 ** Function uwb_ucif_proc_conformance_ntf
1041 **
1042 ** Description This function is called to process conformance test ntf
1043 **
1044 ** Returns void
1045 **
1046 *******************************************************************************/
1047
uwb_ucif_proc_conformance_ntf(uint8_t * p_buf,uint16_t len)1048 void uwb_ucif_proc_conformance_ntf(uint8_t* p_buf, uint16_t len) {
1049 tUWB_RESPONSE uwb_response;
1050 tUWB_CONFORMANCE_TEST_DATA conformance_data_ntf;
1051
1052 if (uwb_cb.p_resp_cback == NULL) {
1053 UCI_TRACE_E("%s: response callback is null", __func__);
1054 return;
1055 }
1056 memset(&conformance_data_ntf, 0, sizeof(tUWB_CONFORMANCE_TEST_DATA));
1057 if (len < CONFORMANCE_TEST_MAX_UCI_PKT_LENGTH) {
1058 conformance_data_ntf.length = len;
1059 STREAM_TO_ARRAY(&conformance_data_ntf.data[0], p_buf, len);
1060 } else {
1061 conformance_data_ntf.length = CONFORMANCE_TEST_MAX_UCI_PKT_LENGTH;
1062 STREAM_TO_ARRAY(&conformance_data_ntf.data[0], p_buf,
1063 CONFORMANCE_TEST_MAX_UCI_PKT_LENGTH);
1064 }
1065 uwb_response.sConformance_test_data = conformance_data_ntf;
1066 (*uwb_cb.p_resp_cback)(UWB_CONFORMANCE_TEST_DATA, &uwb_response);
1067 }
1068
1069 /*******************************************************************************
1070 **
1071 ** Function uwb_ucif_proc_session_status
1072 **
1073 ** Description This function is called to process session related
1074 ** notification
1075 **
1076 ** Returns void
1077 **
1078 *******************************************************************************/
uwb_ucif_proc_session_status(uint8_t * p_buf,uint16_t len)1079 void uwb_ucif_proc_session_status(uint8_t* p_buf, uint16_t len) {
1080 tUWB_SESSION_NTF_REVT sessionNtf;
1081 tUWB_RESPONSE uwb_response;
1082 if (len == 0) {
1083 UCI_TRACE_E("%s: len is zero", __func__);
1084 return;
1085 }
1086 if (uwb_cb.p_resp_cback == NULL) {
1087 UCI_TRACE_E("%s: response callback is null", __func__);
1088 return;
1089 }
1090 memset(&sessionNtf, 0, sizeof(tUWB_SESSION_NTF_REVT));
1091 if (len != 0) {
1092 STREAM_TO_UINT32(sessionNtf.session_id, p_buf);
1093 STREAM_TO_UINT8(sessionNtf.state, p_buf);
1094 STREAM_TO_UINT8(sessionNtf.reason_code, p_buf);
1095 } else {
1096 UCI_TRACE_E("session ntf error");
1097 }
1098 uwb_response.sSessionStatus = sessionNtf;
1099
1100 (*uwb_cb.p_resp_cback)(UWB_SESSION_STATUS_NTF_REVT, &uwb_response);
1101 }
1102
1103 /*******************************************************************************
1104 **
1105 ** Function uwb_ucif_proc_multicast_list_update_ntf
1106 **
1107 ** Description This function is called to process multicast list update
1108 ** notification
1109 **
1110 ** Returns void
1111 **
1112 *******************************************************************************/
uwb_ucif_proc_multicast_list_update_ntf(uint8_t * p_buf,uint16_t len)1113 void uwb_ucif_proc_multicast_list_update_ntf(uint8_t* p_buf, uint16_t len) {
1114 tUWB_SESSION_UPDATE_MULTICAST_LIST_NTF_REVT sMulticast_list_ntf;
1115 tUWB_RESPONSE uwb_response;
1116 if (len == 0) {
1117 UCI_TRACE_E("%s: len is zero", __func__);
1118 return;
1119 }
1120 if (uwb_cb.p_resp_cback == NULL) {
1121 UCI_TRACE_E("%s: response callback is null", __func__);
1122 return;
1123 }
1124 memset(&sMulticast_list_ntf, 0,
1125 sizeof(tUWB_SESSION_UPDATE_MULTICAST_LIST_NTF_REVT));
1126 if (len != 0) {
1127 STREAM_TO_UINT32(sMulticast_list_ntf.session_id, p_buf);
1128 STREAM_TO_UINT8(sMulticast_list_ntf.remaining_list, p_buf);
1129 STREAM_TO_UINT8(sMulticast_list_ntf.no_of_controlees, p_buf);
1130 if (sMulticast_list_ntf.no_of_controlees > MAX_NUM_CONTROLLEES) {
1131 UCI_TRACE_E("%s: wrong number of controless : %d", __func__,
1132 sMulticast_list_ntf.no_of_controlees);
1133 return;
1134 }
1135 for (uint8_t i = 0; i < sMulticast_list_ntf.no_of_controlees; i++) {
1136 REVERSE_STREAM_TO_ARRAY(
1137 &sMulticast_list_ntf.controlee_mac_address_list[i], p_buf,
1138 SHORT_ADDRESS_LEN);
1139 STREAM_TO_UINT32(sMulticast_list_ntf.subsession_id_list[i], p_buf);
1140 STREAM_TO_UINT8(sMulticast_list_ntf.status_list[i], p_buf);
1141 }
1142 } else {
1143 UCI_TRACE_E("multicast list update ntf error");
1144 }
1145 uwb_response.sMulticast_list_ntf = sMulticast_list_ntf;
1146
1147 (*uwb_cb.p_resp_cback)(UWB_SESSION_UPDATE_MULTICAST_LIST_NTF_REVT,
1148 &uwb_response);
1149 }
1150
1151 /*******************************************************************************
1152 **
1153 ** Function uwb_ucif_proc_get_device_info_rsp
1154 **
1155 ** Description This function is called to process get device info response
1156 **
1157 ** Returns void
1158 **
1159 *******************************************************************************/
uwb_ucif_proc_get_device_info_rsp(uint8_t * p_buf,uint16_t len)1160 void uwb_ucif_proc_get_device_info_rsp(uint8_t* p_buf, uint16_t len) {
1161 tUWB_RESPONSE evt_data;
1162 uint8_t* p = p_buf;
1163 if (len == 0) {
1164 UCI_TRACE_E("%s: len is zero", __func__);
1165 return;
1166 }
1167 if (uwb_cb.p_resp_cback == NULL) {
1168 UCI_TRACE_E("%s: response callback is null", __func__);
1169 return;
1170 }
1171 memset(&evt_data.sGet_device_info, 0, sizeof(tUWB_GET_DEVICE_INFO_REVT));
1172 evt_data.sGet_device_info.status = *p++;
1173 STREAM_TO_UINT16(evt_data.sGet_device_info.uci_version, p);
1174 STREAM_TO_UINT16(evt_data.sGet_device_info.mac_version, p);
1175 STREAM_TO_UINT16(evt_data.sGet_device_info.phy_version, p);
1176 STREAM_TO_UINT16(evt_data.sGet_device_info.uciTest_version, p);
1177 STREAM_TO_UINT8(evt_data.sGet_device_info.vendor_info_len, p);
1178 STREAM_TO_ARRAY(evt_data.sGet_device_info.vendor_info, p,
1179 evt_data.sGet_device_info.vendor_info_len);
1180
1181 (*uwb_cb.p_resp_cback)(UWB_GET_DEVICE_INFO_REVT, &evt_data);
1182 }
1183
1184 /*******************************************************************************
1185 **
1186 ** Function uwb_ucif_proc_get_device_capability_rsp
1187 **
1188 ** Description This function is called to process get device capability
1189 ** response.
1190 **
1191 ** Returns void
1192 **
1193 *******************************************************************************/
uwb_ucif_proc_get_device_capability_rsp(uint8_t * p_buf,uint16_t len)1194 void uwb_ucif_proc_get_device_capability_rsp(uint8_t* p_buf, uint16_t len) {
1195 tUWB_RESPONSE evt_data;
1196 tUWB_STATUS status;
1197 uint8_t* p = p_buf;
1198
1199 if (len == 0) {
1200 UCI_TRACE_E("%s: len is zero", __func__);
1201 return;
1202 }
1203 status = *p++;
1204 UCI_TRACE_I("StatusName:%s and StatusValue:%d", UWB_GetStatusName(status),
1205 status);
1206 if (uwb_cb.p_resp_cback == NULL) {
1207 UCI_TRACE_E("%s: response callback is null", __func__);
1208 return;
1209 }
1210 evt_data.sGet_device_capability.status = status;
1211 evt_data.sGet_device_capability.no_of_tlvs = *p++;
1212 evt_data.sGet_device_capability.tlv_buffer_len =
1213 (uint16_t)(len - CONFIG_TLV_OFFSET);
1214 if (evt_data.sGet_device_capability.tlv_buffer_len > 0) {
1215 memcpy(evt_data.sGet_device_capability.tlv_buffer, p,
1216 evt_data.sGet_device_capability.tlv_buffer_len);
1217 }
1218
1219 (*uwb_cb.p_resp_cback)(UWB_CORE_GET_DEVICE_CAPABILITY_REVT, &evt_data);
1220 }
1221
1222 /*******************************************************************************
1223 **
1224 ** Function uwb_ucif_proc_test_get_config_status
1225 **
1226 ** Description This function is called to process get test config response
1227 **
1228 ** Returns void
1229 **
1230 *******************************************************************************/
uwb_ucif_proc_test_get_config_status(uint8_t * p_buf,uint16_t len)1231 void uwb_ucif_proc_test_get_config_status(uint8_t* p_buf, uint16_t len) {
1232 tUWB_TEST_RESPONSE evt_data;
1233 tUWB_STATUS status;
1234 uint8_t* p = p_buf;
1235
1236 if (len == 0) {
1237 UCI_TRACE_E("%s: len is zero", __func__);
1238 return;
1239 }
1240 status = *p++;
1241 UCI_TRACE_I("Status:%s", UWB_GetStatusName(status));
1242 if (uwb_cb.p_resp_cback == NULL) {
1243 UCI_TRACE_E("%s: response callback is null", __func__);
1244 return;
1245 }
1246 evt_data.sTest_get_config.status = status;
1247 evt_data.sTest_get_config.no_of_ids = *p++;
1248 evt_data.sTest_get_config.tlv_size = (uint16_t)(len - CONFIG_TLV_OFFSET);
1249 if (evt_data.sTest_get_config.tlv_size > 0) {
1250 memcpy(evt_data.sTest_get_config.p_param_tlvs, p,
1251 evt_data.sTest_get_config.tlv_size);
1252 }
1253 (*uwb_cb.p_test_resp_cback)(UWB_TEST_GET_CONFIG_REVT, &evt_data);
1254 }
1255
1256 /*******************************************************************************
1257 **
1258 ** Function uwb_ucif_proc_test_set_config_status
1259 **
1260 ** Description This function is called to report UWB_SET_TEST_CONFIG_REVT
1261 **
1262 ** Returns void
1263 **
1264 *******************************************************************************/
uwb_ucif_proc_test_set_config_status(uint8_t * p_buf,uint16_t len)1265 void uwb_ucif_proc_test_set_config_status(uint8_t* p_buf, uint16_t len) {
1266 tUWB_TEST_RESPONSE evt_data;
1267 tUWB_STATUS status;
1268 uint8_t* p = p_buf;
1269
1270 if (len == 0) {
1271 UCI_TRACE_E("%s: len is zero", __func__);
1272 return;
1273 }
1274 status = *p++;
1275 UCI_TRACE_I("Status:%s", UWB_GetStatusName(status));
1276 if (uwb_cb.p_resp_cback == NULL) {
1277 UCI_TRACE_E("%s: response callback is null", __func__);
1278 return;
1279 }
1280 evt_data.sTest_set_config.status = status;
1281 evt_data.sTest_set_config.num_param_id = *p++;
1282 evt_data.sTest_set_config.tlv_size = (uint16_t)(len - CONFIG_TLV_OFFSET);
1283 if (evt_data.sTest_set_config.tlv_size > 0) {
1284 STREAM_TO_ARRAY(evt_data.sTest_set_config.param_ids, p,
1285 evt_data.sTest_set_config.tlv_size);
1286 }
1287 (*uwb_cb.p_test_resp_cback)(UWB_TEST_SET_CONFIG_REVT, &evt_data);
1288 }
1289
1290 /*******************************************************************************
1291 **
1292 ** Function uwb_ucif_test_management_status
1293 **
1294 ** Description This function is called to process test command responses
1295 **
1296 ** Returns void
1297 **
1298 *******************************************************************************/
uwb_ucif_test_management_status(tUWB_TEST_RESPONSE_EVT event,uint8_t * p_buf,uint16_t len)1299 void uwb_ucif_test_management_status(tUWB_TEST_RESPONSE_EVT event,
1300 uint8_t* p_buf, uint16_t len) {
1301 tUWB_TEST_RESPONSE evt_data;
1302 tUWB_TEST_RESPONSE_EVT evt = 0;
1303 tUWB_STATUS status;
1304 uint8_t* p = p_buf;
1305
1306 if (len == 0) {
1307 UCI_TRACE_E("%s: len is zero", __func__);
1308 return;
1309 }
1310 if (uwb_cb.p_resp_cback == NULL) {
1311 UCI_TRACE_E("%s: response callback is null", __func__);
1312 return;
1313 }
1314 status = *p++;
1315 UCI_TRACE_I("Status:%s", UWB_GetStatusName(status));
1316 switch (event) {
1317 case UWB_TEST_PERIODIC_TX_REVT:
1318 evt = UWB_TEST_PERIODIC_TX_REVT;
1319 evt_data.status = status;
1320 break;
1321 case UWB_TEST_PER_RX_REVT:
1322 evt = UWB_TEST_PER_RX_REVT;
1323 evt_data.status = status;
1324 break;
1325 case UWB_TEST_STOP_SESSION_REVT:
1326 evt = UWB_TEST_STOP_SESSION_REVT;
1327 evt_data.status = status;
1328 break;
1329 case UWB_TEST_LOOPBACK_REVT:
1330 evt = UWB_TEST_LOOPBACK_REVT;
1331 evt_data.status = status;
1332 break;
1333 case UWB_TEST_RX_REVT:
1334 evt = UWB_TEST_RX_REVT;
1335 evt_data.status = status;
1336 break;
1337 default:
1338 UCI_TRACE_E("unknown response event %x", event);
1339 }
1340 if (evt) {
1341 (*uwb_cb.p_test_resp_cback)(evt, &evt_data);
1342 }
1343 }
1344
1345 /*******************************************************************************
1346 **
1347 ** Function uwb_ucif_proc_rf_test_data
1348 **
1349 ** Description This function is called to report the RF test notifications
1350 **
1351 ** Returns void
1352 **
1353 *******************************************************************************/
uwb_ucif_proc_rf_test_data(tUWB_TEST_RESPONSE_EVT event,uint8_t * p_buf,uint16_t len)1354 void uwb_ucif_proc_rf_test_data(tUWB_TEST_RESPONSE_EVT event, uint8_t* p_buf,
1355 uint16_t len) {
1356 tUWB_RF_TEST_DATA rf_test_data;
1357 tUWB_TEST_RESPONSE uwb_response;
1358 if (len == 0) {
1359 UCI_TRACE_E("%s: len is zero", __func__);
1360 return;
1361 }
1362 if (uwb_cb.p_resp_cback == NULL) {
1363 UCI_TRACE_E("%s: response callback is null", __func__);
1364 return;
1365 }
1366 memset(&rf_test_data, 0, sizeof(tUWB_RF_TEST_DATA));
1367 rf_test_data.length = len;
1368 memcpy(&rf_test_data.data[0], p_buf, len);
1369 uwb_response.sRf_test_result = rf_test_data;
1370
1371 (*uwb_cb.p_test_resp_cback)(event, &uwb_response);
1372 }
1373
1374 /*******************************************************************************
1375 **
1376 ** Function uwb_ucif_event_status
1377 **
1378 ** Description This function is called to report the event
1379 **
1380 ** Returns void
1381 **
1382 *******************************************************************************/
uwb_ucif_event_status(tUWB_RESPONSE_EVT event,uint8_t status)1383 void uwb_ucif_event_status(tUWB_RESPONSE_EVT event, uint8_t status) {
1384 tUWB_RESPONSE uwb_response;
1385
1386 UCI_TRACE_E("Timeout error ");
1387 if (uwb_cb.p_resp_cback == NULL) {
1388 UCI_TRACE_E("%s: response callback is null", __func__);
1389 return;
1390 }
1391 uwb_response.status = status;
1392 (*uwb_cb.p_resp_cback)(event, &uwb_response);
1393 }
1394
1395 /*******************************************************************************
1396 **
1397 ** Function uwb_ucif_uwb_recovery
1398 **
1399 ** Description uwb recovery
1400 ** 1) spi reset
1401 ** 2) FW download
1402 **
1403 ** Returns void
1404 **
1405 *******************************************************************************/
uwb_ucif_uwb_recovery(void)1406 void uwb_ucif_uwb_recovery(void) {
1407 uint8_t stat;
1408 UCI_TRACE_I("uwb_ucif_uwb_recovery");
1409 if (uwb_cb.is_recovery_in_progress) {
1410 UCI_TRACE_I("uwb_ucif_uwb_recovery: recovery is already in progreess");
1411 return;
1412 }
1413 uwb_cb.cmd_retry_count = 0;
1414 uwb_cb.is_resp_pending = false;
1415 uwb_cb.is_recovery_in_progress = true;
1416
1417 if (uwb_cb.uwb_state == UWB_STATE_W4_HAL_CLOSE ||
1418 uwb_cb.uwb_state == UWB_STATE_NONE) {
1419 UCI_TRACE_E("%s: HAL is not initialized", __func__);
1420 uwb_cb.is_recovery_in_progress = false;
1421 return;
1422 }
1423 stat = uwb_cb.p_hal->CoreInitialization();
1424 if (stat == UWA_STATUS_OK) {
1425 UCI_TRACE_I("%s: uwb fw download successfull", __func__);
1426 } else {
1427 UCI_TRACE_E("%s: uwb fw download Failed", __func__);
1428 }
1429 uwb_main_flush_cmd_queue();
1430 uwb_cb.is_recovery_in_progress = false;
1431 }
1432