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_sensor_model.h"
11 #include "esp_ble_mesh_sensor_model_api.h"
12 
13 #if CONFIG_BLE_MESH_SENSOR_CLI
14 #include "sensor_client.h"
15 
16 /* Sensor Client Models related functions */
17 
btc_ble_mesh_sensor_client_cb_to_app(esp_ble_mesh_sensor_client_cb_event_t event,esp_ble_mesh_sensor_client_cb_param_t * param)18 static inline void btc_ble_mesh_sensor_client_cb_to_app(esp_ble_mesh_sensor_client_cb_event_t event,
19                                                         esp_ble_mesh_sensor_client_cb_param_t *param)
20 {
21     esp_ble_mesh_sensor_client_cb_t btc_ble_mesh_cb =
22         (esp_ble_mesh_sensor_client_cb_t)btc_profile_cb_get(BTC_PID_SENSOR_CLIENT);
23     if (btc_ble_mesh_cb) {
24         btc_ble_mesh_cb(event, param);
25     }
26 }
27 
btc_ble_mesh_sensor_client_arg_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)28 void btc_ble_mesh_sensor_client_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
29 {
30     btc_ble_mesh_sensor_client_args_t *dst = (btc_ble_mesh_sensor_client_args_t *)p_dest;
31     btc_ble_mesh_sensor_client_args_t *src = (btc_ble_mesh_sensor_client_args_t *)p_src;
32     uint16_t length = 0U;
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_SENSOR_CLIENT_GET_STATE: {
41         dst->sensor_client_get_state.params = (esp_ble_mesh_client_common_param_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_client_common_param_t));
42         dst->sensor_client_get_state.get_state = (esp_ble_mesh_sensor_client_get_state_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_sensor_client_get_state_t));
43         if (dst->sensor_client_get_state.params && dst->sensor_client_get_state.get_state) {
44             memcpy(dst->sensor_client_get_state.params, src->sensor_client_get_state.params,
45                    sizeof(esp_ble_mesh_client_common_param_t));
46             memcpy(dst->sensor_client_get_state.get_state, src->sensor_client_get_state.get_state,
47                    sizeof(esp_ble_mesh_sensor_client_get_state_t));
48 
49             switch (src->sensor_client_get_state.params->opcode) {
50             case ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_GET:
51                 if (src->sensor_client_get_state.get_state->column_get.raw_value_x) {
52                     length = src->sensor_client_get_state.get_state->column_get.raw_value_x->len;
53                     dst->sensor_client_get_state.get_state->column_get.raw_value_x = bt_mesh_alloc_buf(length);
54                     if (!dst->sensor_client_get_state.get_state->column_get.raw_value_x) {
55                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
56                         return;
57                     }
58                     net_buf_simple_add_mem(dst->sensor_client_get_state.get_state->column_get.raw_value_x,
59                                            src->sensor_client_get_state.get_state->column_get.raw_value_x->data,
60                                            src->sensor_client_get_state.get_state->column_get.raw_value_x->len);
61                 }
62                 break;
63             case ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_GET:
64                 if (src->sensor_client_get_state.get_state->series_get.raw_value_x1) {
65                     length = src->sensor_client_get_state.get_state->series_get.raw_value_x1->len;
66                     dst->sensor_client_get_state.get_state->series_get.raw_value_x1 = bt_mesh_alloc_buf(length);
67                     if (!dst->sensor_client_get_state.get_state->series_get.raw_value_x1) {
68                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
69                         return;
70                     }
71                     net_buf_simple_add_mem(dst->sensor_client_get_state.get_state->series_get.raw_value_x1,
72                                            src->sensor_client_get_state.get_state->series_get.raw_value_x1->data,
73                                            src->sensor_client_get_state.get_state->series_get.raw_value_x1->len);
74                 }
75                 if (src->sensor_client_get_state.get_state->series_get.raw_value_x2) {
76                     length = src->sensor_client_get_state.get_state->series_get.raw_value_x2->len;
77                     dst->sensor_client_get_state.get_state->series_get.raw_value_x2 = bt_mesh_alloc_buf(length);
78                     if (!dst->sensor_client_get_state.get_state->series_get.raw_value_x2) {
79                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
80                         return;
81                     }
82                     net_buf_simple_add_mem(dst->sensor_client_get_state.get_state->series_get.raw_value_x2,
83                                            src->sensor_client_get_state.get_state->series_get.raw_value_x2->data,
84                                            src->sensor_client_get_state.get_state->series_get.raw_value_x2->len);
85                 }
86                 break;
87             default:
88                 break;
89             }
90         } else {
91             BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
92         }
93         break;
94     }
95     case BTC_BLE_MESH_ACT_SENSOR_CLIENT_SET_STATE: {
96         dst->sensor_client_set_state.params = (esp_ble_mesh_client_common_param_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_client_common_param_t));
97         dst->sensor_client_set_state.set_state = (esp_ble_mesh_sensor_client_set_state_t *)bt_mesh_malloc(sizeof(esp_ble_mesh_sensor_client_set_state_t));
98         if (dst->sensor_client_set_state.params && dst->sensor_client_set_state.set_state) {
99             memcpy(dst->sensor_client_set_state.params, src->sensor_client_set_state.params,
100                    sizeof(esp_ble_mesh_client_common_param_t));
101             memcpy(dst->sensor_client_set_state.set_state, src->sensor_client_set_state.set_state,
102                    sizeof(esp_ble_mesh_sensor_client_set_state_t));
103 
104             switch (src->sensor_client_set_state.params->opcode) {
105             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET:
106                 if (src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down) {
107                     length = src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down->len;
108                     dst->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down = bt_mesh_alloc_buf(length);
109                     if (!dst->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down) {
110                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
111                         return;
112                     }
113                     net_buf_simple_add_mem(dst->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down,
114                                            src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down->data,
115                                            src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down->len);
116                 }
117                 if (src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up) {
118                     length = src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up->len;
119                     dst->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up = bt_mesh_alloc_buf(length);
120                     if (!dst->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up) {
121                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
122                         return;
123                     }
124                     net_buf_simple_add_mem(dst->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up,
125                                            src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up->data,
126                                            src->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up->len);
127                 }
128                 if (src->sensor_client_set_state.set_state->cadence_set.fast_cadence_low) {
129                     length = src->sensor_client_set_state.set_state->cadence_set.fast_cadence_low->len;
130                     dst->sensor_client_set_state.set_state->cadence_set.fast_cadence_low = bt_mesh_alloc_buf(length);
131                     if (!dst->sensor_client_set_state.set_state->cadence_set.fast_cadence_low) {
132                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
133                         return;
134                     }
135                     net_buf_simple_add_mem(dst->sensor_client_set_state.set_state->cadence_set.fast_cadence_low,
136                                            src->sensor_client_set_state.set_state->cadence_set.fast_cadence_low->data,
137                                            src->sensor_client_set_state.set_state->cadence_set.fast_cadence_low->len);
138                 }
139                 if (src->sensor_client_set_state.set_state->cadence_set.fast_cadence_high) {
140                     length = src->sensor_client_set_state.set_state->cadence_set.fast_cadence_high->len;
141                     dst->sensor_client_set_state.set_state->cadence_set.fast_cadence_high = bt_mesh_alloc_buf(length);
142                     if (!dst->sensor_client_set_state.set_state->cadence_set.fast_cadence_high) {
143                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
144                         return;
145                     }
146                     net_buf_simple_add_mem(dst->sensor_client_set_state.set_state->cadence_set.fast_cadence_high,
147                                            src->sensor_client_set_state.set_state->cadence_set.fast_cadence_high->data,
148                                            src->sensor_client_set_state.set_state->cadence_set.fast_cadence_high->len);
149                 }
150                 break;
151             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET:
152                 if (src->sensor_client_set_state.set_state->setting_set.sensor_setting_raw) {
153                     length = src->sensor_client_set_state.set_state->setting_set.sensor_setting_raw->len;
154                     dst->sensor_client_set_state.set_state->setting_set.sensor_setting_raw = bt_mesh_alloc_buf(length);
155                     if (!dst->sensor_client_set_state.set_state->setting_set.sensor_setting_raw) {
156                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
157                         return;
158                     }
159                     net_buf_simple_add_mem(dst->sensor_client_set_state.set_state->setting_set.sensor_setting_raw,
160                                            src->sensor_client_set_state.set_state->setting_set.sensor_setting_raw->data,
161                                            src->sensor_client_set_state.set_state->setting_set.sensor_setting_raw->len);
162                 }
163                 break;
164             default:
165                 break;
166             }
167         } else {
168             BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
169         }
170         break;
171     }
172     default:
173         BT_DBG("%s, Unknown act %d", __func__, msg->act);
174         break;
175     }
176 }
177 
btc_ble_mesh_sensor_client_arg_deep_free(btc_msg_t * msg)178 void btc_ble_mesh_sensor_client_arg_deep_free(btc_msg_t *msg)
179 {
180     btc_ble_mesh_sensor_client_args_t *arg = NULL;
181 
182     if (!msg) {
183         BT_ERR("%s, Invalid parameter", __func__);
184         return;
185     }
186 
187     arg = (btc_ble_mesh_sensor_client_args_t *)(msg->arg);
188 
189     switch (msg->act) {
190     case BTC_BLE_MESH_ACT_SENSOR_CLIENT_GET_STATE:
191         if (arg->sensor_client_get_state.get_state) {
192             if (arg->sensor_client_get_state.params) {
193                 switch (arg->sensor_client_get_state.params->opcode) {
194                 case ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_GET:
195                     bt_mesh_free_buf(arg->sensor_client_get_state.get_state->column_get.raw_value_x);
196                     break;
197                 case ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_GET:
198                     bt_mesh_free_buf(arg->sensor_client_get_state.get_state->series_get.raw_value_x1);
199                     bt_mesh_free_buf(arg->sensor_client_get_state.get_state->series_get.raw_value_x2);
200                     break;
201                 default:
202                     break;
203                 }
204             }
205             bt_mesh_free(arg->sensor_client_get_state.get_state);
206         }
207         if (arg->sensor_client_get_state.params) {
208             bt_mesh_free(arg->sensor_client_get_state.params);
209         }
210         break;
211     case BTC_BLE_MESH_ACT_SENSOR_CLIENT_SET_STATE:
212         if (arg->sensor_client_set_state.set_state) {
213             if (arg->sensor_client_set_state.params) {
214                 switch (arg->sensor_client_set_state.params->opcode) {
215                 case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET:
216                     bt_mesh_free_buf(arg->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_down);
217                     bt_mesh_free_buf(arg->sensor_client_set_state.set_state->cadence_set.status_trigger_delta_up);
218                     bt_mesh_free_buf(arg->sensor_client_set_state.set_state->cadence_set.fast_cadence_low);
219                     bt_mesh_free_buf(arg->sensor_client_set_state.set_state->cadence_set.fast_cadence_high);
220                     break;
221                 case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET:
222                     bt_mesh_free_buf(arg->sensor_client_set_state.set_state->setting_set.sensor_setting_raw);
223                     break;
224                 default:
225                     break;
226                 }
227             }
228             bt_mesh_free(arg->sensor_client_set_state.set_state);
229         }
230         if (arg->sensor_client_set_state.params) {
231             bt_mesh_free(arg->sensor_client_set_state.params);
232         }
233         break;
234     default:
235         break;
236     }
237 }
238 
btc_ble_mesh_sensor_client_copy_req_data(btc_msg_t * msg,void * p_dest,void * p_src)239 static void btc_ble_mesh_sensor_client_copy_req_data(btc_msg_t *msg, void *p_dest, void *p_src)
240 {
241     esp_ble_mesh_sensor_client_cb_param_t *p_dest_data = (esp_ble_mesh_sensor_client_cb_param_t *)p_dest;
242     esp_ble_mesh_sensor_client_cb_param_t *p_src_data = (esp_ble_mesh_sensor_client_cb_param_t *)p_src;
243     uint16_t length = 0U;
244 
245     if (!msg || !p_src_data || !p_dest_data) {
246         BT_ERR("%s, Invalid parameter", __func__);
247         return;
248     }
249 
250     if (p_src_data->params) {
251         p_dest_data->params = bt_mesh_malloc(sizeof(esp_ble_mesh_client_common_param_t));
252         if (!p_dest_data->params) {
253             BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
254             return;
255         }
256 
257         memcpy(p_dest_data->params, p_src_data->params, sizeof(esp_ble_mesh_client_common_param_t));
258     }
259 
260     switch (msg->act) {
261     case ESP_BLE_MESH_SENSOR_CLIENT_GET_STATE_EVT:
262     case ESP_BLE_MESH_SENSOR_CLIENT_SET_STATE_EVT:
263     case ESP_BLE_MESH_SENSOR_CLIENT_PUBLISH_EVT:
264         if (p_src_data->params) {
265             switch (p_src_data->params->opcode) {
266             case ESP_BLE_MESH_MODEL_OP_SENSOR_DESCRIPTOR_GET:
267             case ESP_BLE_MESH_MODEL_OP_SENSOR_DESCRIPTOR_STATUS:
268                 if (p_src_data->status_cb.descriptor_status.descriptor) {
269                     length = p_src_data->status_cb.descriptor_status.descriptor->len;
270                     p_dest_data->status_cb.descriptor_status.descriptor = bt_mesh_alloc_buf(length);
271                     if (!p_dest_data->status_cb.descriptor_status.descriptor) {
272                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
273                         return;
274                     }
275                     net_buf_simple_add_mem(p_dest_data->status_cb.descriptor_status.descriptor,
276                                            p_src_data->status_cb.descriptor_status.descriptor->data,
277                                            p_src_data->status_cb.descriptor_status.descriptor->len);
278                 }
279                 break;
280             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_GET:
281             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET:
282             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_STATUS:
283                 if (p_src_data->status_cb.cadence_status.sensor_cadence_value) {
284                     length = p_src_data->status_cb.cadence_status.sensor_cadence_value->len;
285                     p_dest_data->status_cb.cadence_status.sensor_cadence_value = bt_mesh_alloc_buf(length);
286                     if (!p_dest_data->status_cb.cadence_status.sensor_cadence_value) {
287                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
288                         return;
289                     }
290                     net_buf_simple_add_mem(p_dest_data->status_cb.cadence_status.sensor_cadence_value,
291                                            p_src_data->status_cb.cadence_status.sensor_cadence_value->data,
292                                            p_src_data->status_cb.cadence_status.sensor_cadence_value->len);
293                 }
294                 break;
295             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTINGS_GET:
296             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTINGS_STATUS:
297                 if (p_src_data->status_cb.settings_status.sensor_setting_property_ids) {
298                     length = p_src_data->status_cb.settings_status.sensor_setting_property_ids->len;
299                     p_dest_data->status_cb.settings_status.sensor_setting_property_ids = bt_mesh_alloc_buf(length);
300                     if (!p_dest_data->status_cb.settings_status.sensor_setting_property_ids) {
301                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
302                         return;
303                     }
304                     net_buf_simple_add_mem(p_dest_data->status_cb.settings_status.sensor_setting_property_ids,
305                                            p_src_data->status_cb.settings_status.sensor_setting_property_ids->data,
306                                            p_src_data->status_cb.settings_status.sensor_setting_property_ids->len);
307                 }
308                 break;
309             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_GET:
310             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET:
311             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_STATUS:
312                 if (p_src_data->status_cb.setting_status.sensor_setting_raw) {
313                     length = p_src_data->status_cb.setting_status.sensor_setting_raw->len;
314                     p_dest_data->status_cb.setting_status.sensor_setting_raw = bt_mesh_alloc_buf(length);
315                     if (!p_dest_data->status_cb.setting_status.sensor_setting_raw) {
316                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
317                         return;
318                     }
319                     net_buf_simple_add_mem(p_dest_data->status_cb.setting_status.sensor_setting_raw,
320                                            p_src_data->status_cb.setting_status.sensor_setting_raw->data,
321                                            p_src_data->status_cb.setting_status.sensor_setting_raw->len);
322                 }
323                 break;
324             case ESP_BLE_MESH_MODEL_OP_SENSOR_GET:
325             case ESP_BLE_MESH_MODEL_OP_SENSOR_STATUS:
326                 if (p_src_data->status_cb.sensor_status.marshalled_sensor_data) {
327                     length = p_src_data->status_cb.sensor_status.marshalled_sensor_data->len;
328                     p_dest_data->status_cb.sensor_status.marshalled_sensor_data = bt_mesh_alloc_buf(length);
329                     if (!p_dest_data->status_cb.sensor_status.marshalled_sensor_data) {
330                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
331                         return;
332                     }
333                     net_buf_simple_add_mem(p_dest_data->status_cb.sensor_status.marshalled_sensor_data,
334                                            p_src_data->status_cb.sensor_status.marshalled_sensor_data->data,
335                                            p_src_data->status_cb.sensor_status.marshalled_sensor_data->len);
336                 }
337                 break;
338             case ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_GET:
339             case ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_STATUS:
340                 if (p_src_data->status_cb.column_status.sensor_column_value) {
341                     length = p_src_data->status_cb.column_status.sensor_column_value->len;
342                     p_dest_data->status_cb.column_status.sensor_column_value = bt_mesh_alloc_buf(length);
343                     if (!p_dest_data->status_cb.column_status.sensor_column_value) {
344                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
345                         return;
346                     }
347                     net_buf_simple_add_mem(p_dest_data->status_cb.column_status.sensor_column_value,
348                                            p_src_data->status_cb.column_status.sensor_column_value->data,
349                                            p_src_data->status_cb.column_status.sensor_column_value->len);
350                 }
351                 break;
352             case ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_GET:
353             case ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_STATUS:
354                 if (p_src_data->status_cb.series_status.sensor_series_value) {
355                     length = p_src_data->status_cb.series_status.sensor_series_value->len;
356                     p_dest_data->status_cb.series_status.sensor_series_value = bt_mesh_alloc_buf(length);
357                     if (!p_dest_data->status_cb.series_status.sensor_series_value) {
358                         BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
359                         return;
360                     }
361                     net_buf_simple_add_mem(p_dest_data->status_cb.series_status.sensor_series_value,
362                                            p_src_data->status_cb.series_status.sensor_series_value->data,
363                                            p_src_data->status_cb.series_status.sensor_series_value->len);
364                 }
365                 break;
366             default:
367                 break;
368             }
369         }
370     case ESP_BLE_MESH_SENSOR_CLIENT_TIMEOUT_EVT:
371         break;
372     default:
373         break;
374     }
375 }
376 
btc_ble_mesh_sensor_client_free_req_data(btc_msg_t * msg)377 static void btc_ble_mesh_sensor_client_free_req_data(btc_msg_t *msg)
378 {
379     esp_ble_mesh_sensor_client_cb_param_t *arg = NULL;
380 
381     if (!msg) {
382         BT_ERR("%s, Invalid parameter", __func__);
383         return;
384     }
385 
386     arg = (esp_ble_mesh_sensor_client_cb_param_t *)(msg->arg);
387 
388     switch (msg->act) {
389     case ESP_BLE_MESH_SENSOR_CLIENT_GET_STATE_EVT:
390     case ESP_BLE_MESH_SENSOR_CLIENT_SET_STATE_EVT:
391     case ESP_BLE_MESH_SENSOR_CLIENT_PUBLISH_EVT:
392         if (arg->params) {
393             switch (arg->params->opcode) {
394             case ESP_BLE_MESH_MODEL_OP_SENSOR_DESCRIPTOR_GET:
395             case ESP_BLE_MESH_MODEL_OP_SENSOR_DESCRIPTOR_STATUS:
396                 bt_mesh_free_buf(arg->status_cb.descriptor_status.descriptor);
397                 break;
398             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_GET:
399             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET:
400             case ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_STATUS:
401                 bt_mesh_free_buf(arg->status_cb.cadence_status.sensor_cadence_value);
402                 break;
403             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTINGS_GET:
404             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTINGS_STATUS:
405                 bt_mesh_free_buf(arg->status_cb.settings_status.sensor_setting_property_ids);
406                 break;
407             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_GET:
408             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET:
409             case ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_STATUS:
410                 bt_mesh_free_buf(arg->status_cb.setting_status.sensor_setting_raw);
411                 break;
412             case ESP_BLE_MESH_MODEL_OP_SENSOR_GET:
413             case ESP_BLE_MESH_MODEL_OP_SENSOR_STATUS:
414                 bt_mesh_free_buf(arg->status_cb.sensor_status.marshalled_sensor_data);
415                 break;
416             case ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_GET:
417             case ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_STATUS:
418                 bt_mesh_free_buf(arg->status_cb.column_status.sensor_column_value);
419                 break;
420             case ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_GET:
421             case ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_STATUS:
422                 bt_mesh_free_buf(arg->status_cb.series_status.sensor_series_value);
423                 break;
424             default:
425                 break;
426             }
427         }
428     case ESP_BLE_MESH_SENSOR_CLIENT_TIMEOUT_EVT:
429         if (arg->params) {
430             bt_mesh_free(arg->params);
431         }
432         break;
433     default:
434         break;
435     }
436 }
437 
btc_ble_mesh_sensor_client_callback(esp_ble_mesh_sensor_client_cb_param_t * cb_params,uint8_t act)438 static void btc_ble_mesh_sensor_client_callback(esp_ble_mesh_sensor_client_cb_param_t *cb_params, uint8_t act)
439 {
440     btc_msg_t msg = {0};
441 
442     BT_DBG("%s", __func__);
443 
444     /* If corresponding callback is not registered, event will not be posted. */
445     if (!btc_profile_cb_get(BTC_PID_SENSOR_CLIENT)) {
446         return;
447     }
448 
449     msg.sig = BTC_SIG_API_CB;
450     msg.pid = BTC_PID_SENSOR_CLIENT;
451     msg.act = act;
452 
453     btc_transfer_context(&msg, cb_params, cb_params == NULL ? 0 : sizeof(esp_ble_mesh_sensor_client_cb_param_t),
454                          btc_ble_mesh_sensor_client_copy_req_data, btc_ble_mesh_sensor_client_free_req_data);
455 }
456 
bt_mesh_sensor_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,size_t len)457 void bt_mesh_sensor_client_cb_evt_to_btc(uint32_t opcode, uint8_t evt_type,
458                                          struct bt_mesh_model *model,
459                                          struct bt_mesh_msg_ctx *ctx,
460                                          const uint8_t *val, size_t len)
461 {
462     esp_ble_mesh_sensor_client_cb_param_t cb_params = {0};
463     esp_ble_mesh_client_common_param_t params = {0};
464     uint8_t act = 0U;
465 
466     if (!model || !ctx) {
467         BT_ERR("%s, Invalid parameter", __func__);
468         return;
469     }
470 
471     switch (evt_type) {
472     case BTC_BLE_MESH_EVT_SENSOR_CLIENT_GET_STATE:
473         act = ESP_BLE_MESH_SENSOR_CLIENT_GET_STATE_EVT;
474         break;
475     case BTC_BLE_MESH_EVT_SENSOR_CLIENT_SET_STATE:
476         act = ESP_BLE_MESH_SENSOR_CLIENT_SET_STATE_EVT;
477         break;
478     case BTC_BLE_MESH_EVT_SENSOR_CLIENT_PUBLISH:
479         act = ESP_BLE_MESH_SENSOR_CLIENT_PUBLISH_EVT;
480         break;
481     case BTC_BLE_MESH_EVT_SENSOR_CLIENT_TIMEOUT:
482         act = ESP_BLE_MESH_SENSOR_CLIENT_TIMEOUT_EVT;
483         break;
484     default:
485         BT_ERR("Unknown Sensor client event type %d", evt_type);
486         return;
487     }
488 
489     params.opcode = opcode;
490     params.model = (esp_ble_mesh_model_t *)model;
491     params.ctx.net_idx = ctx->net_idx;
492     params.ctx.app_idx = ctx->app_idx;
493     params.ctx.addr = ctx->addr;
494     params.ctx.recv_ttl = ctx->recv_ttl;
495     params.ctx.recv_op = ctx->recv_op;
496     params.ctx.recv_dst = ctx->recv_dst;
497     params.ctx.recv_rssi = ctx->recv_rssi;
498     params.ctx.send_ttl = ctx->send_ttl;
499 
500     cb_params.error_code = 0;
501     cb_params.params = &params;
502 
503     if (val && len) {
504         memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb)));
505     }
506 
507     btc_ble_mesh_sensor_client_callback(&cb_params, act);
508     return;
509 }
510 
btc_ble_mesh_sensor_client_publish_callback(uint32_t opcode,struct bt_mesh_model * model,struct bt_mesh_msg_ctx * ctx,struct net_buf_simple * buf)511 void btc_ble_mesh_sensor_client_publish_callback(uint32_t opcode, struct bt_mesh_model *model,
512                                                  struct bt_mesh_msg_ctx *ctx,
513                                                  struct net_buf_simple *buf)
514 {
515     if (!model || !ctx || !buf) {
516         BT_ERR("%s, Invalid parameter", __func__);
517         return;
518     }
519 
520     bt_mesh_sensor_client_cb_evt_to_btc(opcode, BTC_BLE_MESH_EVT_SENSOR_CLIENT_PUBLISH,
521                                         model, ctx, buf->data, buf->len);
522     return;
523 }
524 
btc_ble_mesh_sensor_client_call_handler(btc_msg_t * msg)525 void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg)
526 {
527     esp_ble_mesh_client_common_param_t *params = NULL;
528     btc_ble_mesh_sensor_client_args_t *arg = NULL;
529     esp_ble_mesh_sensor_client_cb_param_t cb = {0};
530     bt_mesh_client_common_param_t common = {0};
531 
532     if (!msg) {
533         BT_ERR("%s, Invalid parameter", __func__);
534         return;
535     }
536 
537     arg = (btc_ble_mesh_sensor_client_args_t *)(msg->arg);
538 
539     switch (msg->act) {
540     case BTC_BLE_MESH_ACT_SENSOR_CLIENT_GET_STATE: {
541         params = arg->sensor_client_get_state.params;
542         common.opcode = params->opcode;
543         common.model = (struct bt_mesh_model *)params->model;
544         common.ctx.net_idx = params->ctx.net_idx;
545         common.ctx.app_idx = params->ctx.app_idx;
546         common.ctx.addr = params->ctx.addr;
547         common.ctx.send_rel = params->ctx.send_rel;
548         common.ctx.send_ttl = params->ctx.send_ttl;
549         common.msg_timeout = params->msg_timeout;
550         common.msg_role = params->msg_role;
551 
552         cb.params = arg->sensor_client_get_state.params;
553         cb.error_code = bt_mesh_sensor_client_get_state(&common, arg->sensor_client_get_state.get_state);
554         if (cb.error_code) {
555             /* If send failed, callback error_code to app layer immediately */
556             btc_ble_mesh_sensor_client_callback(&cb, ESP_BLE_MESH_SENSOR_CLIENT_GET_STATE_EVT);
557         }
558         break;
559     }
560     case BTC_BLE_MESH_ACT_SENSOR_CLIENT_SET_STATE: {
561         params = arg->sensor_client_set_state.params;
562         common.opcode = params->opcode;
563         common.model = (struct bt_mesh_model *)params->model;
564         common.ctx.net_idx = params->ctx.net_idx;
565         common.ctx.app_idx = params->ctx.app_idx;
566         common.ctx.addr = params->ctx.addr;
567         common.ctx.send_rel = params->ctx.send_rel;
568         common.ctx.send_ttl = params->ctx.send_ttl;
569         common.msg_timeout = params->msg_timeout;
570         common.msg_role = params->msg_role;
571 
572         cb.params = arg->sensor_client_set_state.params;
573         cb.error_code = bt_mesh_sensor_client_set_state(&common, arg->sensor_client_set_state.set_state);
574         if (cb.error_code) {
575             /* If send failed, callback error_code to app layer immediately */
576             btc_ble_mesh_sensor_client_callback(&cb, ESP_BLE_MESH_SENSOR_CLIENT_SET_STATE_EVT);
577         }
578         break;
579     }
580     default:
581         break;
582     }
583 
584     btc_ble_mesh_sensor_client_arg_deep_free(msg);
585     return;
586 }
587 
btc_ble_mesh_sensor_client_cb_handler(btc_msg_t * msg)588 void btc_ble_mesh_sensor_client_cb_handler(btc_msg_t *msg)
589 {
590     esp_ble_mesh_sensor_client_cb_param_t *param = NULL;
591 
592     if (!msg) {
593         BT_ERR("%s, Invalid parameter", __func__);
594         return;
595     }
596 
597     param = (esp_ble_mesh_sensor_client_cb_param_t *)(msg->arg);
598 
599     if (msg->act < ESP_BLE_MESH_SENSOR_CLIENT_EVT_MAX) {
600         btc_ble_mesh_sensor_client_cb_to_app(msg->act, param);
601     } else {
602         BT_ERR("%s, Unknown act %d", __func__, msg->act);
603     }
604 
605     btc_ble_mesh_sensor_client_free_req_data(msg);
606     return;
607 }
608 
609 #endif /* CONFIG_BLE_MESH_SENSOR_CLI */
610 
611 #if CONFIG_BLE_MESH_SENSOR_SERVER
612 
613 /* Sensor Server Models related functions */
614 
btc_ble_mesh_sensor_server_cb_to_app(esp_ble_mesh_sensor_server_cb_event_t event,esp_ble_mesh_sensor_server_cb_param_t * param)615 static inline void btc_ble_mesh_sensor_server_cb_to_app(esp_ble_mesh_sensor_server_cb_event_t event,
616                                                         esp_ble_mesh_sensor_server_cb_param_t *param)
617 {
618     esp_ble_mesh_sensor_server_cb_t btc_ble_mesh_cb =
619         (esp_ble_mesh_sensor_server_cb_t)btc_profile_cb_get(BTC_PID_SENSOR_SERVER);
620     if (btc_ble_mesh_cb) {
621         btc_ble_mesh_cb(event, param);
622     }
623 }
624 
btc_ble_mesh_sensor_server_copy_req_data(btc_msg_t * msg,void * p_dest,void * p_src)625 static void btc_ble_mesh_sensor_server_copy_req_data(btc_msg_t *msg, void *p_dest, void *p_src)
626 {
627     esp_ble_mesh_sensor_server_cb_param_t *p_dest_data = (esp_ble_mesh_sensor_server_cb_param_t *)p_dest;
628     esp_ble_mesh_sensor_server_cb_param_t *p_src_data = (esp_ble_mesh_sensor_server_cb_param_t *)p_src;
629     uint16_t length = 0U;
630 
631     if (!msg || !p_src_data || !p_dest_data) {
632         BT_ERR("%s, Invalid parameter", __func__);
633         return;
634     }
635 
636     switch (msg->act) {
637     case ESP_BLE_MESH_SENSOR_SERVER_STATE_CHANGE_EVT:
638         if (p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET ||
639                 p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET_UNACK) {
640             if (p_src_data->value.state_change.sensor_cadence_set.trigger_delta_down) {
641                 length = p_src_data->value.state_change.sensor_cadence_set.trigger_delta_down->len;
642                 p_dest_data->value.state_change.sensor_cadence_set.trigger_delta_down = bt_mesh_alloc_buf(length);
643                 if (p_dest_data->value.state_change.sensor_cadence_set.trigger_delta_down == NULL) {
644                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
645                     return;
646                 }
647                 net_buf_simple_add_mem(p_dest_data->value.state_change.sensor_cadence_set.trigger_delta_down,
648                                        p_src_data->value.state_change.sensor_cadence_set.trigger_delta_down->data,
649                                        p_src_data->value.state_change.sensor_cadence_set.trigger_delta_down->len);
650             }
651             if (p_src_data->value.state_change.sensor_cadence_set.trigger_delta_up) {
652                 length = p_src_data->value.state_change.sensor_cadence_set.trigger_delta_up->len;
653                 p_dest_data->value.state_change.sensor_cadence_set.trigger_delta_up = bt_mesh_alloc_buf(length);
654                 if (p_dest_data->value.state_change.sensor_cadence_set.trigger_delta_up == NULL) {
655                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
656                     return;
657                 }
658                 net_buf_simple_add_mem(p_dest_data->value.state_change.sensor_cadence_set.trigger_delta_up,
659                                        p_src_data->value.state_change.sensor_cadence_set.trigger_delta_up->data,
660                                        p_src_data->value.state_change.sensor_cadence_set.trigger_delta_up->len);
661             }
662             if (p_src_data->value.state_change.sensor_cadence_set.fast_cadence_low) {
663                 length = p_src_data->value.state_change.sensor_cadence_set.fast_cadence_low->len;
664                 p_dest_data->value.state_change.sensor_cadence_set.fast_cadence_low = bt_mesh_alloc_buf(length);
665                 if (p_dest_data->value.state_change.sensor_cadence_set.fast_cadence_low == NULL) {
666                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
667                     return;
668                 }
669                 net_buf_simple_add_mem(p_dest_data->value.state_change.sensor_cadence_set.fast_cadence_low,
670                                        p_src_data->value.state_change.sensor_cadence_set.fast_cadence_low->data,
671                                        p_src_data->value.state_change.sensor_cadence_set.fast_cadence_low->len);
672             }
673             if (p_src_data->value.state_change.sensor_cadence_set.fast_cadence_high) {
674                 length = p_src_data->value.state_change.sensor_cadence_set.fast_cadence_high->len;
675                 p_dest_data->value.state_change.sensor_cadence_set.fast_cadence_high = bt_mesh_alloc_buf(length);
676                 if (p_dest_data->value.state_change.sensor_cadence_set.fast_cadence_high == NULL) {
677                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
678                     return;
679                 }
680                 net_buf_simple_add_mem(p_dest_data->value.state_change.sensor_cadence_set.fast_cadence_high,
681                                        p_src_data->value.state_change.sensor_cadence_set.fast_cadence_high->data,
682                                        p_src_data->value.state_change.sensor_cadence_set.fast_cadence_high->len);
683             }
684         } else if (p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET ||
685                    p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET_UNACK) {
686             if (p_src_data->value.state_change.sensor_setting_set.setting_value) {
687                 length = p_src_data->value.state_change.sensor_setting_set.setting_value->len;
688                 p_dest_data->value.state_change.sensor_setting_set.setting_value = bt_mesh_alloc_buf(length);
689                 if (p_dest_data->value.state_change.sensor_setting_set.setting_value == NULL) {
690                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
691                     return;
692                 }
693                 net_buf_simple_add_mem(p_dest_data->value.state_change.sensor_setting_set.setting_value,
694                                        p_src_data->value.state_change.sensor_setting_set.setting_value->data,
695                                        p_src_data->value.state_change.sensor_setting_set.setting_value->len);
696             }
697         }
698         break;
699     case ESP_BLE_MESH_SENSOR_SERVER_RECV_GET_MSG_EVT:
700         if (p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_GET) {
701             if (p_src_data->value.get.sensor_column.raw_value_x) {
702                 length = p_src_data->value.get.sensor_column.raw_value_x->len;
703                 p_dest_data->value.get.sensor_column.raw_value_x = bt_mesh_alloc_buf(length);
704                 if (p_dest_data->value.get.sensor_column.raw_value_x == NULL) {
705                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
706                     return;
707                 }
708                 net_buf_simple_add_mem(p_dest_data->value.get.sensor_column.raw_value_x,
709                                        p_src_data->value.get.sensor_column.raw_value_x->data,
710                                        p_src_data->value.get.sensor_column.raw_value_x->len);
711             }
712         } else if (p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_GET) {
713             if (p_src_data->value.get.sensor_series.raw_value) {
714                 length = p_src_data->value.get.sensor_series.raw_value->len;
715                 p_dest_data->value.get.sensor_series.raw_value = bt_mesh_alloc_buf(length);
716                 if (p_dest_data->value.get.sensor_series.raw_value == NULL) {
717                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
718                     return;
719                 }
720                 net_buf_simple_add_mem(p_dest_data->value.get.sensor_series.raw_value,
721                                        p_src_data->value.get.sensor_series.raw_value->data,
722                                        p_src_data->value.get.sensor_series.raw_value->len);
723             }
724         }
725         break;
726     case ESP_BLE_MESH_SENSOR_SERVER_RECV_SET_MSG_EVT:
727         if (p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET ||
728                 p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET_UNACK) {
729             if (p_src_data->value.set.sensor_cadence.cadence) {
730                 length = p_src_data->value.set.sensor_cadence.cadence->len;
731                 p_dest_data->value.set.sensor_cadence.cadence = bt_mesh_alloc_buf(length);
732                 if (p_dest_data->value.set.sensor_cadence.cadence == NULL) {
733                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
734                     return;
735                 }
736                 net_buf_simple_add_mem(p_dest_data->value.set.sensor_cadence.cadence,
737                                        p_src_data->value.set.sensor_cadence.cadence->data,
738                                        p_src_data->value.set.sensor_cadence.cadence->len);
739             }
740         } else if (p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET ||
741                    p_src_data->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET_UNACK) {
742             if (p_src_data->value.set.sensor_setting.setting_raw) {
743                 length = p_src_data->value.set.sensor_setting.setting_raw->len;
744                 p_dest_data->value.set.sensor_setting.setting_raw = bt_mesh_alloc_buf(length);
745                 if (p_dest_data->value.set.sensor_setting.setting_raw == NULL) {
746                     BT_ERR("%s, Out of memory, act %d", __func__, msg->act);
747                     return;
748                 }
749                 net_buf_simple_add_mem(p_dest_data->value.set.sensor_setting.setting_raw,
750                                        p_src_data->value.set.sensor_setting.setting_raw->data,
751                                        p_src_data->value.set.sensor_setting.setting_raw->len);
752             }
753         }
754         break;
755     default:
756         break;
757     }
758 }
759 
btc_ble_mesh_sensor_server_free_req_data(btc_msg_t * msg)760 static void btc_ble_mesh_sensor_server_free_req_data(btc_msg_t *msg)
761 {
762     esp_ble_mesh_sensor_server_cb_param_t *arg = NULL;
763 
764     if (!msg) {
765         BT_ERR("%s, Invalid parameter", __func__);
766         return;
767     }
768 
769     arg = (esp_ble_mesh_sensor_server_cb_param_t *)(msg->arg);
770 
771     switch (msg->act) {
772     case ESP_BLE_MESH_SENSOR_SERVER_STATE_CHANGE_EVT:
773         if (arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET ||
774                 arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET_UNACK) {
775             bt_mesh_free_buf(arg->value.state_change.sensor_cadence_set.trigger_delta_down);
776             bt_mesh_free_buf(arg->value.state_change.sensor_cadence_set.trigger_delta_up);
777             bt_mesh_free_buf(arg->value.state_change.sensor_cadence_set.fast_cadence_low);
778             bt_mesh_free_buf(arg->value.state_change.sensor_cadence_set.fast_cadence_high);
779         } else if (arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET ||
780                    arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET_UNACK) {
781             bt_mesh_free_buf(arg->value.state_change.sensor_setting_set.setting_value);
782         }
783         break;
784     case ESP_BLE_MESH_SENSOR_SERVER_RECV_GET_MSG_EVT:
785         if (arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_COLUMN_GET) {
786             bt_mesh_free_buf(arg->value.get.sensor_column.raw_value_x);
787         } else if (arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SERIES_GET) {
788             bt_mesh_free_buf(arg->value.get.sensor_series.raw_value);
789         }
790         break;
791     case ESP_BLE_MESH_SENSOR_SERVER_RECV_SET_MSG_EVT:
792         if (arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET ||
793                 arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_CADENCE_SET_UNACK) {
794             bt_mesh_free_buf(arg->value.set.sensor_cadence.cadence);
795         } else if (arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET ||
796                    arg->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_SENSOR_SETTING_SET_UNACK) {
797             bt_mesh_free_buf(arg->value.set.sensor_setting.setting_raw);
798         }
799         break;
800     default:
801         break;
802     }
803 }
804 
btc_ble_mesh_sensor_server_callback(esp_ble_mesh_sensor_server_cb_param_t * cb_params,uint8_t act)805 static void btc_ble_mesh_sensor_server_callback(esp_ble_mesh_sensor_server_cb_param_t *cb_params, uint8_t act)
806 {
807     btc_msg_t msg = {0};
808 
809     BT_DBG("%s", __func__);
810 
811     /* If corresponding callback is not registered, event will not be posted. */
812     if (!btc_profile_cb_get(BTC_PID_SENSOR_SERVER)) {
813         return;
814     }
815 
816     msg.sig = BTC_SIG_API_CB;
817     msg.pid = BTC_PID_SENSOR_SERVER;
818     msg.act = act;
819 
820     btc_transfer_context(&msg, cb_params, cb_params == NULL ? 0 : sizeof(esp_ble_mesh_sensor_server_cb_param_t),
821                          btc_ble_mesh_sensor_server_copy_req_data, btc_ble_mesh_sensor_server_free_req_data);
822 }
823 
bt_mesh_sensor_server_cb_evt_to_btc(uint8_t evt_type,struct bt_mesh_model * model,struct bt_mesh_msg_ctx * ctx,const uint8_t * val,size_t len)824 void bt_mesh_sensor_server_cb_evt_to_btc(uint8_t evt_type, struct bt_mesh_model *model,
825                                          struct bt_mesh_msg_ctx *ctx,
826                                          const uint8_t *val, size_t len)
827 {
828     esp_ble_mesh_sensor_server_cb_param_t cb_params = {0};
829     uint8_t act = 0U;
830 
831     if (model == NULL || ctx == NULL) {
832         BT_ERR("%s, Invalid parameter", __func__);
833         return;
834     }
835 
836     switch (evt_type) {
837     case BTC_BLE_MESH_EVT_SENSOR_SERVER_STATE_CHANGE:
838         act = ESP_BLE_MESH_SENSOR_SERVER_STATE_CHANGE_EVT;
839         break;
840     case BTC_BLE_MESH_EVT_SENSOR_SERVER_RECV_GET_MSG:
841         act = ESP_BLE_MESH_SENSOR_SERVER_RECV_GET_MSG_EVT;
842         break;
843     case BTC_BLE_MESH_EVT_SENSOR_SERVER_RECV_SET_MSG:
844         act = ESP_BLE_MESH_SENSOR_SERVER_RECV_SET_MSG_EVT;
845         break;
846     default:
847         BT_ERR("Unknown Sensor server event type %d", evt_type);
848         return;
849     }
850 
851     cb_params.model = (esp_ble_mesh_model_t *)model;
852     cb_params.ctx.net_idx = ctx->net_idx;
853     cb_params.ctx.app_idx = ctx->app_idx;
854     cb_params.ctx.addr = ctx->addr;
855     cb_params.ctx.recv_ttl = ctx->recv_ttl;
856     cb_params.ctx.recv_op = ctx->recv_op;
857     cb_params.ctx.recv_dst = ctx->recv_dst;
858     cb_params.ctx.recv_rssi = ctx->recv_rssi;
859     cb_params.ctx.send_ttl = ctx->send_ttl;
860 
861     if (val && len) {
862         memcpy(&cb_params.value, val, MIN(len, sizeof(cb_params.value)));
863     }
864 
865     btc_ble_mesh_sensor_server_callback(&cb_params, act);
866     return;
867 }
868 
btc_ble_mesh_sensor_server_cb_handler(btc_msg_t * msg)869 void btc_ble_mesh_sensor_server_cb_handler(btc_msg_t *msg)
870 {
871     esp_ble_mesh_sensor_server_cb_param_t *param = NULL;
872 
873     if (!msg) {
874         BT_ERR("%s, Invalid parameter", __func__);
875         return;
876     }
877 
878     param = (esp_ble_mesh_sensor_server_cb_param_t *)(msg->arg);
879 
880     if (msg->act < ESP_BLE_MESH_SENSOR_SERVER_EVT_MAX) {
881         btc_ble_mesh_sensor_server_cb_to_app(msg->act, param);
882     } else {
883         BT_ERR("%s, Unknown act %d", __func__, msg->act);
884     }
885 
886     btc_ble_mesh_sensor_server_free_req_data(msg);
887     return;
888 }
889 
890 #endif /* CONFIG_BLE_MESH_SENSOR_SERVER */
891