1
2 /******************************************************************************
3 *
4 * Copyright (C) 1999-2014 Broadcom Corporation
5 * Copyright 2018-2020 NXP
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at:
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 ******************************************************************************/
20 /******************************************************************************
21 *
22 * This file contains the action functions for device manager state
23 * machine.
24 *
25 ******************************************************************************/
26 #include <string.h>
27
28 #include "uci_hmsgs.h"
29 #include "uci_log.h"
30 #include "uwa_api.h"
31 #include "uwa_dm_int.h"
32 #include "uwa_sys.h"
33 #include "uwa_sys_int.h"
34 #include "uwb_api.h"
35 #include "uwb_osal_common.h"
36
37 static void uwa_dm_set_init_uci_params(void);
38
39 /*******************************************************************************
40 **
41 ** Function uwa_dm_sys_enable
42 **
43 ** Description This function on enable
44 **
45 ** Returns void
46 **
47 *******************************************************************************/
uwa_dm_sys_enable(void)48 void uwa_dm_sys_enable(void) { uwa_dm_set_init_uci_params(); }
49
50 /*******************************************************************************
51 **
52 ** Function uwa_dm_set_init_uci_params
53 **
54 ** Description Set initial UCI configuration parameters
55 **
56 ** Returns void
57 **
58 *******************************************************************************/
uwa_dm_set_init_uci_params(void)59 static void uwa_dm_set_init_uci_params(void) { return; }
60
61 /*******************************************************************************
62 **
63 ** Function uwa_dm_disable_event
64 **
65 ** Description report disable event
66 **
67 ** Returns void
68 **
69 *******************************************************************************/
uwa_dm_disable_event(void)70 static void uwa_dm_disable_event(void) {
71 /* Deregister DM from sys */
72 uwa_sys_deregister(UWA_ID_DM);
73
74 /* Notify app */
75 if (uwa_dm_cb.p_dm_cback != NULL) {
76 uwa_dm_cb.flags &= (uint32_t)(~UWA_DM_FLAGS_DM_IS_ACTIVE);
77 (*uwa_dm_cb.p_dm_cback)(UWA_DM_DISABLE_EVT, NULL);
78 }
79 }
80
81 /*******************************************************************************
82 **
83 ** Function uwa_dm_uwb_response_cback
84 **
85 ** Description Call DM event hanlder with UWB response callback data
86 **
87 ** Returns void
88 **
89 *******************************************************************************/
uwa_dm_uwb_response_cback(tUWB_RESPONSE_EVT event,tUWB_RESPONSE * p_data)90 static void uwa_dm_uwb_response_cback(tUWB_RESPONSE_EVT event,
91 tUWB_RESPONSE* p_data) {
92 tUWA_DM_CBACK_DATA dm_cback_data;
93
94 UCI_TRACE_I("uwa_dm_uwb_response_cback:%s(0x%x)",
95 uwa_dm_uwb_revt_2_str(event).c_str(), event);
96 switch (event) {
97 case UWB_ENABLE_REVT: /* 0 Enable event */
98 /* UWB stack enabled. Enable uwa sub-systems */
99 /* Notify app */
100 uwa_dm_cb.flags &= UWA_DM_FLAGS_DM_IS_ACTIVE;
101 dm_cback_data.status = p_data->enable.status;
102 (*uwa_dm_cb.p_dm_cback)(UWA_DM_ENABLE_EVT, &dm_cback_data);
103 break;
104
105 case UWB_DISABLE_REVT: /* 1 Disable event */
106 uwa_dm_disable_event();
107 break;
108
109 case UWB_DEVICE_STATUS_REVT: /* device status notification */
110 dm_cback_data.dev_status.status = p_data->sDevice_status.status;
111 (*uwa_dm_cb.p_dm_cback)(UWA_DM_DEVICE_STATUS_NTF_EVT, &dm_cback_data);
112 break;
113
114 case UWB_GET_DEVICE_INFO_REVT: {
115 if (p_data->sGet_device_info.status == UWB_STATUS_OK) {
116 dm_cback_data.sGet_device_info.status = UWA_STATUS_OK;
117 dm_cback_data.sGet_device_info.uci_version =
118 p_data->sGet_device_info.uci_version;
119 dm_cback_data.sGet_device_info.mac_version =
120 p_data->sGet_device_info.mac_version;
121 dm_cback_data.sGet_device_info.phy_version =
122 p_data->sGet_device_info.phy_version;
123 dm_cback_data.sGet_device_info.uciTest_version =
124 p_data->sGet_device_info.uciTest_version;
125 dm_cback_data.sGet_device_info.vendor_info_len =
126 p_data->sGet_device_info.vendor_info_len;
127 memcpy(dm_cback_data.sGet_device_info.vendor_info,
128 p_data->sGet_device_info.vendor_info,
129 p_data->sGet_device_info.vendor_info_len);
130 } else {
131 dm_cback_data.sGet_device_info.status = UWA_STATUS_FAILED;
132 }
133
134 (*uwa_dm_cb.p_dm_cback)(UWA_DM_CORE_GET_DEVICE_INFO_RSP_EVT,
135 &dm_cback_data);
136 } break;
137
138 case UWB_SET_CORE_CONFIG_REVT: /* 2 Set Config Response */
139 dm_cback_data.sCore_set_config.status = p_data->sCore_set_config.status;
140 dm_cback_data.sCore_set_config.num_param_id =
141 p_data->sCore_set_config.num_param_id;
142 dm_cback_data.sCore_set_config.tlv_size =
143 p_data->sCore_set_config.tlv_size;
144 if (dm_cback_data.sCore_set_config.tlv_size > 0) {
145 memcpy(dm_cback_data.sCore_set_config.param_ids,
146 p_data->sCore_set_config.param_ids,
147 p_data->sCore_set_config.tlv_size);
148 }
149 (*uwa_dm_cb.p_dm_cback)(UWA_DM_CORE_SET_CONFIG_RSP_EVT, &dm_cback_data);
150 break;
151
152 case UWB_GET_CORE_CONFIG_REVT: /* 3 Get Config Response */
153 dm_cback_data.sCore_get_config.status = p_data->sCore_get_config.status;
154 dm_cback_data.sCore_get_config.no_of_ids =
155 p_data->sCore_get_config.no_of_ids;
156 dm_cback_data.sCore_get_config.tlv_size =
157 p_data->sCore_get_config.tlv_size;
158 if (dm_cback_data.sCore_get_config.tlv_size > 0) {
159 memcpy(dm_cback_data.sCore_get_config.param_tlvs,
160 p_data->sCore_get_config.p_param_tlvs,
161 p_data->sCore_get_config.tlv_size);
162 }
163 (*uwa_dm_cb.p_dm_cback)(UWA_DM_CORE_GET_CONFIG_RSP_EVT, &dm_cback_data);
164 break;
165
166 case UWB_DEVICE_RESET_REVT: /* Device Reset Response */
167 if (p_data->sDevice_reset.status == UWB_STATUS_OK) {
168 dm_cback_data.sDevice_reset.status = p_data->sDevice_reset.status;
169 } else {
170 dm_cback_data.sDevice_reset.status = UWA_STATUS_FAILED;
171 }
172 (*uwa_dm_cb.p_dm_cback)(UWA_DM_DEVICE_RESET_RSP_EVT, &dm_cback_data);
173 break;
174
175 case UWB_CORE_GEN_ERR_STATUS_REVT: /* Generic error notification */
176 {
177 dm_cback_data.sCore_gen_err_status.status =
178 p_data->sCore_gen_err_status.status;
179 (*uwa_dm_cb.p_dm_cback)(UWA_DM_CORE_GEN_ERR_STATUS_EVT, &dm_cback_data);
180 } break;
181
182 case UWB_SESSION_INIT_REVT: /* Session init response */
183 if (p_data->status != UWB_STATUS_OK) {
184 UCI_TRACE_E(" Session Init request is failed");
185 }
186 dm_cback_data.status = p_data->status;
187 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_INIT_RSP_EVT, &dm_cback_data);
188 break;
189
190 case UWB_SESSION_DEINIT_REVT: /* session de-init response */
191 if (p_data->status != UWB_STATUS_OK) {
192 UCI_TRACE_E(" Session De Init request is failed");
193 }
194 dm_cback_data.status = p_data->status;
195 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_DEINIT_RSP_EVT, &dm_cback_data);
196 break;
197
198 case UWB_SESSION_STATUS_NTF_REVT: /* session status notification */
199 {
200 tUWA_SESSION_STATUS_NTF_REVT* p_session_ntf =
201 &dm_cback_data.sSessionStatus;
202 p_session_ntf->session_id = p_data->sSessionStatus.session_id;
203 p_session_ntf->state = p_data->sSessionStatus.state;
204 p_session_ntf->reason_code = p_data->sSessionStatus.reason_code;
205 if (UWB_SESSION_INITIALIZED == p_session_ntf->state) {
206 // Trigger session initialization HAL API.
207 tUWB_STATUS status;
208 status = UWB_HalSessionInit(dm_cback_data.sSessionStatus.session_id);
209 if (UWB_STATUS_OK == status) {
210 UCI_TRACE_I("HAL session init: success ,status=0x%X", status);
211 } else {
212 UCI_TRACE_E("HAL session init: status=0x%X. Deinitializing session", status);
213 p_session_ntf->state = UWB_SESSION_DEINITIALIZED;
214 }
215 }
216 }
217 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_STATUS_NTF_EVT, &dm_cback_data);
218 break;
219
220 case UWB_SESSION_GET_COUNT_REVT: /* get session count response */
221 if (p_data->status == UWB_STATUS_OK) {
222 tUWA_SESSION_GET_COUNT* p_sGet_session_cnt =
223 &dm_cback_data.sGet_session_cnt;
224 p_sGet_session_cnt->status = p_data->sGet_session_cnt.status;
225 p_sGet_session_cnt->count = p_data->sGet_session_cnt.count;
226
227 } else {
228 UCI_TRACE_E("Get session count command failed");
229 dm_cback_data.status = UWA_STATUS_FAILED;
230 }
231 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_GET_COUNT_RSP_EVT, &dm_cback_data);
232 break;
233
234 case UWB_SESSION_GET_STATE_REVT: /*get session state response */
235 if (p_data->sGet_session_state.status == UWB_STATUS_OK) {
236 tUWA_SESSION_GET_STATE* p_sGet_session_state =
237 &dm_cback_data.sGet_session_state;
238 p_sGet_session_state->status = p_data->sGet_session_state.status;
239 p_sGet_session_state->session_state =
240 p_data->sGet_session_state.session_state;
241
242 } else {
243 UCI_TRACE_E("Get session state command failed");
244 dm_cback_data.status = UWA_STATUS_FAILED;
245 }
246 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_GET_STATE_RSP_EVT, &dm_cback_data);
247 break;
248
249 case UWB_SET_APP_CONFIG_REVT: /*set session app config response */
250 dm_cback_data.sApp_set_config.status = p_data->sApp_set_config.status;
251 dm_cback_data.sApp_set_config.num_param_id =
252 p_data->sApp_set_config.num_param_id;
253 dm_cback_data.sApp_set_config.tlv_size = p_data->sApp_set_config.tlv_size;
254 if (dm_cback_data.sApp_set_config.tlv_size > 0) {
255 memcpy(dm_cback_data.sApp_set_config.param_ids,
256 p_data->sApp_set_config.param_ids,
257 p_data->sApp_set_config.tlv_size);
258 }
259 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_SET_CONFIG_RSP_EVT,
260 &dm_cback_data);
261 break;
262
263 case UWB_GET_APP_CONFIG_REVT: /*get session app config response */
264 dm_cback_data.sApp_get_config.status = p_data->sApp_get_config.status;
265 dm_cback_data.sApp_get_config.no_of_ids =
266 p_data->sApp_get_config.no_of_ids;
267 dm_cback_data.sApp_get_config.tlv_size = p_data->sApp_get_config.tlv_size;
268 if (dm_cback_data.sApp_get_config.tlv_size > 0) {
269 memcpy(dm_cback_data.sApp_get_config.param_tlvs,
270 p_data->sApp_get_config.p_param_tlvs,
271 p_data->sApp_get_config.tlv_size);
272 }
273 /* Return result of getAppConfig to the app */
274 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_GET_CONFIG_RSP_EVT,
275 &dm_cback_data);
276 break;
277
278 case UWB_START_RANGE_REVT: /* range start response */
279 if (p_data->status != UWB_STATUS_OK) {
280 UCI_TRACE_E("Range start command failed");
281 }
282 dm_cback_data.status = p_data->status;
283 (*uwa_dm_cb.p_dm_cback)(UWA_DM_RANGE_START_RSP_EVT, &dm_cback_data);
284 break;
285
286 case UWB_STOP_RANGE_REVT: /* range start response */
287 if (p_data->status != UWB_STATUS_OK) {
288 UCI_TRACE_E("Range stop command failed");
289 }
290 dm_cback_data.status = p_data->status;
291 (*uwa_dm_cb.p_dm_cback)(UWA_DM_RANGE_STOP_RSP_EVT, &dm_cback_data);
292 break;
293
294 case UWB_RANGE_DATA_REVT: /* range data notification */
295 {
296 tUWA_RANGE_DATA_NTF* p_sRange_data = &dm_cback_data.sRange_data;
297 memset(p_sRange_data, 0, sizeof(tUWA_RANGE_DATA_NTF));
298 if (p_data->sRange_data.range_data_len != 0) {
299 memcpy((uint8_t*)p_sRange_data, (uint8_t*)&p_data->sRange_data,
300 sizeof(tUWA_RANGE_DATA_NTF));
301 (*uwa_dm_cb.p_dm_cback)(UWA_DM_RANGE_DATA_NTF_EVT, &dm_cback_data);
302 }
303 } break;
304
305 case UWB_GET_RANGE_COUNT_REVT: /* get ranging round count response */
306 if (p_data->status == UWB_STATUS_OK) {
307 tUWA_RANGE_GET_RNG_COUNT_REVT* p_sGet_range_cnt =
308 &dm_cback_data.sGet_range_cnt;
309 p_sGet_range_cnt->status = p_data->sGet_range_cnt.status;
310 p_sGet_range_cnt->count = p_data->sGet_range_cnt.count;
311 } else {
312 UCI_TRACE_E("Get range count command failed");
313 }
314 dm_cback_data.status = p_data->status;
315 (*uwa_dm_cb.p_dm_cback)(UWA_DM_GET_RANGE_COUNT_RSP_EVT, &dm_cback_data);
316 break;
317
318 case UWB_CORE_GET_DEVICE_CAPABILITY_REVT: /* Core Get device capability
319 Response */
320 {
321 dm_cback_data.sGet_device_capability.status =
322 p_data->sGet_device_capability.status;
323 dm_cback_data.sGet_device_capability.no_of_tlvs =
324 p_data->sGet_device_capability.no_of_tlvs;
325 dm_cback_data.sGet_device_capability.tlv_buffer_len =
326 p_data->sGet_device_capability.tlv_buffer_len;
327 if (dm_cback_data.sGet_device_capability.tlv_buffer_len > 0) {
328 memcpy(dm_cback_data.sGet_device_capability.tlv_buffer,
329 p_data->sGet_device_capability.tlv_buffer,
330 p_data->sGet_device_capability.tlv_buffer_len);
331 }
332 /* Return result of core get device capability to the app */
333 (*uwa_dm_cb.p_dm_cback)(UWA_DM_GET_CORE_DEVICE_CAP_RSP_EVT,
334 &dm_cback_data);
335 } break;
336
337 case UWB_SESSION_UPDATE_MULTICAST_LIST_REVT: /* multi-cast list update
338 response*/
339 if (p_data->status != UWB_STATUS_OK) {
340 UCI_TRACE_E(" Session update multicast list request is failed");
341 }
342 dm_cback_data.status = p_data->status;
343 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_MC_LIST_UPDATE_RSP_EVT,
344 &dm_cback_data);
345 break;
346
347 case UWB_SESSION_UPDATE_MULTICAST_LIST_NTF_REVT: /* session update multicast
348 list data notification
349 */
350 {
351 tUWA_SESSION_UPDATE_MULTICAST_LIST_NTF* p_sMulticast_list_ntf =
352 &dm_cback_data.sMulticast_list_ntf;
353 memset(p_sMulticast_list_ntf, 0,
354 sizeof(tUWA_SESSION_UPDATE_MULTICAST_LIST_NTF));
355 memcpy((uint8_t*)p_sMulticast_list_ntf,
356 (uint8_t*)&p_data->sMulticast_list_ntf,
357 sizeof(tUWA_SESSION_UPDATE_MULTICAST_LIST_NTF));
358 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SESSION_MC_LIST_UPDATE_NTF_EVT,
359 &dm_cback_data);
360 } break;
361
362 case UWB_SET_COUNTRY_CODE_REVT: /* set country code response*/
363 if (p_data->status != UWB_STATUS_OK) {
364 UCI_TRACE_E(" Set country code request failed");
365 }
366 dm_cback_data.status = p_data->status;
367 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SET_COUNTRY_CODE_RSP_EVT,
368 &dm_cback_data);
369 break;
370
371 case UWB_BLINK_DATA_TX_REVT: /* blink data send response */
372 if (p_data->status != UWB_STATUS_OK) {
373 UCI_TRACE_E(" Blink data tx request is failed");
374 }
375 dm_cback_data.status = p_data->status;
376 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SEND_BLINK_DATA_RSP_EVT, &dm_cback_data);
377 break;
378
379 case UWB_BLINK_DATA_TX_NTF_REVT: /* blink data tx notification */
380 {
381 tUWA_SEND_BLINK_DATA_NTF* p_sBlink_data_ntf =
382 &dm_cback_data.sBlink_data_ntf;
383 p_sBlink_data_ntf->repetition_count_status =
384 p_data->sSend_blink_data_ntf.repetition_count_status;
385
386 (*uwa_dm_cb.p_dm_cback)(UWA_DM_SEND_BLINK_DATA_NTF_EVT, &dm_cback_data);
387 } break;
388
389 case UWB_CONFORMANCE_TEST_DATA: /* conformance test notification */
390 {
391 tUWA_CONFORMANCE_TEST_DATA* p_sConformance_data_ntf =
392 &dm_cback_data.sConformance_ntf;
393 p_sConformance_data_ntf->length = p_data->sConformance_test_data.length;
394 memcpy((uint8_t*)p_sConformance_data_ntf->data,
395 (uint8_t*)p_data->sConformance_test_data.data,
396 p_data->sConformance_test_data.length);
397 (*uwa_dm_cb.p_dm_cback)(UWA_DM_CONFORMANCE_NTF_EVT, &dm_cback_data);
398 } break;
399 case UWB_UWBS_RESP_TIMEOUT_REVT: /* event to notify response timeout */
400 {
401 dm_cback_data.status = UWB_STATUS_FAILED;
402 (*uwa_dm_cb.p_dm_cback)(UWA_DM_UWBS_RESP_TIMEOUT_EVT, &dm_cback_data);
403 } break;
404 case UWB_VENDOR_SPECIFIC_UCI_NTF_EVT:
405 {
406 dm_cback_data.sVendor_specific_ntf.len = p_data->sVendor_specific_ntf.len;
407 memcpy((uint8_t*)dm_cback_data.sVendor_specific_ntf.data, p_data->sVendor_specific_ntf.data, p_data->sVendor_specific_ntf.len);
408 (*uwa_dm_cb.p_dm_cback)(UWA_VENDOR_SPECIFIC_UCI_NTF_EVT, &dm_cback_data);
409 } break;
410 default:
411 UCI_TRACE_E("unknown event.");
412 break;
413 }
414 }
415
416 /*******************************************************************************
417 **
418 ** Function uwa_dm_uwb_test_response_cback
419 **
420 ** Description callback handles all RF test responses and notifications
421 **
422 ** Returns void
423 **
424 *******************************************************************************/
uwa_dm_uwb_test_response_cback(tUWB_TEST_RESPONSE_EVT event,tUWB_TEST_RESPONSE * p_data)425 static void uwa_dm_uwb_test_response_cback(tUWB_TEST_RESPONSE_EVT event,
426 tUWB_TEST_RESPONSE* p_data) {
427 tUWA_DM_TEST_CBACK_DATA dm_cback_data;
428
429 UCI_TRACE_I("uwa_dm_uwb_test_response_cback:%s(0x%x)",
430 uwa_test_dm_uwb_revt_2_str(event).c_str(), event);
431 switch (event) {
432 case UWB_TEST_SET_CONFIG_REVT: /* set test configs response */
433 dm_cback_data.sTest_set_config.status = p_data->sTest_set_config.status;
434 dm_cback_data.sTest_set_config.num_param_id =
435 p_data->sTest_set_config.num_param_id;
436 dm_cback_data.sTest_set_config.tlv_size =
437 p_data->sTest_set_config.tlv_size;
438 if (p_data->sTest_set_config.tlv_size > 0) {
439 memcpy(dm_cback_data.sTest_set_config.param_ids,
440 p_data->sTest_set_config.param_ids,
441 p_data->sTest_set_config.tlv_size);
442 }
443 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_SET_CONFIG_RSP_EVT,
444 &dm_cback_data);
445 break;
446
447 case UWB_TEST_GET_CONFIG_REVT: /* get test configs response */
448 dm_cback_data.sTest_get_config.status = p_data->sTest_get_config.status;
449 dm_cback_data.sTest_get_config.no_of_ids =
450 p_data->sTest_get_config.no_of_ids;
451 dm_cback_data.sTest_get_config.tlv_size =
452 p_data->sTest_get_config.tlv_size;
453 if (p_data->sTest_get_config.tlv_size > 0) {
454 memcpy(dm_cback_data.sTest_get_config.param_tlvs,
455 p_data->sTest_get_config.p_param_tlvs,
456 p_data->sTest_get_config.tlv_size);
457 }
458 /* Return result of getTestConfig to the app */
459 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_GET_CONFIG_RSP_EVT,
460 &dm_cback_data);
461 break;
462
463 case UWB_TEST_PERIODIC_TX_REVT: /* periodic tx response */
464 if (p_data->status != UWB_STATUS_OK) {
465 UCI_TRACE_E("per tx command failed");
466 }
467 dm_cback_data.status = p_data->status;
468 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_PERIODIC_TX_RSP_EVT,
469 &dm_cback_data);
470 break;
471
472 case UWB_TEST_PER_RX_REVT: /* per rx response */
473 if (p_data->status != UWB_STATUS_OK) {
474 UCI_TRACE_E("per rx command failed");
475 }
476 dm_cback_data.status = p_data->status;
477 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_PER_RX_RSP_EVT, &dm_cback_data);
478 break;
479
480 case UWB_TEST_LOOPBACK_REVT: /* rf loop back response */
481 if (p_data->status != UWB_STATUS_OK) {
482 UCI_TRACE_E("rf loop back command failed");
483 }
484 dm_cback_data.status = p_data->status;
485 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_LOOPBACK_RSP_EVT,
486 &dm_cback_data);
487 break;
488
489 case UWB_TEST_RX_REVT: /* rx test response */
490 if (p_data->status != UWB_STATUS_OK) {
491 UCI_TRACE_E("rx test command failed");
492 }
493 dm_cback_data.status = p_data->status;
494 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_RX_RSP_EVT, &dm_cback_data);
495 break;
496
497 case UWB_TEST_STOP_SESSION_REVT: /* per rx response */
498 if (p_data->status != UWB_STATUS_OK) {
499 UCI_TRACE_E("test stop command failed");
500 }
501 dm_cback_data.status = p_data->status;
502 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_STOP_SESSION_RSP_EVT,
503 &dm_cback_data);
504 break;
505
506 case UWB_TEST_PER_RX_DATA_REVT: /* PER test data notification */
507 {
508 tUWA_RF_TEST_DATA* p_per_rx_test_data = &dm_cback_data.rf_test_data;
509 if (p_data->sRf_test_result.length > 0) {
510 p_per_rx_test_data->length = p_data->sRf_test_result.length;
511 memcpy(&p_per_rx_test_data->data[0], &p_data->sRf_test_result.data[0],
512 p_per_rx_test_data->length);
513 }
514 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_PER_RX_NTF_EVT, &dm_cback_data);
515 } break;
516
517 case UWB_TEST_PERIODIC_TX_DATA_REVT: /* periodic Tx test data notification
518 */
519 {
520 tUWA_RF_TEST_DATA* p_rf_test_data = &dm_cback_data.rf_test_data;
521 if (p_data->sRf_test_result.length > 0) {
522 p_rf_test_data->length = p_data->sRf_test_result.length;
523 memcpy(&p_rf_test_data->data[0], &p_data->sRf_test_result.data[0],
524 p_rf_test_data->length);
525 }
526 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_PERIODIC_TX_NTF_EVT,
527 &dm_cback_data);
528 } break;
529
530 case UWB_TEST_LOOPBACK_DATA_REVT: /* loopback test data notification */
531 {
532 tUWA_RF_TEST_DATA* p_uwb_loopback_test_data = &dm_cback_data.rf_test_data;
533 if (p_data->sRf_test_result.length > 0) {
534 p_uwb_loopback_test_data->length = p_data->sRf_test_result.length;
535 memcpy(&p_uwb_loopback_test_data->data[0],
536 &p_data->sRf_test_result.data[0],
537 p_uwb_loopback_test_data->length);
538 }
539 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_LOOPBACK_NTF_EVT,
540 &dm_cback_data);
541 } break;
542
543 case UWB_TEST_RX_DATA_REVT: /* Rx test data notification */
544 {
545 tUWA_RF_TEST_DATA* p_uwb_rx_test_data = &dm_cback_data.rf_test_data;
546 if (p_data->sRf_test_result.length > 0) {
547 p_uwb_rx_test_data->length = p_data->sRf_test_result.length;
548 memcpy(&p_uwb_rx_test_data->data[0], &p_data->sRf_test_result.data[0],
549 p_uwb_rx_test_data->length);
550 }
551 (*uwa_dm_cb.p_dm_test_cback)(UWA_DM_TEST_RX_NTF_EVT, &dm_cback_data);
552 } break;
553
554 default:
555 UCI_TRACE_E("unknown event.");
556 break;
557 }
558 }
559
560 /*******************************************************************************
561 **
562 ** Function uwa_dm_enable
563 **
564 ** Description Initializes the UWB device manager
565 **
566 ** Returns true (message buffer to be freed by caller)
567 **
568 *******************************************************************************/
uwa_dm_enable(tUWA_DM_MSG * p_data)569 bool uwa_dm_enable(tUWA_DM_MSG* p_data) {
570 tUWA_DM_CBACK_DATA dm_cback_data;
571 UCI_TRACE_I("uwa_dm_enable ()");
572
573 /* Check if UWA is already enabled */
574 if (!(uwa_dm_cb.flags & UWA_DM_FLAGS_DM_IS_ACTIVE)) {
575 uwa_dm_cb.flags |=
576 (UWA_DM_FLAGS_DM_IS_ACTIVE | UWA_DM_FLAGS_ENABLE_EVT_PEND);
577
578 /* Store Enable parameters */
579 uwa_dm_cb.p_dm_cback = p_data->enable.p_dm_cback;
580 uwa_dm_cb.p_dm_test_cback = p_data->enable.p_dm_test_cback;
581 /* Enable UWB stack */
582 UWB_Enable(uwa_dm_uwb_response_cback, uwa_dm_uwb_test_response_cback);
583 } else {
584 UCI_TRACE_E("uwa_dm_enable: ERROR ALREADY ENABLED.");
585 dm_cback_data.status = UWA_STATUS_FAILED;
586 (*(p_data->enable.p_dm_cback))(UWA_DM_ENABLE_EVT, &dm_cback_data);
587 }
588
589 return (true);
590 }
591
592 /*******************************************************************************
593 **
594 ** Function uwa_dm_disable
595 **
596 ** Description Disables the UWB device manager
597 **
598 ** Returns true (message buffer to be freed by caller)
599 **
600 *******************************************************************************/
uwa_dm_disable(tUWA_DM_MSG * p_data)601 bool uwa_dm_disable(tUWA_DM_MSG* p_data) {
602 UCI_TRACE_I("uwa_dm_disable (): graceful:%d", p_data->disable.graceful);
603
604 /* Disable all subsystems other than DM (DM will be disabled after all */
605 /* the other subsystem have been disabled) */
606 uwa_sys_disable_subsystems(p_data->disable.graceful);
607
608 return (true);
609 }
610
611 /*******************************************************************************
612 **
613 ** Function uwa_dm_disable_complete
614 **
615 ** Description Called when all UWA subsytems are disabled.
616 **
617 ** UWB core stack can now be disabled.
618 **
619 ** Returns void
620 **
621 *******************************************************************************/
uwa_dm_disable_complete(void)622 void uwa_dm_disable_complete(void) {
623 UCI_TRACE_I("uwa_dm_disable_complete ()");
624 /* Disable uwb core stack */
625 UWB_Disable();
626 }
627
628 /*******************************************************************************
629 **
630 ** Function uwa_dm_act_get_device_info
631 **
632 ** Description Function to get the UWBS device information by issuing get
633 ** device UCI command
634 **
635 ** Returns FALSE (message buffer is NOT freed by caller)
636 **
637 *******************************************************************************/
uwa_dm_act_get_device_info(tUWA_DM_MSG * p_data)638 bool uwa_dm_act_get_device_info(tUWA_DM_MSG* p_data) {
639 tUWB_STATUS status;
640 if (p_data == NULL) {
641 UCI_TRACE_E("uwa_dm_act_get_device_info(): p_data is NULL)");
642 return false;
643 } else {
644 status = UWB_GetDeviceInfo();
645 if (UWB_STATUS_OK == status) {
646 UCI_TRACE_I("uwa_dm_act_get_device_info(): success ,status=0x%X", status);
647 } else {
648 UCI_TRACE_E("uwa_dm_act_get_device_info(): failed ,status=0x%X", status);
649 }
650 }
651 return true;
652 }
653
654 /*******************************************************************************
655 **
656 ** Function uwa_dm_set_core_config
657 **
658 ** Description Process set core config command
659 **
660 ** Returns true (message buffer to be freed by caller)
661 **
662 *******************************************************************************/
uwa_dm_set_core_config(tUWA_DM_MSG * p_data)663 bool uwa_dm_set_core_config(tUWA_DM_MSG* p_data) {
664 tUWB_STATUS status;
665 uint8_t buff[255];
666 uint8_t* p = buff;
667
668 tUWA_DM_CBACK_DATA dm_cback_data;
669
670 if (p_data->setconfig.length + 2 > 255) {
671 /* Total length of TLV must be less than 256 (1 byte) */
672 status = UWB_STATUS_FAILED;
673 } else {
674 UINT8_TO_STREAM(p, p_data->setconfig.param_id);
675 UINT8_TO_STREAM(p, p_data->setconfig.length);
676 ARRAY_TO_STREAM(p, p_data->setconfig.p_data, p_data->setconfig.length);
677
678 status = UWB_SetCoreConfig((uint8_t)(p_data->setconfig.length + 2), buff);
679 }
680
681 if (status != UWB_STATUS_OK) {
682 dm_cback_data.sCore_set_config.status = UWA_STATUS_INVALID_PARAM;
683 (*uwa_dm_cb.p_dm_cback)(UWA_DM_CORE_SET_CONFIG_RSP_EVT, &dm_cback_data);
684 }
685
686 return (true);
687 }
688
689 /*******************************************************************************
690 **
691 ** Function uwa_dm_get_core_config
692 **
693 ** Description Process get config command
694 **
695 ** Returns true (message buffer to be freed by caller)
696 **
697 *******************************************************************************/
uwa_dm_get_core_config(tUWA_DM_MSG * p_data)698 bool uwa_dm_get_core_config(tUWA_DM_MSG* p_data) {
699 UWB_GetCoreConfig(p_data->getconfig.num_ids, p_data->getconfig.p_pmids);
700
701 return (true);
702 }
703
704 /*******************************************************************************
705 **
706 ** Function uwa_dm_act_device_reset
707 **
708 ** Description Process core device reset command
709 **
710 ** Returns true (message buffer to be freed by caller)
711 **
712 *******************************************************************************/
uwa_dm_act_device_reset(tUWA_DM_MSG * pResetConfig)713 bool uwa_dm_act_device_reset(tUWA_DM_MSG* pResetConfig) {
714 tUWB_STATUS status;
715
716 if (pResetConfig == NULL) {
717 UCI_TRACE_E("uwa_dm_act_device_reset(): pResetConfig is NULL)");
718 } else {
719 status = UWB_DeviceResetCommand(pResetConfig->sDevice_reset.resetConfig);
720 if (UWB_STATUS_OK == status) {
721 UCI_TRACE_I("uwa_dm_act_device_reset(): success ,status=0x%X", status);
722 } else {
723 UCI_TRACE_E("uwa_dm_act_device_reset(): failed ,status=0x%X", status);
724 }
725 }
726
727 return (true);
728 }
729
730 /*******************************************************************************
731 **
732 ** Function uwa_dm_act_send_session_init
733 **
734 ** Description send session init command
735 **
736 ** Returns FALSE (message buffer is NOT freed by caller)
737 **
738 *******************************************************************************/
uwa_dm_act_send_session_init(tUWA_DM_MSG * p_data)739 bool uwa_dm_act_send_session_init(tUWA_DM_MSG* p_data) {
740 if (p_data == NULL) {
741 UCI_TRACE_E("uwa_dm_act_send_session_init(): p_data is NULL)");
742 return false;
743 } else {
744 UWB_SessionInit(p_data->sessionInit.session_id,
745 p_data->sessionInit.sessionType);
746 }
747 return true;
748 }
749 /*******************************************************************************
750 **
751 ** Function uwa_dm_act_send_session_deinit
752 **
753 ** Description send session de init command
754 **
755 ** Returns FALSE (message buffer is NOT freed by caller)
756 **
757 *******************************************************************************/
uwa_dm_act_send_session_deinit(tUWA_DM_MSG * p_data)758 bool uwa_dm_act_send_session_deinit(tUWA_DM_MSG* p_data) {
759 if (p_data == NULL) {
760 UCI_TRACE_E("uwa_dm_act_send_session_deinit(): p_data is NULL)");
761 return false;
762 } else {
763 UWB_SessionDeInit(p_data->sessionInit.session_id);
764 }
765 return true;
766 }
767
768 /*******************************************************************************
769 **
770 ** Function uwa_dm_act_get_session_count
771 **
772 ** Description send get session count to get no of active sessions
773 **
774 ** Returns FALSE (message buffer is NOT freed by caller)
775 **
776 *******************************************************************************/
uwa_dm_act_get_session_count(tUWA_DM_MSG * p_data)777 bool uwa_dm_act_get_session_count(tUWA_DM_MSG* p_data) {
778 tUWB_STATUS status;
779 if (p_data == NULL) {
780 UCI_TRACE_E("uwa_dm_act_get_session_count(): p_data is NULL)");
781 return false;
782 } else {
783 status = UWB_GetSessionCount();
784 if (UWB_STATUS_OK == status) {
785 UCI_TRACE_I("uwa_dm_act_get_session_count(): success ,status=0x%X",
786 status);
787 } else {
788 UCI_TRACE_E("uwa_dm_act_get_session_count(): failed ,status=0x%X",
789 status);
790 }
791 }
792 return true;
793 }
794
795 /*******************************************************************************
796 **
797 ** Function uwa_dm_act_app_set_config
798 **
799 ** Description Send set configurations command to set the app configuration
800 ** parameters
801 **
802 ** Returns true (message buffer to be freed by caller)
803 **
804 *******************************************************************************/
uwa_dm_act_app_set_config(tUWA_DM_MSG * p_data)805 bool uwa_dm_act_app_set_config(tUWA_DM_MSG* p_data) {
806 tUWB_STATUS status;
807
808 if (p_data->sApp_set_config.length + 2 > 255) {
809 /* Total length of TLV must be less than 256 (1 byte) */
810 status = UWB_STATUS_FAILED;
811 } else {
812 status = UWB_SetAppConfig(
813 p_data->sApp_set_config.session_id, p_data->sApp_set_config.num_ids,
814 p_data->sApp_set_config.length, p_data->sApp_set_config.p_data);
815 }
816
817 if (status != UWB_STATUS_OK) {
818 UCI_TRACE_E("uwa_dm_act_app_set_config(): failed ,status=0x%X", status);
819 } else {
820 UCI_TRACE_I("uwa_dm_act_app_set_config(): success ,status=0x%X", status);
821 }
822
823 return (true);
824 }
825
826 /*******************************************************************************
827 **
828 ** Function uwa_dm_act_app_get_config
829 **
830 ** Description Send get configurations command to get the app configuration
831 ** parameters
832 **
833 ** Returns true (message buffer to be freed by caller)
834 **
835 *******************************************************************************/
uwa_dm_act_app_get_config(tUWA_DM_MSG * p_data)836 bool uwa_dm_act_app_get_config(tUWA_DM_MSG* p_data) {
837 tUWB_STATUS status;
838
839 if (p_data == NULL) {
840 UCI_TRACE_E("uwa_dm_act_app_get_config(): p_data is NULL)");
841 } else {
842 status = UWB_GetAppConfig(
843 p_data->sApp_get_config.session_id, p_data->sApp_get_config.num_ids,
844 p_data->sApp_get_config.length, p_data->sApp_get_config.p_pmids);
845
846 if (UWB_STATUS_OK == status) {
847 UCI_TRACE_I("uwa_dm_act_app_get_config(): success ,status=0x%X", status);
848 } else {
849 UCI_TRACE_E("uwa_dm_act_app_get_config(): failed ,status=0x%X", status);
850 }
851 }
852 return (true);
853 }
854
855 /*******************************************************************************
856 **
857 ** Function uwa_dm_act_start_range_session
858 **
859 ** Description start the ranging session
860 **
861 ** Returns FALSE (message buffer is NOT freed by caller)
862 **
863 *******************************************************************************/
uwa_dm_act_start_range_session(tUWA_DM_MSG * p_data)864 bool uwa_dm_act_start_range_session(tUWA_DM_MSG* p_data) {
865 if (p_data == NULL) {
866 UCI_TRACE_E("uwa_dm_act_start_range_session(): p_data is NULL)");
867 } else {
868 UWB_StartRanging(p_data->rang_start.session_id);
869 }
870 return true;
871 }
872
873 /*******************************************************************************
874 **
875 ** Function uwa_dm_act_stop_range_session
876 **
877 ** Description stop the ranging session
878 **
879 ** Returns FALSE (message buffer is NOT freed by caller)
880 **
881 *******************************************************************************/
uwa_dm_act_stop_range_session(tUWA_DM_MSG * p_data)882 bool uwa_dm_act_stop_range_session(tUWA_DM_MSG* p_data) {
883 if (p_data == NULL) {
884 UCI_TRACE_E("uwa_dm_act_stop_range_session(): p_data is NULL");
885 } else {
886 UWB_StopRanging(p_data->rang_stop.session_id);
887 }
888 return true;
889 }
890
891 /*******************************************************************************
892 **
893 ** Function uwa_dm_act_send_raw_vs
894 **
895 ** Description Send the raw vs command to the UCI command queue
896 **
897 ** Returns FALSE (message buffer is NOT freed by caller)
898 **
899 *******************************************************************************/
uwa_dm_act_send_raw_cmd(tUWA_DM_MSG * p_data)900 bool uwa_dm_act_send_raw_cmd(tUWA_DM_MSG* p_data) {
901 UWB_HDR* p_cmd = (UWB_HDR*)p_data;
902
903 p_cmd->offset = sizeof(tUWA_DM_API_SEND_RAW) - UWB_HDR_SIZE;
904 p_cmd->len = p_data->send_raw.cmd_params_len;
905 UWB_SendRawCommand(p_cmd, p_data->send_raw.p_cback);
906
907 return false;
908 }
909
910 /*******************************************************************************
911 **
912 ** Function uwa_dm_act_get_range_count
913 **
914 ** Description Send the get range count command to the ranging count
915 **
916 ** Returns FALSE (message buffer is NOT freed by caller)
917 **
918 *******************************************************************************/
uwa_dm_act_get_range_count(tUWA_DM_MSG * p_data)919 bool uwa_dm_act_get_range_count(tUWA_DM_MSG* p_data) {
920 tUWB_STATUS status;
921
922 if (p_data == NULL) {
923 UCI_TRACE_E("uwa_dm_act_get_range_count(): p_data is NULL)");
924 } else {
925 status = UWB_GetRangingCount(p_data->sGet_rang_count.session_id);
926
927 if (UWB_STATUS_OK == status) {
928 UCI_TRACE_I("uwa_dm_act_get_range_count(): success ,status=0x%X", status);
929 } else {
930 UCI_TRACE_E("uwa_dm_act_get_range_count(): failed ,status=0x%X", status);
931 }
932 }
933 return (true);
934 }
935
936 /*******************************************************************************
937 **
938 ** Function uwa_dm_act_get_session_status
939 **
940 ** Description Send the get session status command to get the session
941 ** status
942 **
943 ** Returns FALSE (message buffer is NOT freed by caller)
944 **
945 *******************************************************************************/
uwa_dm_act_get_session_status(tUWA_DM_MSG * p_data)946 bool uwa_dm_act_get_session_status(tUWA_DM_MSG* p_data) {
947 tUWB_STATUS status;
948
949 if (p_data == NULL) {
950 UCI_TRACE_E("uwa_dm_act_get_session_status(): p_data is NULL)");
951 } else {
952 status = UWB_GetSessionStatus(p_data->sGet_session_status.session_id);
953
954 if (UWB_STATUS_OK == status) {
955 UCI_TRACE_I("uwa_dm_act_get_session_status(): success ,status=0x%X",
956 status);
957 } else {
958 UCI_TRACE_E("uwa_dm_act_get_session_status(): failed ,status=0x%X",
959 status);
960 }
961 }
962 return (true);
963 }
964
965 /*******************************************************************************
966 **
967 ** Function uwa_dm_act_get_device_capability
968 **
969 ** Description send get capability info command
970 **
971 ** Returns FALSE (message buffer is NOT freed by caller)
972 **
973 *******************************************************************************/
uwa_dm_act_get_device_capability(tUWA_DM_MSG * p_data)974 bool uwa_dm_act_get_device_capability(tUWA_DM_MSG* p_data) {
975 tUWB_STATUS status;
976 if (p_data == NULL) {
977 UCI_TRACE_E("uwa_dm_act_get_device_capability(): p_data is NULL)");
978 } else {
979 status = UWB_CoreGetDeviceCapability();
980 if (UWB_STATUS_OK == status) {
981 UCI_TRACE_I("uwa_dm_act_get_device_capability(): success ,status=0x%X",
982 status);
983 } else {
984 UCI_TRACE_E("uwa_dm_act_get_device_capability(): failed ,status=0x%X",
985 status);
986 }
987 }
988 return true;
989 }
990
991 /*******************************************************************************
992 **
993 ** Function uwa_dm_act_multicast_list_update
994 **
995 ** Description send controlee multicast list update command
996 **
997 ** Returns FALSE (message buffer is NOT freed by caller)
998 **
999 *******************************************************************************/
uwa_dm_act_multicast_list_update(tUWA_DM_MSG * p_data)1000 bool uwa_dm_act_multicast_list_update(tUWA_DM_MSG* p_data) {
1001 tUWB_STATUS status;
1002 if (p_data == NULL) {
1003 UCI_TRACE_E("uwa_dm_act_multicast_list_update(): p_data is NULL)");
1004 } else {
1005 status = UWB_MulticastListUpdate(
1006 p_data->sMulticast_list.session_id, p_data->sMulticast_list.action,
1007 p_data->sMulticast_list.no_of_controlee,
1008 p_data->sMulticast_list.short_address_list,
1009 p_data->sMulticast_list.subsession_id_list);
1010 if (UWB_STATUS_OK == status) {
1011 UCI_TRACE_I("uwa_dm_act_multicast_list_update(): success ,status=0x%X",
1012 status);
1013 } else {
1014 UCI_TRACE_E("uwa_dm_act_multicast_list_update(): failed ,status=0x%X",
1015 status);
1016 }
1017 }
1018 return true;
1019 }
1020
1021 /*******************************************************************************
1022 **
1023 ** Function uwa_dm_act_set_country_code
1024 **
1025 ** Description send country code set command.
1026 **
1027 ** Returns FALSE (message buffer is NOT freed by caller)
1028 **
1029 *******************************************************************************/
uwa_dm_act_set_country_code(tUWA_DM_MSG * p_data)1030 bool uwa_dm_act_set_country_code(tUWA_DM_MSG* p_data) {
1031 tUWB_STATUS status;
1032 if (p_data == NULL) {
1033 UCI_TRACE_E("uwa_dm_act_set_country_code(): p_data is NULL)");
1034 } else {
1035 status = UWB_SetCountryCode(p_data->sCountryCode.country_code);
1036 if (UWB_STATUS_OK == status) {
1037 UCI_TRACE_I("uwa_dm_act_set_country_code(): success ,status=0x%X",
1038 status);
1039 } else {
1040 UCI_TRACE_E("uwa_dm_set_country_code(): failed ,status=0x%X", status);
1041 }
1042 }
1043 return true;
1044 }
1045
1046 /*******************************************************************************
1047 **
1048 ** Function uwa_dm_act_send_blink_data
1049 **
1050 ** Description send blink data tx command
1051 **
1052 ** Returns FALSE (message buffer is NOT freed by caller)
1053 **
1054 *******************************************************************************/
uwa_dm_act_send_blink_data(tUWA_DM_MSG * p_data)1055 bool uwa_dm_act_send_blink_data(tUWA_DM_MSG* p_data) {
1056 tUWB_STATUS status;
1057 if (p_data == NULL) {
1058 UCI_TRACE_E("uwa_dm_act_send_blink_data(): p_data is NULL)");
1059 } else {
1060 status = UWB_SendBlinkData(p_data->sSend_blink_data.session_id,
1061 p_data->sSend_blink_data.repetition_count,
1062 p_data->sSend_blink_data.app_data_len,
1063 p_data->sSend_blink_data.app_data);
1064 if (UWB_STATUS_OK == status) {
1065 UCI_TRACE_I("uwa_dm_act_send_blink_data(): success ,status=0x%X", status);
1066 } else {
1067 UCI_TRACE_E("uwa_dm_act_send_blink_data(): failed ,status=0x%X", status);
1068 }
1069 }
1070 return true;
1071 }
1072 /* APIs for RF Test Functionality */
1073
1074 /*******************************************************************************
1075 **
1076 ** Function uwa_dm_act_test_set_config
1077 **
1078 ** Description Send set configurations command to set the test
1079 ** configuration parameters
1080 **
1081 ** Returns true (message buffer to be freed by caller)
1082 **
1083 *******************************************************************************/
uwa_dm_act_test_set_config(tUWA_DM_MSG * p_data)1084 bool uwa_dm_act_test_set_config(tUWA_DM_MSG* p_data) {
1085 tUWB_STATUS status;
1086
1087 if (p_data->sTest_set_config.length + 2 > UCI_MAX_PAYLOAD_SIZE) {
1088 /* Total length of TLV must be less than 256 (1 byte) */
1089 status = UWB_STATUS_FAILED;
1090 } else {
1091 status = UWB_SetTestConfig(
1092 p_data->sTest_set_config.session_id, p_data->sTest_set_config.num_ids,
1093 p_data->sTest_set_config.length, p_data->sTest_set_config.p_data);
1094 }
1095 if (status != UWB_STATUS_OK) {
1096 UCI_TRACE_E("uwa_dm_act_test_set_config(): failed ,status=0x%X", status);
1097 } else {
1098 UCI_TRACE_I("uwa_dm_act_test_set_config(): success ,status=0x%X", status);
1099 }
1100
1101 return (true);
1102 }
1103
1104 /*******************************************************************************
1105 **
1106 ** Function uwa_dm_act_test_get_config
1107 **
1108 ** Description Send get configurations command to get the test
1109 ** configuration parameters
1110 **
1111 ** Returns true (message buffer to be freed by caller)
1112 **
1113 *******************************************************************************/
uwa_dm_act_test_get_config(tUWA_DM_MSG * p_data)1114 bool uwa_dm_act_test_get_config(tUWA_DM_MSG* p_data) {
1115 tUWB_STATUS status;
1116
1117 if (p_data == NULL) {
1118 UCI_TRACE_E("uwa_dm_act_test_get_config(): p_data is NULL)");
1119 } else {
1120 status = UWB_TestGetConfig(
1121 p_data->sTest_get_config.session_id, p_data->sTest_get_config.num_ids,
1122 p_data->sTest_get_config.length, p_data->sTest_get_config.p_pmids);
1123
1124 if (UWB_STATUS_OK == status) {
1125 UCI_TRACE_I("uwa_dm_act_test_get_config(): success ,status=0x%X", status);
1126 } else {
1127 UCI_TRACE_E("uwa_dm_act_test_get_config(): failed ,status=0x%X", status);
1128 }
1129 }
1130 return (true);
1131 }
1132
1133 /*******************************************************************************
1134 **
1135 ** Function uwa_dm_act_test_periodic_tx
1136 **
1137 ** Description Send periodic tx command to start periodic Tx test
1138 **
1139 ** Returns true (message buffer to be freed by caller)
1140 **
1141 *******************************************************************************/
uwa_dm_act_test_periodic_tx(tUWA_DM_MSG * p_data)1142 bool uwa_dm_act_test_periodic_tx(tUWA_DM_MSG* p_data) {
1143 tUWB_STATUS status;
1144 if (p_data == NULL) {
1145 UCI_TRACE_E("uwa_dm_act_test_periodic_tx(): p_data is NULL)");
1146 } else {
1147 status = UWB_TestPeriodicTx(p_data->sPeriodic_tx.length,
1148 p_data->sPeriodic_tx.p_data);
1149
1150 if (UWB_STATUS_OK == status) {
1151 UCI_TRACE_I("uwa_dm_act_test_periodic_tx(): success ,status=0x%X",
1152 status);
1153 } else {
1154 UCI_TRACE_E("uwa_dm_act_test_periodic_tx(): failed ,status=0x%X", status);
1155 }
1156 }
1157 return (true);
1158 }
1159
1160 /*******************************************************************************
1161 **
1162 ** Function uwa_dm_act_test_per_rx
1163 **
1164 ** Description Send PER Rx command to start Packet error rate Rx test
1165 **
1166 ** Returns true (message buffer to be freed by caller)
1167 **
1168 *******************************************************************************/
uwa_dm_act_test_per_rx(tUWA_DM_MSG * p_data)1169 bool uwa_dm_act_test_per_rx(tUWA_DM_MSG* p_data) {
1170 tUWB_STATUS status;
1171 if (p_data == NULL) {
1172 UCI_TRACE_E("uwa_dm_act_test_per_rx(): p_data is NULL)");
1173 } else {
1174 status = UWB_TestPerRx(p_data->sPer_rx.length, p_data->sPer_rx.p_data);
1175
1176 if (UWB_STATUS_OK == status) {
1177 UCI_TRACE_I("uwa_dm_act_test_per_rx(): success ,status=0x%X", status);
1178 } else {
1179 UCI_TRACE_E("uwa_dm_act_test_per_rx(): failed ,status=0x%X", status);
1180 }
1181 }
1182 return (true);
1183 }
1184
1185 /*******************************************************************************
1186 **
1187 ** Function uwa_dm_act_test_uwb_loopback
1188 **
1189 ** Description Send Rf loop back command
1190 **
1191 ** Returns true (message buffer to be freed by caller)
1192 **
1193 *******************************************************************************/
uwa_dm_act_test_uwb_loopback(tUWA_DM_MSG * p_data)1194 bool uwa_dm_act_test_uwb_loopback(tUWA_DM_MSG* p_data) {
1195 tUWB_STATUS status;
1196 if (p_data == NULL) {
1197 UCI_TRACE_E("uwa_dm_act_test_uwb_loopback(): p_data is NULL)");
1198 } else {
1199 status = UWB_TestUwbLoopBack(p_data->sUwb_loopback.length,
1200 p_data->sUwb_loopback.p_data);
1201
1202 if (UWB_STATUS_OK == status) {
1203 UCI_TRACE_I("uwa_dm_act_test_uwb_loopback(): success ,status=0x%X",
1204 status);
1205 } else {
1206 UCI_TRACE_E("uwa_dm_act_test_uwb_loopback(): failed ,status=0x%X",
1207 status);
1208 }
1209 }
1210 return (true);
1211 }
1212
1213 /*******************************************************************************
1214 **
1215 ** Function uwa_dm_act_test_rx
1216 **
1217 ** Description Send Test Rx Command
1218 **
1219 ** Returns FALSE (message buffer is NOT freed by caller)
1220 **
1221 *******************************************************************************/
uwa_dm_act_test_rx(tUWA_DM_MSG * p_data)1222 bool uwa_dm_act_test_rx(tUWA_DM_MSG* p_data) {
1223 tUWB_STATUS status;
1224 if (p_data == NULL) {
1225 UCI_TRACE_E("uwa_dm_act_test_rx(): p_data is NULL)");
1226 return false;
1227 } else {
1228 status = UWB_TestRx();
1229 if (UWB_STATUS_OK == status) {
1230 UCI_TRACE_I("uwa_dm_act_test_rx(): success , status=0x%X", status);
1231 } else {
1232 UCI_TRACE_E("uwa_dm_act_test_rx(): failed , status=0x%X", status);
1233 }
1234 }
1235 return true;
1236 }
1237
1238 /*******************************************************************************
1239 **
1240 ** Function uwa_dm_act_test_stop_session
1241 **
1242 ** Description send test stop session command
1243 **
1244 ** Returns FALSE (message buffer is NOT freed by caller)
1245 **
1246 *******************************************************************************/
uwa_dm_act_test_stop_session(tUWA_DM_MSG * p_data)1247 bool uwa_dm_act_test_stop_session(tUWA_DM_MSG* p_data) {
1248 tUWB_STATUS status;
1249 if (p_data == NULL) {
1250 UCI_TRACE_E("uwa_dm_act_test_stop_session(): p_data is NULL)");
1251 return false;
1252 } else {
1253 status = UWB_TestStopSession();
1254 if (UWB_STATUS_OK == status) {
1255 UCI_TRACE_I("uwa_dm_act_test_stop_session(): success , status=0x%X",
1256 status);
1257 } else {
1258 UCI_TRACE_E("uwa_dm_act_test_stop_session(): failed , status=0x%X",
1259 status);
1260 }
1261 }
1262 return true;
1263 }
1264
1265 /*******************************************************************************
1266 **
1267 ** Function uwa_dm_uwb_revt_2_str
1268 **
1269 ** Description convert uwb revt to string
1270 **
1271 *******************************************************************************/
uwa_dm_uwb_revt_2_str(tUWB_RESPONSE_EVT event)1272 std::string uwa_dm_uwb_revt_2_str(tUWB_RESPONSE_EVT event) {
1273 switch (event) {
1274 case UWB_ENABLE_REVT:
1275 return "UWB_ENABLE_REVT";
1276
1277 case UWB_DISABLE_REVT:
1278 return "UWB_DISABLE_REVT";
1279
1280 case UWB_DEVICE_STATUS_REVT:
1281 return "UWB_DEVICE_STATUS_REVT";
1282
1283 case UWB_GET_DEVICE_INFO_REVT:
1284 return "UWB_GET_DEVICE_INFO_REVT";
1285
1286 case UWB_SET_CORE_CONFIG_REVT:
1287 return "UWB_SET_CORE_CONFIG_REVT";
1288
1289 case UWB_GET_CORE_CONFIG_REVT:
1290 return "UWB_GET_CORE_CONFIG_REVT";
1291
1292 case UWB_DEVICE_RESET_REVT:
1293 return "UWB_DEVICE_RESET_REVT";
1294
1295 case UWB_CORE_GEN_ERR_STATUS_REVT:
1296 return "UWB_CORE_GEN_ERR_STATUS_REVT";
1297
1298 case UWB_SESSION_INIT_REVT:
1299 return "UWB_SESSION_INIT_REVT";
1300
1301 case UWB_SESSION_DEINIT_REVT:
1302 return "UWB_SESSION_DEINIT_REVT";
1303
1304 case UWB_SESSION_STATUS_NTF_REVT:
1305 return "UWB_SESSION_STATUS_NTF_REVT";
1306
1307 case UWB_SESSION_GET_COUNT_REVT:
1308 return "UWB_SESSION_GET_COUNT_REVT";
1309
1310 case UWB_SESSION_GET_STATE_REVT:
1311 return "UWB_SESSION_GET_STATE_REVT";
1312
1313 case UWB_GET_APP_CONFIG_REVT:
1314 return "UWB_GET_APP_CONFIG_REVT";
1315
1316 case UWB_SET_APP_CONFIG_REVT:
1317 return "UWB_SET_APP_CONFIG_REVT";
1318
1319 case UWB_START_RANGE_REVT:
1320 return "UWB_START_RANGE_REVT";
1321
1322 case UWB_STOP_RANGE_REVT:
1323 return "UWB_STOP_RANGE_REVT";
1324
1325 case UWB_RANGE_DATA_REVT:
1326 return "UWB_RANGE_DATA_REVT";
1327
1328 case UWB_GET_RANGE_COUNT_REVT:
1329 return "UWB_GET_RANGE_COUNT_REVT";
1330
1331 case UWB_CORE_GET_DEVICE_CAPABILITY_REVT:
1332 return "UWB_CORE_GET_DEVICE_CAPABILITY_REVT";
1333
1334 case UWB_SESSION_UPDATE_MULTICAST_LIST_REVT:
1335 return "UWB_SESSION_UPDATE_MULTICAST_LIST_REVT";
1336
1337 case UWB_SESSION_UPDATE_MULTICAST_LIST_NTF_REVT:
1338 return "UWB_SESSION_UPDATE_MULTICAST_LIST_NTF_REVT";
1339
1340 case UWB_SET_COUNTRY_CODE_REVT:
1341 return "UWB_SET_COUNTRY_CODE_REVT";
1342
1343 case UWB_BLINK_DATA_TX_REVT:
1344 return "UWB_BLINK_DATA_TX_REVT";
1345
1346 case UWB_BLINK_DATA_TX_NTF_REVT:
1347 return "UWB_BLINK_DATA_TX_NTF_REVT";
1348
1349 case UWB_CONFORMANCE_TEST_DATA:
1350 return "UWB_CONFORMANCE_TEST_DATA";
1351
1352 case UWB_VENDOR_SPECIFIC_UCI_NTF_EVT:
1353 return "UWB_VENDOR_SPECIfIC_UCI_NTF_EVT";
1354
1355 default:
1356 return "unknown revt";
1357 break;
1358 }
1359 }
1360
1361 /*******************************************************************************
1362 **
1363 ** Function uwa_test_dm_uwb_revt_2_str
1364 **
1365 ** Description convert uwb revt to string for RF test events
1366 **
1367 *******************************************************************************/
uwa_test_dm_uwb_revt_2_str(tUWB_TEST_RESPONSE_EVT event)1368 std::string uwa_test_dm_uwb_revt_2_str(tUWB_TEST_RESPONSE_EVT event) {
1369 switch (event) {
1370 case UWB_TEST_GET_CONFIG_REVT:
1371 return "UWB_TEST_GET_CONFIG_REVT";
1372
1373 case UWB_TEST_SET_CONFIG_REVT:
1374 return "UWB_TEST_SET_CONFIG_REVT";
1375
1376 case UWB_TEST_PERIODIC_TX_DATA_REVT:
1377 return "UWB_TEST_PERIODIC_TX_DATA_REVT";
1378
1379 case UWB_TEST_PER_RX_DATA_REVT:
1380 return "UWB_TEST_PER_RX_DATA_REVT";
1381
1382 case UWB_TEST_PERIODIC_TX_REVT:
1383 return "UWB_TEST_PERIODIC_TX_REVT";
1384
1385 case UWB_TEST_PER_RX_REVT:
1386 return "UWB_TEST_PER_RX_REVT";
1387
1388 case UWB_TEST_STOP_SESSION_REVT:
1389 return "UWB_TEST_STOP_SESSION_REVT";
1390
1391 case UWB_TEST_LOOPBACK_DATA_REVT:
1392 return "UWB_TEST_LOOPBACK_DATA_REVT";
1393
1394 case UWB_TEST_LOOPBACK_REVT:
1395 return "UWB_TEST_LOOPBACK_REVT";
1396
1397 case UWB_TEST_RX_REVT:
1398 return "UWB_TEST_RX_REVT";
1399
1400 case UWB_TEST_RX_DATA_REVT:
1401 return "UWB_TEST_RX_DATA_REVT";
1402
1403 default:
1404 return "unknown revt";
1405 break;
1406 }
1407 }
1408