1 /*
2 * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <string.h>
8 #include <errno.h>
9
10 #include "btc_ble_mesh_health_model.h"
11 #include "foundation.h"
12 #include "esp_ble_mesh_health_model_api.h"
13
14 #if CONFIG_BLE_MESH_HEALTH_CLI
15 #include "health_cli.h"
16
17 /* Health Client Model related functions */
18
btc_ble_mesh_health_client_cb_to_app(esp_ble_mesh_health_client_cb_event_t event,esp_ble_mesh_health_client_cb_param_t * param)19 static inline void btc_ble_mesh_health_client_cb_to_app(esp_ble_mesh_health_client_cb_event_t event,
20 esp_ble_mesh_health_client_cb_param_t *param)
21 {
22 esp_ble_mesh_health_client_cb_t btc_ble_mesh_cb =
23 (esp_ble_mesh_health_client_cb_t)btc_profile_cb_get(BTC_PID_HEALTH_CLIENT);
24 if (btc_ble_mesh_cb) {
25 btc_ble_mesh_cb(event, param);
26 }
27 }
28
btc_ble_mesh_health_client_arg_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)29 void btc_ble_mesh_health_client_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
30 {
31 btc_ble_mesh_health_client_args_t *dst = (btc_ble_mesh_health_client_args_t *)p_dest;
32 btc_ble_mesh_health_client_args_t *src = (btc_ble_mesh_health_client_args_t *)p_src;
33
34 if (!msg || !dst || !src) {
35 BT_ERR("%s, Invalid parameter", __func__);
36 return;
37 }
38
39 switch (msg->act) {
40 case BTC_BLE_MESH_ACT_HEALTH_CLIENT_GET_STATE: {
41 dst->health_client_get_state.params = (esp_ble_mesh_client_common_param_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_client_common_param_t));
42 if (dst->health_client_get_state.params) {
43 memcpy(dst->health_client_get_state.params, src->health_client_get_state.params,
44 sizeof(esp_ble_mesh_client_common_param_t));
45 } else {
46 BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
47 break;
48 }
49 if (src->health_client_get_state.get_state) {
50 dst->health_client_get_state.get_state = (esp_ble_mesh_health_client_get_state_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_health_client_get_state_t));
51 if (dst->health_client_get_state.get_state) {
52 memcpy(dst->health_client_get_state.get_state, src->health_client_get_state.get_state,
53 sizeof(esp_ble_mesh_health_client_get_state_t));
54 } else {
55 BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
56 }
57 }
58 break;
59 }
60 case BTC_BLE_MESH_ACT_HEALTH_CLIENT_SET_STATE: {
61 dst->health_client_set_state.params = (esp_ble_mesh_client_common_param_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_client_common_param_t));
62 dst->health_client_set_state.set_state = (esp_ble_mesh_health_client_set_state_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_health_client_set_state_t));
63 if (dst->health_client_set_state.params && dst->health_client_set_state.set_state) {
64 memcpy(dst->health_client_set_state.params, src->health_client_set_state.params,
65 sizeof(esp_ble_mesh_client_common_param_t));
66 memcpy(dst->health_client_set_state.set_state, src->health_client_set_state.set_state,
67 sizeof(esp_ble_mesh_health_client_set_state_t));
68 } else {
69 BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
70 }
71 break;
72 }
73 default:
74 BT_DBG("%s, Unknown act %d", __func__, msg->act);
75 break;
76 }
77 }
78
btc_ble_mesh_health_client_arg_deep_free(btc_msg_t * msg)79 void btc_ble_mesh_health_client_arg_deep_free(btc_msg_t *msg)
80 {
81 btc_ble_mesh_health_client_args_t *arg = NULL;
82
83 if (!msg) {
84 BT_ERR("%s, Invalid parameter", __func__);
85 return;
86 }
87
88 arg = (btc_ble_mesh_health_client_args_t *)(msg->arg);
89
90 switch (msg->act) {
91 case BTC_BLE_MESH_ACT_HEALTH_CLIENT_GET_STATE:
92 if (arg->health_client_get_state.params) {
93 bt_mesh_free(arg->health_client_get_state.params);
94 }
95 if (arg->health_client_get_state.get_state) {
96 bt_mesh_free(arg->health_client_get_state.get_state);
97 }
98 break;
99 case BTC_BLE_MESH_ACT_HEALTH_CLIENT_SET_STATE:
100 if (arg->health_client_set_state.params) {
101 bt_mesh_free(arg->health_client_set_state.params);
102 }
103 if (arg->health_client_set_state.set_state) {
104 bt_mesh_free(arg->health_client_set_state.set_state);
105 }
106 break;
107 default:
108 break;
109 }
110 }
111
btc_ble_mesh_health_client_copy_req_data(btc_msg_t * msg,void * p_dest,void * p_src)112 static void btc_ble_mesh_health_client_copy_req_data(btc_msg_t *msg, void *p_dest, void *p_src)
113 {
114 esp_ble_mesh_health_client_cb_param_t *p_dest_data = (esp_ble_mesh_health_client_cb_param_t *)p_dest;
115 esp_ble_mesh_health_client_cb_param_t *p_src_data = (esp_ble_mesh_health_client_cb_param_t *)p_src;
116 uint16_t length = 0U;
117
118 if (!msg || !p_src_data || !p_dest_data) {
119 BT_ERR("%s, Invalid parameter", __func__);
120 return;
121 }
122
123 if (p_src_data->params) {
124 p_dest_data->params = bt_mesh_malloc(sizeof(esp_ble_mesh_client_common_param_t));
125 if (!p_dest_data->params) {
126 BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
127 return;
128 }
129
130 memcpy(p_dest_data->params, p_src_data->params, sizeof(esp_ble_mesh_client_common_param_t));
131 }
132
133 switch (msg->act) {
134 case ESP_BLE_MESH_HEALTH_CLIENT_GET_STATE_EVT:
135 case ESP_BLE_MESH_HEALTH_CLIENT_SET_STATE_EVT:
136 case ESP_BLE_MESH_HEALTH_CLIENT_PUBLISH_EVT:
137 if (p_src_data->params) {
138 switch (p_src_data->params->opcode) {
139 case OP_HEALTH_CURRENT_STATUS:
140 if (p_src_data->status_cb.current_status.fault_array) {
141 length = p_src_data->status_cb.current_status.fault_array->len;
142 p_dest_data->status_cb.current_status.fault_array = bt_mesh_alloc_buf(length);
143 if (!p_dest_data->status_cb.current_status.fault_array) {
144 BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
145 return;
146 }
147 net_buf_simple_add_mem(p_dest_data->status_cb.current_status.fault_array,
148 p_src_data->status_cb.current_status.fault_array->data,
149 p_src_data->status_cb.current_status.fault_array->len);
150 }
151 break;
152 case OP_HEALTH_FAULT_GET:
153 case OP_HEALTH_FAULT_CLEAR:
154 case OP_HEALTH_FAULT_TEST:
155 case OP_HEALTH_FAULT_STATUS:
156 if (p_src_data->status_cb.fault_status.fault_array) {
157 length = p_src_data->status_cb.fault_status.fault_array->len;
158 p_dest_data->status_cb.fault_status.fault_array = bt_mesh_alloc_buf(length);
159 if (!p_dest_data->status_cb.fault_status.fault_array) {
160 BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
161 return;
162 }
163 net_buf_simple_add_mem(p_dest_data->status_cb.fault_status.fault_array,
164 p_src_data->status_cb.fault_status.fault_array->data,
165 p_src_data->status_cb.fault_status.fault_array->len);
166 }
167 break;
168 default:
169 break;
170 }
171 }
172 case ESP_BLE_MESH_HEALTH_CLIENT_TIMEOUT_EVT:
173 break;
174 default:
175 break;
176 }
177 }
178
btc_ble_mesh_health_client_free_req_data(btc_msg_t * msg)179 static void btc_ble_mesh_health_client_free_req_data(btc_msg_t *msg)
180 {
181 esp_ble_mesh_health_client_cb_param_t *arg = NULL;
182
183 if (!msg) {
184 BT_ERR("%s, Invalid parameter", __func__);
185 return;
186 }
187
188 arg = (esp_ble_mesh_health_client_cb_param_t *)(msg->arg);
189
190 switch (msg->act) {
191 case ESP_BLE_MESH_HEALTH_CLIENT_GET_STATE_EVT:
192 case ESP_BLE_MESH_HEALTH_CLIENT_SET_STATE_EVT:
193 case ESP_BLE_MESH_HEALTH_CLIENT_PUBLISH_EVT:
194 if (arg->params) {
195 switch (arg->params->opcode) {
196 case OP_HEALTH_CURRENT_STATUS:
197 bt_mesh_free_buf(arg->status_cb.current_status.fault_array);
198 break;
199 case OP_HEALTH_FAULT_GET:
200 case OP_HEALTH_FAULT_CLEAR:
201 case OP_HEALTH_FAULT_TEST:
202 case OP_HEALTH_FAULT_STATUS:
203 bt_mesh_free_buf(arg->status_cb.fault_status.fault_array);
204 break;
205 default:
206 break;
207 }
208 }
209 case ESP_BLE_MESH_HEALTH_CLIENT_TIMEOUT_EVT:
210 if (arg->params) {
211 bt_mesh_free(arg->params);
212 }
213 break;
214 default:
215 break;
216 }
217 }
218
btc_ble_mesh_health_client_callback(esp_ble_mesh_health_client_cb_param_t * cb_params,uint8_t act)219 static void btc_ble_mesh_health_client_callback(esp_ble_mesh_health_client_cb_param_t *cb_params, uint8_t act)
220 {
221 btc_msg_t msg = {0};
222
223 BT_DBG("%s", __func__);
224
225 /* If corresponding callback is not registered, event will not be posted. */
226 if (!btc_profile_cb_get(BTC_PID_HEALTH_CLIENT)) {
227 return;
228 }
229
230 msg.sig = BTC_SIG_API_CB;
231 msg.pid = BTC_PID_HEALTH_CLIENT;
232 msg.act = act;
233
234 btc_transfer_context(&msg, cb_params, cb_params == NULL ? 0 : sizeof(esp_ble_mesh_health_client_cb_param_t),
235 btc_ble_mesh_health_client_copy_req_data, btc_ble_mesh_health_client_free_req_data);
236 }
237
bt_mesh_health_client_cb_evt_to_btc(uint32_t opcode,uint8_t evt_type,struct bt_mesh_model * model,struct bt_mesh_msg_ctx * ctx,const uint8_t * val,uint16_t len)238 void bt_mesh_health_client_cb_evt_to_btc(uint32_t opcode, uint8_t evt_type,
239 struct bt_mesh_model *model,
240 struct bt_mesh_msg_ctx *ctx,
241 const uint8_t *val, uint16_t len)
242 {
243 esp_ble_mesh_health_client_cb_param_t cb_params = {0};
244 esp_ble_mesh_client_common_param_t params = {0};
245 uint8_t act = 0U;
246
247 if (!model || !ctx) {
248 BT_ERR("%s, Invalid parameter", __func__);
249 return;
250 }
251
252 switch (evt_type) {
253 case BTC_BLE_MESH_EVT_HEALTH_CLIENT_GET_STATE:
254 act = ESP_BLE_MESH_HEALTH_CLIENT_GET_STATE_EVT;
255 break;
256 case BTC_BLE_MESH_EVT_HEALTH_CLIENT_SET_STATE:
257 act = ESP_BLE_MESH_HEALTH_CLIENT_SET_STATE_EVT;
258 break;
259 case BTC_BLE_MESH_EVT_HEALTH_CLIENT_PUBLISH:
260 act = ESP_BLE_MESH_HEALTH_CLIENT_PUBLISH_EVT;
261 break;
262 case BTC_BLE_MESH_EVT_HEALTH_CLIENT_TIMEOUT:
263 act = ESP_BLE_MESH_HEALTH_CLIENT_TIMEOUT_EVT;
264 break;
265 default:
266 BT_ERR("Unknown Health client event type %d", evt_type);
267 return;
268 }
269
270 params.opcode = opcode;
271 params.model = (esp_ble_mesh_model_t *)model;
272 params.ctx.net_idx = ctx->net_idx;
273 params.ctx.app_idx = ctx->app_idx;
274 params.ctx.addr = ctx->addr;
275 params.ctx.recv_ttl = ctx->recv_ttl;
276 params.ctx.recv_op = ctx->recv_op;
277 params.ctx.recv_dst = ctx->recv_dst;
278 params.ctx.recv_rssi = ctx->recv_rssi;
279 params.ctx.send_ttl = ctx->send_ttl;
280
281 cb_params.error_code = 0;
282 cb_params.params = ¶ms;
283
284 if (val && len) {
285 memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb)));
286 }
287
288 btc_ble_mesh_health_client_callback(&cb_params, act);
289 return;
290 }
291
btc_ble_mesh_health_publish_callback(uint32_t opcode,struct bt_mesh_model * model,struct bt_mesh_msg_ctx * ctx,struct net_buf_simple * buf)292 void btc_ble_mesh_health_publish_callback(uint32_t opcode, struct bt_mesh_model *model,
293 struct bt_mesh_msg_ctx *ctx,
294 struct net_buf_simple *buf)
295 {
296 if (!model || !ctx || !buf) {
297 BT_ERR("%s, Invalid parameter", __func__);
298 return;
299 }
300
301 bt_mesh_health_client_cb_evt_to_btc(opcode, BTC_BLE_MESH_EVT_HEALTH_CLIENT_PUBLISH,
302 model, ctx, buf->data, buf->len);
303 return;
304 }
305
btc_ble_mesh_health_client_get_state(esp_ble_mesh_client_common_param_t * params,esp_ble_mesh_health_client_get_state_t * get)306 static int btc_ble_mesh_health_client_get_state(esp_ble_mesh_client_common_param_t *params,
307 esp_ble_mesh_health_client_get_state_t *get)
308 {
309 bt_mesh_client_common_param_t param = {0};
310
311 if (params == NULL) {
312 BT_ERR("%s, Invalid parameter", __func__);
313 return -EINVAL;
314 }
315
316 if (params->opcode == ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_GET && get == NULL) {
317 BT_ERR("Invalid Health Get");
318 return -EINVAL;
319 }
320
321 param.opcode = params->opcode;
322 param.model = (struct bt_mesh_model *)params->model;
323 param.ctx.net_idx = params->ctx.net_idx;
324 param.ctx.app_idx = params->ctx.app_idx;
325 param.ctx.addr = params->ctx.addr;
326 param.ctx.send_rel = params->ctx.send_rel;
327 param.ctx.send_ttl = params->ctx.send_ttl;
328 param.msg_timeout = params->msg_timeout;
329 param.msg_role = params->msg_role;
330
331 switch (param.opcode) {
332 case ESP_BLE_MESH_MODEL_OP_ATTENTION_GET:
333 return bt_mesh_health_attention_get(¶m);
334 case ESP_BLE_MESH_MODEL_OP_HEALTH_PERIOD_GET:
335 return bt_mesh_health_period_get(¶m);
336 case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_GET:
337 return bt_mesh_health_fault_get(¶m, get->fault_get.company_id);
338 default:
339 BT_ERR("Invalid Health Get opcode 0x%04x", param.opcode);
340 return -EINVAL;
341 }
342
343 return 0;
344 }
345
btc_ble_mesh_health_client_set_state(esp_ble_mesh_client_common_param_t * params,esp_ble_mesh_health_client_set_state_t * set)346 static int btc_ble_mesh_health_client_set_state(esp_ble_mesh_client_common_param_t *params,
347 esp_ble_mesh_health_client_set_state_t *set)
348 {
349 bt_mesh_client_common_param_t param = {0};
350
351 if (params == NULL || set == NULL) {
352 BT_ERR("%s, Invalid parameter", __func__);
353 return -EINVAL;
354 }
355
356 param.opcode = params->opcode;
357 param.model = (struct bt_mesh_model *)params->model;
358 param.ctx.net_idx = params->ctx.net_idx;
359 param.ctx.app_idx = params->ctx.app_idx;
360 param.ctx.addr = params->ctx.addr;
361 param.ctx.send_rel = params->ctx.send_rel;
362 param.ctx.send_ttl = params->ctx.send_ttl;
363 param.msg_timeout = params->msg_timeout;
364 param.msg_role = params->msg_role;
365
366 switch (param.opcode) {
367 case ESP_BLE_MESH_MODEL_OP_ATTENTION_SET:
368 return bt_mesh_health_attention_set(¶m, set->attention_set.attention, true);
369 case ESP_BLE_MESH_MODEL_OP_ATTENTION_SET_UNACK:
370 return bt_mesh_health_attention_set(¶m, set->attention_set.attention, false);
371 case ESP_BLE_MESH_MODEL_OP_HEALTH_PERIOD_SET:
372 return bt_mesh_health_period_set(¶m, set->period_set.fast_period_divisor, true);
373 case ESP_BLE_MESH_MODEL_OP_HEALTH_PERIOD_SET_UNACK:
374 return bt_mesh_health_period_set(¶m, set->period_set.fast_period_divisor, false);
375 case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_TEST:
376 return bt_mesh_health_fault_test(¶m, set->fault_test.company_id, set->fault_test.test_id, true);
377 case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_TEST_UNACK:
378 return bt_mesh_health_fault_test(¶m, set->fault_test.company_id, set->fault_test.test_id, false);
379 case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_CLEAR:
380 return bt_mesh_health_fault_clear(¶m, set->fault_clear.company_id, true);
381 case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_CLEAR_UNACK:
382 return bt_mesh_health_fault_clear(¶m, set->fault_clear.company_id, false);
383 default:
384 BT_ERR("Invalid Health Set opcode 0x%04x", param.opcode);
385 return -EINVAL;
386 }
387
388 return 0;
389 }
390
btc_ble_mesh_health_client_call_handler(btc_msg_t * msg)391 void btc_ble_mesh_health_client_call_handler(btc_msg_t *msg)
392 {
393 btc_ble_mesh_health_client_args_t *arg = NULL;
394 esp_ble_mesh_health_client_cb_param_t cb = {0};
395
396 if (!msg) {
397 BT_ERR("%s, Invalid parameter", __func__);
398 return;
399 }
400
401 arg = (btc_ble_mesh_health_client_args_t *)(msg->arg);
402
403 switch (msg->act) {
404 case BTC_BLE_MESH_ACT_HEALTH_CLIENT_GET_STATE: {
405 cb.params = arg->health_client_get_state.params;
406 cb.error_code = btc_ble_mesh_health_client_get_state(arg->health_client_get_state.params,
407 arg->health_client_get_state.get_state);
408 if (cb.error_code) {
409 /* If send failed, callback error_code to app layer immediately */
410 btc_ble_mesh_health_client_callback(&cb, ESP_BLE_MESH_HEALTH_CLIENT_GET_STATE_EVT);
411 }
412 break;
413 }
414 case BTC_BLE_MESH_ACT_HEALTH_CLIENT_SET_STATE: {
415 cb.params = arg->health_client_set_state.params;
416 cb.error_code = btc_ble_mesh_health_client_set_state(arg->health_client_set_state.params,
417 arg->health_client_set_state.set_state);
418 if (cb.error_code) {
419 /* If send failed, callback error_code to app layer immediately */
420 btc_ble_mesh_health_client_callback(&cb, ESP_BLE_MESH_HEALTH_CLIENT_SET_STATE_EVT);
421 }
422 break;
423 }
424 default:
425 break;
426 }
427
428 btc_ble_mesh_health_client_arg_deep_free(msg);
429 return;
430 }
431
btc_ble_mesh_health_client_cb_handler(btc_msg_t * msg)432 void btc_ble_mesh_health_client_cb_handler(btc_msg_t *msg)
433 {
434 esp_ble_mesh_health_client_cb_param_t *param = NULL;
435
436 if (!msg) {
437 BT_ERR("%s, Invalid parameter", __func__);
438 return;
439 }
440
441 param = (esp_ble_mesh_health_client_cb_param_t *)(msg->arg);
442
443 if (msg->act < ESP_BLE_MESH_HEALTH_CLIENT_EVT_MAX) {
444 btc_ble_mesh_health_client_cb_to_app(msg->act, param);
445 } else {
446 BT_ERR("%s, Unknown act %d", __func__, msg->act);
447 }
448
449 btc_ble_mesh_health_client_free_req_data(msg);
450 return;
451 }
452
453 #endif /* CONFIG_BLE_MESH_HEALTH_CLI */
454
455 #if CONFIG_BLE_MESH_HEALTH_SRV
456 #include "health_srv.h"
457
458 /* Health Server Model related functions */
459
btc_ble_mesh_health_server_cb_to_app(esp_ble_mesh_health_server_cb_event_t event,esp_ble_mesh_health_server_cb_param_t * param)460 static inline void btc_ble_mesh_health_server_cb_to_app(esp_ble_mesh_health_server_cb_event_t event,
461 esp_ble_mesh_health_server_cb_param_t *param)
462 {
463 esp_ble_mesh_health_server_cb_t btc_ble_mesh_cb =
464 (esp_ble_mesh_health_server_cb_t)btc_profile_cb_get(BTC_PID_HEALTH_SERVER);
465 if (btc_ble_mesh_cb) {
466 btc_ble_mesh_cb(event, param);
467 }
468 }
469
btc_ble_mesh_health_server_arg_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)470 void btc_ble_mesh_health_server_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
471 {
472 if (!msg) {
473 BT_ERR("%s, Invalid parameter", __func__);
474 return;
475 }
476
477 switch (msg->act) {
478 case BTC_BLE_MESH_ACT_HEALTH_SERVER_FAULT_UPDATE:
479 break;
480 default:
481 break;
482 }
483 }
484
btc_ble_mesh_health_server_arg_deep_free(btc_msg_t * msg)485 static void btc_ble_mesh_health_server_arg_deep_free(btc_msg_t *msg)
486 {
487 if (!msg) {
488 BT_ERR("%s, Invalid parameter", __func__);
489 return;
490 }
491
492 switch (msg->act) {
493 case BTC_BLE_MESH_ACT_HEALTH_SERVER_FAULT_UPDATE:
494 break;
495 default:
496 break;
497 }
498 }
499
btc_ble_mesh_health_server_copy_req_data(btc_msg_t * msg,void * p_dest,void * p_src)500 static void btc_ble_mesh_health_server_copy_req_data(btc_msg_t *msg, void *p_dest, void *p_src)
501 {
502 if (!msg) {
503 BT_ERR("%s, Invalid parameter", __func__);
504 return;
505 }
506
507 switch (msg->act) {
508 case ESP_BLE_MESH_HEALTH_SERVER_FAULT_UPDATE_COMP_EVT:
509 break;
510 default:
511 break;
512 }
513 }
514
btc_ble_mesh_health_server_free_req_data(btc_msg_t * msg)515 static void btc_ble_mesh_health_server_free_req_data(btc_msg_t *msg)
516 {
517 if (!msg) {
518 BT_ERR("%s, Invalid parameter", __func__);
519 return;
520 }
521
522 switch (msg->act) {
523 case ESP_BLE_MESH_HEALTH_SERVER_FAULT_UPDATE_COMP_EVT:
524 break;
525 default:
526 break;
527 }
528 }
529
btc_ble_mesh_health_server_callback(esp_ble_mesh_health_server_cb_param_t * cb_params,uint8_t act)530 static void btc_ble_mesh_health_server_callback(esp_ble_mesh_health_server_cb_param_t *cb_params, uint8_t act)
531 {
532 btc_msg_t msg = {0};
533
534 BT_DBG("%s", __func__);
535
536 /* If corresponding callback is not registered, event will not be posted. */
537 if (!btc_profile_cb_get(BTC_PID_HEALTH_SERVER)) {
538 return;
539 }
540
541 msg.sig = BTC_SIG_API_CB;
542 msg.pid = BTC_PID_HEALTH_SERVER;
543 msg.act = act;
544
545 btc_transfer_context(&msg, cb_params, cb_params == NULL ? 0 : sizeof(esp_ble_mesh_health_server_cb_param_t),
546 btc_ble_mesh_health_server_copy_req_data, btc_ble_mesh_health_server_free_req_data);
547 }
548
btc_ble_mesh_health_server_call_handler(btc_msg_t * msg)549 void btc_ble_mesh_health_server_call_handler(btc_msg_t *msg)
550 {
551 esp_ble_mesh_health_server_cb_param_t param = {0};
552 btc_ble_mesh_health_server_args_t *arg = NULL;
553
554 if (!msg) {
555 BT_ERR("%s, Invalid parameter", __func__);
556 return;
557 }
558
559 arg = (btc_ble_mesh_health_server_args_t *)(msg->arg);
560
561 switch (msg->act) {
562 case BTC_BLE_MESH_ACT_HEALTH_SERVER_FAULT_UPDATE:
563 param.fault_update_comp.element = arg->health_fault_update.element;
564 param.fault_update_comp.error_code =
565 bt_mesh_fault_update((struct bt_mesh_elem *)arg->health_fault_update.element);
566 btc_ble_mesh_health_server_callback(¶m, ESP_BLE_MESH_HEALTH_SERVER_FAULT_UPDATE_COMP_EVT);
567 break;
568 default:
569 break;
570 }
571
572 btc_ble_mesh_health_server_arg_deep_free(msg);
573 return;
574 }
575
btc_ble_mesh_health_server_cb_handler(btc_msg_t * msg)576 void btc_ble_mesh_health_server_cb_handler(btc_msg_t *msg)
577 {
578 esp_ble_mesh_health_server_cb_param_t *param = NULL;
579
580 if (!msg) {
581 BT_ERR("%s, Invalid parameter", __func__);
582 return;
583 }
584
585 param = (esp_ble_mesh_health_server_cb_param_t *)(msg->arg);
586
587 if (msg->act < ESP_BLE_MESH_HEALTH_SERVER_EVT_MAX) {
588 btc_ble_mesh_health_server_cb_to_app(msg->act, param);
589 } else {
590 BT_ERR("%s, Unknown act %d", __func__, msg->act);
591 }
592
593 btc_ble_mesh_health_server_free_req_data(msg);
594 return;
595 }
596
btc_ble_mesh_health_server_fault_clear(struct bt_mesh_model * model,uint16_t company_id)597 void btc_ble_mesh_health_server_fault_clear(struct bt_mesh_model *model, uint16_t company_id)
598 {
599 esp_ble_mesh_health_server_cb_param_t param = {0};
600
601 param.fault_clear.model = (esp_ble_mesh_model_t *)model;
602 param.fault_clear.company_id = company_id;
603
604 btc_ble_mesh_health_server_callback(¶m, ESP_BLE_MESH_HEALTH_SERVER_FAULT_CLEAR_EVT);
605 }
606
btc_ble_mesh_health_server_fault_test(struct bt_mesh_model * model,uint8_t test_id,uint16_t company_id)607 void btc_ble_mesh_health_server_fault_test(struct bt_mesh_model *model,
608 uint8_t test_id, uint16_t company_id)
609 {
610 esp_ble_mesh_health_server_cb_param_t param = {0};
611
612 param.fault_test.model = (esp_ble_mesh_model_t *)model;
613 param.fault_test.test_id = test_id;
614 param.fault_test.company_id = company_id;
615
616 btc_ble_mesh_health_server_callback(¶m, ESP_BLE_MESH_HEALTH_SERVER_FAULT_TEST_EVT);
617 }
618
btc_ble_mesh_health_server_attention_on(struct bt_mesh_model * model,uint8_t time)619 void btc_ble_mesh_health_server_attention_on(struct bt_mesh_model *model, uint8_t time)
620 {
621 esp_ble_mesh_health_server_cb_param_t param = {0};
622
623 param.attention_on.model = (esp_ble_mesh_model_t *)model;
624 param.attention_on.time = time;
625
626 btc_ble_mesh_health_server_callback(¶m, ESP_BLE_MESH_HEALTH_SERVER_ATTENTION_ON_EVT);
627 }
628
btc_ble_mesh_health_server_attention_off(struct bt_mesh_model * model)629 void btc_ble_mesh_health_server_attention_off(struct bt_mesh_model *model)
630 {
631 esp_ble_mesh_health_server_cb_param_t param = {0};
632
633 param.attention_off.model = (esp_ble_mesh_model_t *)model;
634
635 btc_ble_mesh_health_server_callback(¶m, ESP_BLE_MESH_HEALTH_SERVER_ATTENTION_OFF_EVT);
636 }
637 #endif /* CONFIG_BLE_MESH_HEALTH_SRV */
638
