1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hci_evt_le_cmd_complete.h"
17
18 #include <securec.h>
19
20 #include "platform/include/list.h"
21 #include "platform/include/mutex.h"
22
23 #include "hci/hci.h"
24
25 #include "hci_evt.h"
26
27 typedef void (*HciLeCmdCompleteFunc)(const void *param, uint8_t length);
28
HciEventOnLeSetEventMaskComplete(const void * param,uint8_t length)29 static void HciEventOnLeSetEventMaskComplete(const void *param, uint8_t length)
30 {
31 HciLeSetEventMaskReturnParam returnParam = {0};
32 (void)memcpy_s(
33 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
34
35 HciEventCallbacks *callbacks = NULL;
36 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
37 if (callbacks->leSetEventMaskComplete != NULL) {
38 callbacks->leSetEventMaskComplete(&returnParam);
39 }
40 HCI_FOREACH_EVT_CALLBACKS_END;
41 }
42
HciEventOnLeReadBufferSizeComplete(const void * param,uint8_t length)43 static void HciEventOnLeReadBufferSizeComplete(const void *param, uint8_t length)
44 {
45 HciLeReadBufferSizeReturnParam returnParam = {0};
46 (void)memcpy_s(
47 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
48
49 HciEventCallbacks *callbacks = NULL;
50 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
51 if (callbacks->leReadBufferSizeComplete != NULL) {
52 callbacks->leReadBufferSizeComplete(&returnParam);
53 }
54 HCI_FOREACH_EVT_CALLBACKS_END;
55 }
56
HciEventOnLeReadLocalSupportedFeaturesComplete(const void * param,uint8_t length)57 static void HciEventOnLeReadLocalSupportedFeaturesComplete(const void *param, uint8_t length)
58 {
59 HciLeReadLocalSupportedFeaturesReturnParam returnParam = {0};
60 (void)memcpy_s(
61 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
62
63 HciEventCallbacks *callbacks = NULL;
64 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
65 if (callbacks->leReadLocalSupportedFeaturesComplete != NULL) {
66 callbacks->leReadLocalSupportedFeaturesComplete(&returnParam);
67 }
68 HCI_FOREACH_EVT_CALLBACKS_END;
69 }
70
HciEventOnLeSetRandomAddressComplete(const void * param,uint8_t length)71 static void HciEventOnLeSetRandomAddressComplete(const void *param, uint8_t length)
72 {
73 HciLeSetRandomAddressReturnParam returnParam = {0};
74 (void)memcpy_s(
75 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
76
77 HciEventCallbacks *callbacks = NULL;
78 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
79 if (callbacks->leSetRandomAddressComplete != NULL) {
80 callbacks->leSetRandomAddressComplete(&returnParam);
81 }
82 HCI_FOREACH_EVT_CALLBACKS_END;
83 }
84
HciEventOnLeSetAdvertisingParametersComplete(const void * param,uint8_t length)85 static void HciEventOnLeSetAdvertisingParametersComplete(const void *param, uint8_t length)
86 {
87 HciLeSetAdvertisingParametersReturnParam returnParam = {0};
88 (void)memcpy_s(
89 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
90
91 HciEventCallbacks *callbacks = NULL;
92 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
93 if (callbacks->leSetAdvertisingParametersComplete != NULL) {
94 callbacks->leSetAdvertisingParametersComplete(&returnParam);
95 }
96 HCI_FOREACH_EVT_CALLBACKS_END;
97 }
98
HciEventOnLeReadAdvertisingChannelTxPowerComplete(const void * param,uint8_t length)99 static void HciEventOnLeReadAdvertisingChannelTxPowerComplete(const void *param, uint8_t length)
100 {
101 HciLeReadAdvertisingChannelTxPowerReturnParam returnParam = {0};
102 (void)memcpy_s(
103 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
104
105 HciEventCallbacks *callbacks = NULL;
106 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
107 if (callbacks->leReadAdvertisingChannelTxPowerComplete != NULL) {
108 callbacks->leReadAdvertisingChannelTxPowerComplete(&returnParam);
109 }
110 HCI_FOREACH_EVT_CALLBACKS_END;
111 }
112
HciEventOnLeSetAdvertisingDataComplete(const void * param,uint8_t length)113 static void HciEventOnLeSetAdvertisingDataComplete(const void *param, uint8_t length)
114 {
115 HciLeSetAdvertisingDataReturnParam returnParam = {0};
116 (void)memcpy_s(
117 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
118
119 HciEventCallbacks *callbacks = NULL;
120 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
121 if (callbacks->leSetAdvertisingDataComplete != NULL) {
122 callbacks->leSetAdvertisingDataComplete(&returnParam);
123 }
124 HCI_FOREACH_EVT_CALLBACKS_END;
125 }
126
HciEventOnLeSetScanResponseDataComplete(const void * param,uint8_t length)127 static void HciEventOnLeSetScanResponseDataComplete(const void *param, uint8_t length)
128 {
129 HciLeSetScanResponseDataReturnParam returnParam = {0};
130 (void)memcpy_s(
131 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
132
133 HciEventCallbacks *callbacks = NULL;
134 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
135 if (callbacks->leSetScanResponseDataComplete != NULL) {
136 callbacks->leSetScanResponseDataComplete(&returnParam);
137 }
138 HCI_FOREACH_EVT_CALLBACKS_END;
139 }
140
HciEventOnLeSetAdvertisingEnableComplete(const void * param,uint8_t length)141 static void HciEventOnLeSetAdvertisingEnableComplete(const void *param, uint8_t length)
142 {
143 HciLeSetAdvertisingEnableReturnParam returnParam = {0};
144 (void)memcpy_s(
145 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
146
147 HciEventCallbacks *callbacks = NULL;
148 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
149 if (callbacks->leSetAdvertisingEnableComplete != NULL) {
150 callbacks->leSetAdvertisingEnableComplete(&returnParam);
151 }
152 HCI_FOREACH_EVT_CALLBACKS_END;
153 }
154
HciEventOnLeSetScanParametersComplete(const void * param,uint8_t length)155 static void HciEventOnLeSetScanParametersComplete(const void *param, uint8_t length)
156 {
157 HciLeSetScanParametersReturnParam returnParam = {0};
158 (void)memcpy_s(
159 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
160
161 HciEventCallbacks *callbacks = NULL;
162 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
163 if (callbacks->leSetScanParametersComplete != NULL) {
164 callbacks->leSetScanParametersComplete(&returnParam);
165 }
166 HCI_FOREACH_EVT_CALLBACKS_END;
167 }
168
HciEventOnLeSetScanEnableComplete(const void * param,uint8_t length)169 static void HciEventOnLeSetScanEnableComplete(const void *param, uint8_t length)
170 {
171 HciLeSetScanEnableReturnParam returnParam = {0};
172 (void)memcpy_s(
173 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
174
175 HciEventCallbacks *callbacks = NULL;
176 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
177 if (callbacks->leSetScanEnableComplete != NULL) {
178 callbacks->leSetScanEnableComplete(&returnParam);
179 }
180 HCI_FOREACH_EVT_CALLBACKS_END;
181 }
182
HciEventOnLeCreateConnectionCancelComplete(const void * param,uint8_t length)183 static void HciEventOnLeCreateConnectionCancelComplete(const void *param, uint8_t length)
184 {
185 HciLeCreateConnectionCancelReturnParam returnParam = {0};
186 (void)memcpy_s(
187 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
188
189 HciEventCallbacks *callbacks = NULL;
190 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
191 if (callbacks->leCreateConnectionCancelComplete != NULL) {
192 callbacks->leCreateConnectionCancelComplete(&returnParam);
193 }
194 HCI_FOREACH_EVT_CALLBACKS_END;
195 }
196
HciEventOnLeReadWhiteListSizeComplete(const void * param,uint8_t length)197 static void HciEventOnLeReadWhiteListSizeComplete(const void *param, uint8_t length)
198 {
199 HciLeReadWhiteListSizeReturnParam returnParam = {0};
200 (void)memcpy_s(
201 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
202
203 HciEventCallbacks *callbacks = NULL;
204 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
205 if (callbacks->leReadWhiteListSizeComplete != NULL) {
206 callbacks->leReadWhiteListSizeComplete(&returnParam);
207 }
208 HCI_FOREACH_EVT_CALLBACKS_END;
209 }
210
HciEventOnLeClearWhiteListComplete(const void * param,uint8_t length)211 static void HciEventOnLeClearWhiteListComplete(const void *param, uint8_t length)
212 {
213 HciLeClearWhiteListReturnParam returnParam = {0};
214 (void)memcpy_s(
215 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
216
217 HciEventCallbacks *callbacks = NULL;
218 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
219 if (callbacks->leClearWhiteListComplete != NULL) {
220 callbacks->leClearWhiteListComplete(&returnParam);
221 }
222 HCI_FOREACH_EVT_CALLBACKS_END;
223 }
224
HciEventOnLeAddDeviceToWhiteListComplete(const void * param,uint8_t length)225 static void HciEventOnLeAddDeviceToWhiteListComplete(const void *param, uint8_t length)
226 {
227 HciLeAddDeviceToWhiteListReturnParam returnParam = {0};
228 (void)memcpy_s(
229 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
230
231 HciEventCallbacks *callbacks = NULL;
232 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
233 if (callbacks->leAddDeviceToWhiteListComplete != NULL) {
234 callbacks->leAddDeviceToWhiteListComplete(&returnParam);
235 }
236 HCI_FOREACH_EVT_CALLBACKS_END;
237 }
238
HciEventOnLeRemoveDeviceFromWhiteListComplete(const void * param,uint8_t length)239 static void HciEventOnLeRemoveDeviceFromWhiteListComplete(const void *param, uint8_t length)
240 {
241 HciLeRemoveDeviceFromWhiteListReturnParam returnParam = {0};
242 (void)memcpy_s(
243 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
244
245 HciEventCallbacks *callbacks = NULL;
246 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
247 if (callbacks->leRemoveDeviceFromWhiteListComplete != NULL) {
248 callbacks->leRemoveDeviceFromWhiteListComplete(&returnParam);
249 }
250 HCI_FOREACH_EVT_CALLBACKS_END;
251 }
252
HciEventOnLeSetHostChannelClassificationComplete(const void * param,uint8_t length)253 static void HciEventOnLeSetHostChannelClassificationComplete(const void *param, uint8_t length)
254 {
255 HciLeSetHostChannelClassificationReturnParam returnParam = {0};
256 (void)memcpy_s(
257 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
258
259 HciEventCallbacks *callbacks = NULL;
260 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
261 if (callbacks->leSetHostChannelClassificationComplete != NULL) {
262 callbacks->leSetHostChannelClassificationComplete(&returnParam);
263 }
264 HCI_FOREACH_EVT_CALLBACKS_END;
265 }
266
HciEventOnLeReadChannelMapComplete(const void * param,uint8_t length)267 static void HciEventOnLeReadChannelMapComplete(const void *param, uint8_t length)
268 {
269 HciLeReadChannelMapReturnParam returnParam = {0};
270 (void)memcpy_s(
271 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
272
273 HciEventCallbacks *callbacks = NULL;
274 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
275 if (callbacks->leReadChannelMapComplete != NULL) {
276 callbacks->leReadChannelMapComplete(&returnParam);
277 }
278 HCI_FOREACH_EVT_CALLBACKS_END;
279 }
280
HciEventOnLeEncryptComplete(const void * param,uint8_t length)281 static void HciEventOnLeEncryptComplete(const void *param, uint8_t length)
282 {
283 HciLeEncryptReturnParam returnParam = {0};
284 (void)memcpy_s(
285 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
286
287 HciEventCallbacks *callbacks = NULL;
288 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
289 if (callbacks->leEncryptComplete != NULL) {
290 callbacks->leEncryptComplete(&returnParam);
291 }
292 HCI_FOREACH_EVT_CALLBACKS_END;
293 }
294
HciEventOnLeRandComplete(const void * param,uint8_t length)295 static void HciEventOnLeRandComplete(const void *param, uint8_t length)
296 {
297 HciLeRandReturnParam returnParam = {0};
298 (void)memcpy_s(
299 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
300
301 HciEventCallbacks *callbacks = NULL;
302 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
303 if (callbacks->leRandComplete != NULL) {
304 callbacks->leRandComplete(&returnParam);
305 }
306 HCI_FOREACH_EVT_CALLBACKS_END;
307 }
308
HciEventOnLeLongTermKeyRequestReplyComplete(const void * param,uint8_t length)309 static void HciEventOnLeLongTermKeyRequestReplyComplete(const void *param, uint8_t length)
310 {
311 HciLeLongTermKeyRequestReplyReturnParam returnParam = {0};
312 (void)memcpy_s(
313 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
314
315 HciEventCallbacks *callbacks = NULL;
316 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
317 if (callbacks->leLongTermKeyRequestReplyComplete != NULL) {
318 callbacks->leLongTermKeyRequestReplyComplete(&returnParam);
319 }
320 HCI_FOREACH_EVT_CALLBACKS_END;
321 }
322
HciEventOnLeLongTermKeyRequestNegativeReplyComplete(const void * param,uint8_t length)323 static void HciEventOnLeLongTermKeyRequestNegativeReplyComplete(const void *param, uint8_t length)
324 {
325 HciLeLongTermKeyRequestNegativeReplyReturnParam returnParam = {0};
326 (void)memcpy_s(
327 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
328
329 HciEventCallbacks *callbacks = NULL;
330 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
331 if (callbacks->leLongTermKeyRequestNegativeReplyComplete != NULL) {
332 callbacks->leLongTermKeyRequestNegativeReplyComplete(&returnParam);
333 }
334 HCI_FOREACH_EVT_CALLBACKS_END;
335 }
336
HciEventOnLeRemoteConnectionParameterRequestReplyComplete(const void * param,uint8_t length)337 static void HciEventOnLeRemoteConnectionParameterRequestReplyComplete(const void *param, uint8_t length)
338 {
339 HciLeRemoteConnectionParameterRequestReplyReturnParam returnParam = {0};
340 (void)memcpy_s(
341 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
342
343 HciEventCallbacks *callbacks = NULL;
344 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
345 if (callbacks->leRemoteConnectionParameterRequestReplyComplete != NULL) {
346 callbacks->leRemoteConnectionParameterRequestReplyComplete(&returnParam);
347 }
348 HCI_FOREACH_EVT_CALLBACKS_END;
349 }
350
HciEventOnLeRemoteConnectionParameterRequestNegativeReplyComplete(const void * param,uint8_t length)351 static void HciEventOnLeRemoteConnectionParameterRequestNegativeReplyComplete(const void *param, uint8_t length)
352 {
353 HciLeRemoteConnectionParameterRequestNegativeReplyReturnParam returnParam = {0};
354 (void)memcpy_s(
355 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
356
357 HciEventCallbacks *callbacks = NULL;
358 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
359 if (callbacks->leRemoteConnectionParameterRequestNegativeReplyComplete != NULL) {
360 callbacks->leRemoteConnectionParameterRequestNegativeReplyComplete(&returnParam);
361 }
362 HCI_FOREACH_EVT_CALLBACKS_END;
363 }
364
HciEventOnLeAddDeviceToResolvingListComplete(const void * param,uint8_t length)365 static void HciEventOnLeAddDeviceToResolvingListComplete(const void *param, uint8_t length)
366 {
367 HciLeAddDeviceToResolvingListReturnParam returnParam = {0};
368 (void)memcpy_s(
369 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
370
371 HciEventCallbacks *callbacks = NULL;
372 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
373 if (callbacks->leAddDeviceToResolvingListComplete != NULL) {
374 callbacks->leAddDeviceToResolvingListComplete(&returnParam);
375 }
376 HCI_FOREACH_EVT_CALLBACKS_END;
377 }
378
HciEventOnLeRemoveDeviceFromResolvingListComplete(const void * param,uint8_t length)379 static void HciEventOnLeRemoveDeviceFromResolvingListComplete(const void *param, uint8_t length)
380 {
381 HciLeRemoveDeviceFromResolvingListReturnParam returnParam = {0};
382 (void)memcpy_s(
383 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
384
385 HciEventCallbacks *callbacks = NULL;
386 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
387 if (callbacks->leRemoveDeviceFromResolvingListComplete != NULL) {
388 callbacks->leRemoveDeviceFromResolvingListComplete(&returnParam);
389 }
390 HCI_FOREACH_EVT_CALLBACKS_END;
391 }
392
HciEventOnLeClearResolvingListComplete(const void * param,uint8_t length)393 static void HciEventOnLeClearResolvingListComplete(const void *param, uint8_t length)
394 {
395 HciLeClearResolvingListReturnParam returnParam = {0};
396 (void)memcpy_s(
397 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
398
399 HciEventCallbacks *callbacks = NULL;
400 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
401 if (callbacks->leClearResolvingListComplete != NULL) {
402 callbacks->leClearResolvingListComplete(&returnParam);
403 }
404 HCI_FOREACH_EVT_CALLBACKS_END;
405 }
406
HciEventOnLeReadResolvingListSizeComplete(const void * param,uint8_t length)407 static void HciEventOnLeReadResolvingListSizeComplete(const void *param, uint8_t length)
408 {
409 HciLeReadResolvingListSizeReturnParam returnParam = {0};
410 (void)memcpy_s(
411 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
412
413 HciEventCallbacks *callbacks = NULL;
414 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
415 if (callbacks->leReadResolvingListSizeComplete != NULL) {
416 callbacks->leReadResolvingListSizeComplete(&returnParam);
417 }
418 HCI_FOREACH_EVT_CALLBACKS_END;
419 }
420
HciEventOnLeReadPeerResolvableAddressComplete(const void * param,uint8_t length)421 static void HciEventOnLeReadPeerResolvableAddressComplete(const void *param, uint8_t length)
422 {
423 HciLeReadPeerResolvableAddressReturnParam returnParam = {0};
424 (void)memcpy_s(
425 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
426
427 HciEventCallbacks *callbacks = NULL;
428 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
429 if (callbacks->leReadPeerResolvableAddressComplete != NULL) {
430 callbacks->leReadPeerResolvableAddressComplete(&returnParam);
431 }
432 HCI_FOREACH_EVT_CALLBACKS_END;
433 }
434
HciEventOnLeReadLocalResolvableAddressComplete(const void * param,uint8_t length)435 static void HciEventOnLeReadLocalResolvableAddressComplete(const void *param, uint8_t length)
436 {
437 HciLeReadLocalResolvableAddressReturnParam returnParam = {0};
438 (void)memcpy_s(
439 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
440
441 HciEventCallbacks *callbacks = NULL;
442 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
443 if (callbacks->leReadLocalResolvableAddressComplete != NULL) {
444 callbacks->leReadLocalResolvableAddressComplete(&returnParam);
445 }
446 HCI_FOREACH_EVT_CALLBACKS_END;
447 }
448
HciEventOnLeSetAddressResolutionEnableComplete(const void * param,uint8_t length)449 static void HciEventOnLeSetAddressResolutionEnableComplete(const void *param, uint8_t length)
450 {
451 HciLeSetAddressResolutionEnableReturnParam returnParam = {0};
452 (void)memcpy_s(
453 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
454
455 HciEventCallbacks *callbacks = NULL;
456 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
457 if (callbacks->leSetAddressResolutionEnableComplete != NULL) {
458 callbacks->leSetAddressResolutionEnableComplete(&returnParam);
459 }
460 HCI_FOREACH_EVT_CALLBACKS_END;
461 }
462
HciEventOnSetResolvablePrivateAddressTimeoutComplete(const void * param,uint8_t length)463 static void HciEventOnSetResolvablePrivateAddressTimeoutComplete(const void *param, uint8_t length)
464 {
465 HciLeSetResolvablePrivateAddressTimeoutReturnParam returnParam = {0};
466 (void)memcpy_s(
467 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
468
469 HciEventCallbacks *callbacks = NULL;
470 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
471 if (callbacks->leSetResolvablePrivateAddressTimeoutComplete != NULL) {
472 callbacks->leSetResolvablePrivateAddressTimeoutComplete(&returnParam);
473 }
474 HCI_FOREACH_EVT_CALLBACKS_END;
475 }
476
HciEventOnLeSetAdvertisingSetRandomAddressComplete(const void * param,uint8_t length)477 static void HciEventOnLeSetAdvertisingSetRandomAddressComplete(const void *param, uint8_t length)
478 {
479 HciLeSetAdvertisingSetRandomAddressReturnParam returnParam = {0};
480 (void)memcpy_s(
481 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
482
483 HciEventCallbacks *callbacks = NULL;
484 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
485 if (callbacks->leSetAdvertisingSetRandomAddressComplete != NULL) {
486 callbacks->leSetAdvertisingSetRandomAddressComplete(&returnParam);
487 }
488 HCI_FOREACH_EVT_CALLBACKS_END;
489 }
490
HciEventOnLeSetExtendedAdvertisingParametersComplete(const void * param,uint8_t length)491 static void HciEventOnLeSetExtendedAdvertisingParametersComplete(const void *param, uint8_t length)
492 {
493 HciLeSetExtendedAdvertisingParametersReturnParam returnParam = {0};
494 (void)memcpy_s(
495 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
496
497 HciEventCallbacks *callbacks = NULL;
498 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
499 if (callbacks->leSetExtendedAdvertisingParametersComplete != NULL) {
500 callbacks->leSetExtendedAdvertisingParametersComplete(&returnParam);
501 }
502 HCI_FOREACH_EVT_CALLBACKS_END;
503 }
504
HciEventOnLeSetExtendedAdvertisingDataComplete(const void * param,uint8_t length)505 static void HciEventOnLeSetExtendedAdvertisingDataComplete(const void *param, uint8_t length)
506 {
507 HciLeSetExtendedAdvertisingDataReturnParam returnParam = {0};
508 (void)memcpy_s(
509 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
510
511 HciEventCallbacks *callbacks = NULL;
512 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
513 if (callbacks->leSetExtendedAdvertisingDataComplete != NULL) {
514 callbacks->leSetExtendedAdvertisingDataComplete(&returnParam);
515 }
516 HCI_FOREACH_EVT_CALLBACKS_END;
517 }
518
HciEventOnLeSetExtendedScanResponseDataComplete(const void * param,uint8_t length)519 static void HciEventOnLeSetExtendedScanResponseDataComplete(const void *param, uint8_t length)
520 {
521 HciLeSetExtendedScanResponseDataReturnParam returnParam = {0};
522 (void)memcpy_s(
523 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
524
525 HciEventCallbacks *callbacks = NULL;
526 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
527 if (callbacks->leSetExtendedScanResponseDataComplete != NULL) {
528 callbacks->leSetExtendedScanResponseDataComplete(&returnParam);
529 }
530 HCI_FOREACH_EVT_CALLBACKS_END;
531 }
532
HciEventOnLeSetExtendedAdvertisingEnableComplete(const void * param,uint8_t length)533 static void HciEventOnLeSetExtendedAdvertisingEnableComplete(const void *param, uint8_t length)
534 {
535 HciLeSetExtendedAdvertisingEnableReturnParam returnParam = {0};
536 (void)memcpy_s(
537 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
538
539 HciEventCallbacks *callbacks = NULL;
540 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
541 if (callbacks->leSetExtendedAdvertisingEnableComplete != NULL) {
542 callbacks->leSetExtendedAdvertisingEnableComplete(&returnParam);
543 }
544 HCI_FOREACH_EVT_CALLBACKS_END;
545 }
546
HciEventOnLeReadMaximumAdvertisingDataLengthComplete(const void * param,uint8_t length)547 static void HciEventOnLeReadMaximumAdvertisingDataLengthComplete(const void *param, uint8_t length)
548 {
549 HciLeReadMaximumAdvertisingDataLengthReturnParam returnParam = {0};
550 (void)memcpy_s(
551 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
552
553 HciEventCallbacks *callbacks = NULL;
554 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
555 if (callbacks->leReadMaximumAdvertisingDataLengthComplete != NULL) {
556 callbacks->leReadMaximumAdvertisingDataLengthComplete(&returnParam);
557 }
558 HCI_FOREACH_EVT_CALLBACKS_END;
559 }
560
HciEventOnLeReadNumberofSupportedAdvertisingSetsComplete(const void * param,uint8_t length)561 static void HciEventOnLeReadNumberofSupportedAdvertisingSetsComplete(const void *param, uint8_t length)
562 {
563 HciLeReadNumberofSupportedAdvertisingSetsReturnParam returnParam = {0};
564 (void)memcpy_s(
565 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
566
567 HciEventCallbacks *callbacks = NULL;
568 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
569 if (callbacks->leReadNumberofSupportedAdvertisingSetsComplete != NULL) {
570 callbacks->leReadNumberofSupportedAdvertisingSetsComplete(&returnParam);
571 }
572 HCI_FOREACH_EVT_CALLBACKS_END;
573 }
574
HciEventOnLeRemoveAdvertisingSetComplete(const void * param,uint8_t length)575 static void HciEventOnLeRemoveAdvertisingSetComplete(const void *param, uint8_t length)
576 {
577 HciLeRemoveAdvertisingSetReturnParam returnParam = {0};
578 (void)memcpy_s(
579 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
580
581 HciEventCallbacks *callbacks = NULL;
582 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
583 if (callbacks->leRemoveAdvertisingSetComplete != NULL) {
584 callbacks->leRemoveAdvertisingSetComplete(&returnParam);
585 }
586 HCI_FOREACH_EVT_CALLBACKS_END;
587 }
588
HciEventOnLeClearAdvertisingSetsComplete(const void * param,uint8_t length)589 static void HciEventOnLeClearAdvertisingSetsComplete(const void *param, uint8_t length)
590 {
591 HciLeClearAdvertisingSetsReturnParam returnParam = {0};
592 (void)memcpy_s(
593 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
594
595 HciEventCallbacks *callbacks = NULL;
596 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
597 if (callbacks->leClearAdvertisingSetsComplete != NULL) {
598 callbacks->leClearAdvertisingSetsComplete(&returnParam);
599 }
600 HCI_FOREACH_EVT_CALLBACKS_END;
601 }
602
HciEventOnLeSetExtendedScanParametersComplete(const void * param,uint8_t length)603 static void HciEventOnLeSetExtendedScanParametersComplete(const void *param, uint8_t length)
604 {
605 HciLeClearAdvertisingSetsReturnParam returnParam = {0};
606 (void)memcpy_s(
607 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
608
609 HciEventCallbacks *callbacks = NULL;
610 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
611 if (callbacks->leSetExtendedScanParametersComplete != NULL) {
612 callbacks->leSetExtendedScanParametersComplete(&returnParam);
613 }
614 HCI_FOREACH_EVT_CALLBACKS_END;
615 }
616
HciEventOnLeSetExtendedScanEnableComplete(const void * param,uint8_t length)617 static void HciEventOnLeSetExtendedScanEnableComplete(const void *param, uint8_t length)
618 {
619 HciLeSetExtendedScanEnableReturnParam returnParam = {0};
620 (void)memcpy_s(
621 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
622
623 HciEventCallbacks *callbacks = NULL;
624 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
625 if (callbacks->leSetExtendedScanEnableComplete != NULL) {
626 callbacks->leSetExtendedScanEnableComplete(&returnParam);
627 }
628 HCI_FOREACH_EVT_CALLBACKS_END;
629 }
630
HciEventOnLeReadSupportedStatesComplete(const void * param,uint8_t length)631 static void HciEventOnLeReadSupportedStatesComplete(const void *param, uint8_t length)
632 {
633 HciLeReadSupportedStatesReturnParam returnParam = {0};
634 (void)memcpy_s(
635 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
636
637 HciEventCallbacks *callbacks = NULL;
638 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
639 if (callbacks->leReadSupportedStatesComplete != NULL) {
640 callbacks->leReadSupportedStatesComplete(&returnParam);
641 }
642 HCI_FOREACH_EVT_CALLBACKS_END;
643 }
644
HciEventOnLeReceiverTestComplete(const void * param,uint8_t length)645 static void HciEventOnLeReceiverTestComplete(const void *param, uint8_t length)
646 {
647 HciLeReceiverTestReturnParam returnParam = {0};
648 (void)memcpy_s(
649 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
650
651 HciEventCallbacks *callbacks = NULL;
652 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
653 if (callbacks->leReceiverTestComplete != NULL) {
654 callbacks->leReceiverTestComplete(&returnParam);
655 }
656 HCI_FOREACH_EVT_CALLBACKS_END;
657 }
658
HciEventOnLeTransmitterTestComplete(const void * param,uint8_t length)659 static void HciEventOnLeTransmitterTestComplete(const void *param, uint8_t length)
660 {
661 HciLeTransmitterTestReturnParam returnParam = {0};
662 (void)memcpy_s(
663 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
664
665 HciEventCallbacks *callbacks = NULL;
666 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
667 if (callbacks->leTransmitterTestComplete != NULL) {
668 callbacks->leTransmitterTestComplete(&returnParam);
669 }
670 HCI_FOREACH_EVT_CALLBACKS_END;
671 }
672
HciEventOnLeTestEndComplete(const void * param,uint8_t length)673 static void HciEventOnLeTestEndComplete(const void *param, uint8_t length)
674 {
675 HciLeTestEndReturnParam returnParam = {0};
676 (void)memcpy_s(
677 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
678
679 HciEventCallbacks *callbacks = NULL;
680 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
681 if (callbacks->leTestEndComplete != NULL) {
682 callbacks->leTestEndComplete(&returnParam);
683 }
684 HCI_FOREACH_EVT_CALLBACKS_END;
685 }
686
HciEventOnLeSetDataLengthComplete(const void * param,uint8_t length)687 static void HciEventOnLeSetDataLengthComplete(const void *param, uint8_t length)
688 {
689 HciLeSetDataLengthReturnParam returnParam = {0};
690 (void)memcpy_s(
691 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
692
693 HciEventCallbacks *callbacks = NULL;
694 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
695 if (callbacks->leSetDataLengthComplete != NULL) {
696 callbacks->leSetDataLengthComplete(&returnParam);
697 }
698 HCI_FOREACH_EVT_CALLBACKS_END;
699 }
700
HciEventOnLeReadSuggestedDefaultDataLengthComplete(const void * param,uint8_t length)701 static void HciEventOnLeReadSuggestedDefaultDataLengthComplete(const void *param, uint8_t length)
702 {
703 HciLeReadSuggestedDefaultDataLengthReturnParam returnParam = {0};
704 (void)memcpy_s(
705 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
706
707 HciEventCallbacks *callbacks = NULL;
708 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
709 if (callbacks->leReadSuggestedDefaultDataLengthComplete != NULL) {
710 callbacks->leReadSuggestedDefaultDataLengthComplete(&returnParam);
711 }
712 HCI_FOREACH_EVT_CALLBACKS_END;
713 }
714
HciEventOnLeWriteSuggestedDefaultDataLengthComplete(const void * param,uint8_t length)715 static void HciEventOnLeWriteSuggestedDefaultDataLengthComplete(const void *param, uint8_t length)
716 {
717 HciLeWriteSuggestedDefaultDataLengthReturnParam returnParam = {0};
718 (void)memcpy_s(
719 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
720
721 HciEventCallbacks *callbacks = NULL;
722 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
723 if (callbacks->leWriteSuggestedDefaultDataLengthComplete != NULL) {
724 callbacks->leWriteSuggestedDefaultDataLengthComplete(&returnParam);
725 }
726 HCI_FOREACH_EVT_CALLBACKS_END;
727 }
728
HciEventOnLeReadMaximumDataLengthComplete(const void * param,uint8_t length)729 static void HciEventOnLeReadMaximumDataLengthComplete(const void *param, uint8_t length)
730 {
731 HciLeReadMaximumDataLengthReturnParam returnParam = {0};
732 (void)memcpy_s(
733 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
734
735 HciEventCallbacks *callbacks = NULL;
736 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
737 if (callbacks->leReadMaximumDataLengthComplete != NULL) {
738 callbacks->leReadMaximumDataLengthComplete(&returnParam);
739 }
740 HCI_FOREACH_EVT_CALLBACKS_END;
741 }
742
HciEventOnLeReadPhyComplete(const void * param,uint8_t length)743 static void HciEventOnLeReadPhyComplete(const void *param, uint8_t length)
744 {
745 HciLeReadPhyReturnParam returnParam = {0};
746 (void)memcpy_s(
747 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
748
749 HciEventCallbacks *callbacks = NULL;
750 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
751 if (callbacks->leReadPhyComplete != NULL) {
752 callbacks->leReadPhyComplete(&returnParam);
753 }
754 HCI_FOREACH_EVT_CALLBACKS_END;
755 }
756
HciEventOnLeSetDefaultPhyComplete(const void * param,uint8_t length)757 static void HciEventOnLeSetDefaultPhyComplete(const void *param, uint8_t length)
758 {
759 HciLeSetDefaultPhyReturnParam returnParam = {0};
760 (void)memcpy_s(
761 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
762
763 HciEventCallbacks *callbacks = NULL;
764 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
765 if (callbacks->leSetDefaultPhyComplete != NULL) {
766 callbacks->leSetDefaultPhyComplete(&returnParam);
767 }
768 HCI_FOREACH_EVT_CALLBACKS_END;
769 }
770
HciEventOnLeEnhancedReceiverTestComplete(const void * param,uint8_t length)771 static void HciEventOnLeEnhancedReceiverTestComplete(const void *param, uint8_t length)
772 {
773 HciLeEnhancedReceiverTestReturnParam returnParam = {0};
774 (void)memcpy_s(
775 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
776
777 HciEventCallbacks *callbacks = NULL;
778 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
779 if (callbacks->leEnhancedReceiverTestComplete != NULL) {
780 callbacks->leEnhancedReceiverTestComplete(&returnParam);
781 }
782 HCI_FOREACH_EVT_CALLBACKS_END;
783 }
784
HciEventOnLeEnhancedTransmitterTestComplete(const void * param,uint8_t length)785 static void HciEventOnLeEnhancedTransmitterTestComplete(const void *param, uint8_t length)
786 {
787 HciLeEnhancedTransmitterTestReturnParam returnParam = {0};
788 (void)memcpy_s(
789 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
790
791 HciEventCallbacks *callbacks = NULL;
792 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
793 if (callbacks->leEnhancedTransmitterTestComplete != NULL) {
794 callbacks->leEnhancedTransmitterTestComplete(&returnParam);
795 }
796 HCI_FOREACH_EVT_CALLBACKS_END;
797 }
798
HciEventOnLeSetPeriodicAdvertisingParametersComplete(const void * param,uint8_t length)799 static void HciEventOnLeSetPeriodicAdvertisingParametersComplete(const void *param, uint8_t length)
800 {
801 HciLeSetPeriodicAdvertisingParametersReturnParameters returnParam = {0};
802 (void)memcpy_s(
803 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
804
805 HciEventCallbacks *callbacks = NULL;
806 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
807 if (callbacks->leSetPeriodicAdvertisingParametersComplete != NULL) {
808 callbacks->leSetPeriodicAdvertisingParametersComplete(param);
809 }
810 HCI_FOREACH_EVT_CALLBACKS_END;
811 }
812
HciEventOnLeSetPeriodicAdvertisingDataComplete(const void * param,uint8_t length)813 static void HciEventOnLeSetPeriodicAdvertisingDataComplete(const void *param, uint8_t length)
814 {
815 HciLeSetPeriodicAdvertisingDataReturnParameters returnParam = {0};
816 (void)memcpy_s(
817 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
818
819 HciEventCallbacks *callbacks = NULL;
820 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
821 if (callbacks->leSetPeriodicAdvertisingDataComplete != NULL) {
822 callbacks->leSetPeriodicAdvertisingDataComplete(&returnParam);
823 }
824 HCI_FOREACH_EVT_CALLBACKS_END;
825 }
826
HciEventOnLeSetPeriodicAdvertisingEnableComplete(const void * param,uint8_t length)827 static void HciEventOnLeSetPeriodicAdvertisingEnableComplete(const void *param, uint8_t length)
828 {
829 HciLeSetPeriodicAdvertisingEnableReturnParameters returnParam = {0};
830 (void)memcpy_s(
831 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
832
833 HciEventCallbacks *callbacks = NULL;
834 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
835 if (callbacks->leSetPeriodicAdvertisingEnableComplete != NULL) {
836 callbacks->leSetPeriodicAdvertisingEnableComplete(&returnParam);
837 }
838 HCI_FOREACH_EVT_CALLBACKS_END;
839 }
840
HciEventOnLePeriodicAdvertisingCreateSyncCancelComplete(const void * param,uint8_t length)841 static void HciEventOnLePeriodicAdvertisingCreateSyncCancelComplete(const void *param, uint8_t length)
842 {
843 HciLePeriodicAdvertisingCreateSyncCancelReturnParam returnParam = {0};
844 (void)memcpy_s(
845 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
846
847 HciEventCallbacks *callbacks = NULL;
848 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
849 if (callbacks->lePeriodicAdvertisingCreateSyncCancelComplete != NULL) {
850 callbacks->lePeriodicAdvertisingCreateSyncCancelComplete(&returnParam);
851 }
852 HCI_FOREACH_EVT_CALLBACKS_END;
853 }
854
HciEventOnLePeriodicAdvertisingTerminateSyncComplete(const void * param,uint8_t length)855 static void HciEventOnLePeriodicAdvertisingTerminateSyncComplete(const void *param, uint8_t length)
856 {
857 HciLePeriodicAdvertisingTerminateSyncReturnParam returnParam = {0};
858 (void)memcpy_s(
859 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
860
861 HciEventCallbacks *callbacks = NULL;
862 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
863 if (callbacks->lePeriodicAdvertisingTerminateSyncComplete != NULL) {
864 callbacks->lePeriodicAdvertisingTerminateSyncComplete(&returnParam);
865 }
866 HCI_FOREACH_EVT_CALLBACKS_END;
867 }
868
HciEventOnLeAddDeviceToPeriodicAdvertiserListComplete(const void * param,uint8_t length)869 static void HciEventOnLeAddDeviceToPeriodicAdvertiserListComplete(const void *param, uint8_t length)
870 {
871 HciLeAddDeviceToPeriodicAdvertiserListReturnParam returnParam = {0};
872 (void)memcpy_s(
873 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
874
875 HciEventCallbacks *callbacks = NULL;
876 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
877 if (callbacks->leAddDeviceToPeriodicAdvertiserListComplete != NULL) {
878 callbacks->leAddDeviceToPeriodicAdvertiserListComplete(&returnParam);
879 }
880 HCI_FOREACH_EVT_CALLBACKS_END;
881 }
882
HciEventOnLeRemoveDeviceFromPeriodicAdvertiserListComplete(const void * param,uint8_t length)883 static void HciEventOnLeRemoveDeviceFromPeriodicAdvertiserListComplete(const void *param, uint8_t length)
884 {
885 HciLeRemoveDeviceFromPeriodicAdvertiserListReturnParam returnParam = {0};
886 (void)memcpy_s(
887 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
888
889 HciEventCallbacks *callbacks = NULL;
890 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
891 if (callbacks->leRemoveDeviceFromPeriodicAdvertiserListComplete != NULL) {
892 callbacks->leRemoveDeviceFromPeriodicAdvertiserListComplete(&returnParam);
893 }
894 HCI_FOREACH_EVT_CALLBACKS_END;
895 }
896
HciEventOnLeClearPeriodicAdvertiserListComplete(const void * param,uint8_t length)897 static void HciEventOnLeClearPeriodicAdvertiserListComplete(const void *param, uint8_t length)
898 {
899 HciLeClearPeriodicAdvertiserListReturnParam returnParam = {0};
900 (void)memcpy_s(
901 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
902
903 HciEventCallbacks *callbacks = NULL;
904 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
905 if (callbacks->leClearPeriodicAdvertiserListComplete != NULL) {
906 callbacks->leClearPeriodicAdvertiserListComplete(&returnParam);
907 }
908 HCI_FOREACH_EVT_CALLBACKS_END;
909 }
910
HciEventOnLeReadPeriodicAdvertiserListSizeComplete(const void * param,uint8_t length)911 static void HciEventOnLeReadPeriodicAdvertiserListSizeComplete(const void *param, uint8_t length)
912 {
913 HciLeReadPeriodicAdvertiserListSizeReturnParam returnParam = {0};
914 (void)memcpy_s(
915 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
916
917 HciEventCallbacks *callbacks = NULL;
918 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
919 if (callbacks->leReadPeriodicAdvertiserListSizeComplete != NULL) {
920 callbacks->leReadPeriodicAdvertiserListSizeComplete(&returnParam);
921 }
922 HCI_FOREACH_EVT_CALLBACKS_END;
923 }
924
HciEventOnLeReadTransmitPowerComplete(const void * param,uint8_t length)925 static void HciEventOnLeReadTransmitPowerComplete(const void *param, uint8_t length)
926 {
927 HciLeReadTransmitPowerReturnParam returnParam = {0};
928 (void)memcpy_s(
929 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
930
931 HciEventCallbacks *callbacks = NULL;
932 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
933 if (callbacks->leReadTransmitPowerComplete != NULL) {
934 callbacks->leReadTransmitPowerComplete(&returnParam);
935 }
936 HCI_FOREACH_EVT_CALLBACKS_END;
937 }
938
HciEventOnLeReadRFPathCompensationComplete(const void * param,uint8_t length)939 static void HciEventOnLeReadRFPathCompensationComplete(const void *param, uint8_t length)
940 {
941 HciLeReadRfPathCompensationReturnParam returnParam = {0};
942 (void)memcpy_s(
943 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
944
945 HciEventCallbacks *callbacks = NULL;
946 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
947 if (callbacks->leReadRfPathCompensationComplete != NULL) {
948 callbacks->leReadRfPathCompensationComplete(&returnParam);
949 }
950 HCI_FOREACH_EVT_CALLBACKS_END;
951 }
952
HciEventOnLeWriteRFPathCompensationComplete(const void * param,uint8_t length)953 static void HciEventOnLeWriteRFPathCompensationComplete(const void *param, uint8_t length)
954 {
955 HciLeWriteRfPathCompensationReturnParam returnParam = {0};
956 (void)memcpy_s(
957 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
958
959 HciEventCallbacks *callbacks = NULL;
960 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
961 if (callbacks->leWriteRfPathCompensationComplete != NULL) {
962 callbacks->leWriteRfPathCompensationComplete(&returnParam);
963 }
964 HCI_FOREACH_EVT_CALLBACKS_END;
965 }
966
HciEventOnLeSetPrivacyModeComplete(const void * param,uint8_t length)967 static void HciEventOnLeSetPrivacyModeComplete(const void *param, uint8_t length)
968 {
969 HciLeSetPrivacyModeReturnParam returnParam = {0};
970 (void)memcpy_s(
971 &returnParam, sizeof(returnParam), param, (length > sizeof(returnParam)) ? sizeof(returnParam) : length);
972
973 HciEventCallbacks *callbacks = NULL;
974 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
975 if (callbacks->leSetPrivacyModeComplete != NULL) {
976 callbacks->leSetPrivacyModeComplete(&returnParam);
977 }
978 HCI_FOREACH_EVT_CALLBACKS_END;
979 }
980
981 static HciLeCmdCompleteFunc g_leControllerCommandCompleteMap[] = {
982 NULL, // 0x0000
983 HciEventOnLeSetEventMaskComplete, // 0x0001
984 HciEventOnLeReadBufferSizeComplete, // 0x0002
985 HciEventOnLeReadLocalSupportedFeaturesComplete, // 0x0003
986 NULL, // 0x0004
987 HciEventOnLeSetRandomAddressComplete, // 0x0005
988 HciEventOnLeSetAdvertisingParametersComplete, // 0x0006
989 HciEventOnLeReadAdvertisingChannelTxPowerComplete, // 0x0007
990 HciEventOnLeSetAdvertisingDataComplete, // 0x0008
991 HciEventOnLeSetScanResponseDataComplete, // 0x0009
992 HciEventOnLeSetAdvertisingEnableComplete, // 0x000A
993 HciEventOnLeSetScanParametersComplete, // 0x000B
994 HciEventOnLeSetScanEnableComplete, // 0x000C
995 NULL, // 0x000D
996 HciEventOnLeCreateConnectionCancelComplete, // 0x000E
997 HciEventOnLeReadWhiteListSizeComplete, // 0x000F
998 HciEventOnLeClearWhiteListComplete, // 0x0010
999 HciEventOnLeAddDeviceToWhiteListComplete, // 0x0011
1000 HciEventOnLeRemoveDeviceFromWhiteListComplete, // 0x0012
1001 NULL, // 0x0013
1002 HciEventOnLeSetHostChannelClassificationComplete, // 0x0014
1003 HciEventOnLeReadChannelMapComplete, // 0x0015
1004 NULL, // 0x0016
1005 HciEventOnLeEncryptComplete, // 0x0017
1006 HciEventOnLeRandComplete, // 0x0018
1007 NULL, // 0x0019
1008 HciEventOnLeLongTermKeyRequestReplyComplete, // 0x001A
1009 HciEventOnLeLongTermKeyRequestNegativeReplyComplete, // 0x001B
1010 HciEventOnLeReadSupportedStatesComplete, // 0x001C
1011 HciEventOnLeReceiverTestComplete, // 0x001D
1012 HciEventOnLeTransmitterTestComplete, // 0x001E
1013 HciEventOnLeTestEndComplete, // 0x001F
1014 HciEventOnLeRemoteConnectionParameterRequestReplyComplete, // 0x0020
1015 HciEventOnLeRemoteConnectionParameterRequestNegativeReplyComplete, // 0x0021
1016 HciEventOnLeSetDataLengthComplete, // 0x0022
1017 HciEventOnLeReadSuggestedDefaultDataLengthComplete, // 0x0023
1018 HciEventOnLeWriteSuggestedDefaultDataLengthComplete, // 0x0024
1019 NULL, // 0x0025
1020 NULL, // 0x0026
1021 HciEventOnLeAddDeviceToResolvingListComplete, // 0x0027
1022 HciEventOnLeRemoveDeviceFromResolvingListComplete, // 0x0028
1023 HciEventOnLeClearResolvingListComplete, // 0x0029
1024 HciEventOnLeReadResolvingListSizeComplete, // 0x002A
1025 HciEventOnLeReadPeerResolvableAddressComplete, // 0x002B
1026 HciEventOnLeReadLocalResolvableAddressComplete, // 0x002C
1027 HciEventOnLeSetAddressResolutionEnableComplete, // 0x002D
1028 HciEventOnSetResolvablePrivateAddressTimeoutComplete, // 0x002E
1029 HciEventOnLeReadMaximumDataLengthComplete, // 0x002F
1030 HciEventOnLeReadPhyComplete, // 0x0030
1031 HciEventOnLeSetDefaultPhyComplete, // 0x0031
1032 NULL, // 0x0032
1033 HciEventOnLeEnhancedReceiverTestComplete, // 0x0033
1034 HciEventOnLeEnhancedTransmitterTestComplete, // 0x0034
1035 HciEventOnLeSetAdvertisingSetRandomAddressComplete, // 0x0035
1036 HciEventOnLeSetExtendedAdvertisingParametersComplete, // 0x0036
1037 HciEventOnLeSetExtendedAdvertisingDataComplete, // 0x0037
1038 HciEventOnLeSetExtendedScanResponseDataComplete, // 0x0038
1039 HciEventOnLeSetExtendedAdvertisingEnableComplete, // 0x0039
1040 HciEventOnLeReadMaximumAdvertisingDataLengthComplete, // 0x003A
1041 HciEventOnLeReadNumberofSupportedAdvertisingSetsComplete, // 0x003B
1042 HciEventOnLeRemoveAdvertisingSetComplete, // 0x003C
1043 HciEventOnLeClearAdvertisingSetsComplete, // 0x003D
1044 HciEventOnLeSetPeriodicAdvertisingParametersComplete, // 0x003E
1045 HciEventOnLeSetPeriodicAdvertisingDataComplete, // 0x003F
1046 HciEventOnLeSetPeriodicAdvertisingEnableComplete, // 0x0040
1047 HciEventOnLeSetExtendedScanParametersComplete, // 0x0041
1048 HciEventOnLeSetExtendedScanEnableComplete, // 0x0042
1049 NULL, // 0x0043
1050 NULL, // 0x0044
1051 HciEventOnLePeriodicAdvertisingCreateSyncCancelComplete, // 0x0045
1052 HciEventOnLePeriodicAdvertisingTerminateSyncComplete, // 0x0046
1053 HciEventOnLeAddDeviceToPeriodicAdvertiserListComplete, // 0x0047
1054 HciEventOnLeRemoveDeviceFromPeriodicAdvertiserListComplete, // 0x0048
1055 HciEventOnLeClearPeriodicAdvertiserListComplete, // 0x0049
1056 HciEventOnLeReadPeriodicAdvertiserListSizeComplete, // 0x004A
1057 HciEventOnLeReadTransmitPowerComplete, // 0x004B
1058 HciEventOnLeReadRFPathCompensationComplete, // 0x004C
1059 HciEventOnLeWriteRFPathCompensationComplete, // 0x004D
1060 HciEventOnLeSetPrivacyModeComplete, // 0x004E
1061 };
1062
1063 #define LECONTROLLER_OCF_MAX 0x004E
1064
HciEventOnLeCommandComplete(uint16_t opCode,const void * param,uint8_t length)1065 void HciEventOnLeCommandComplete(uint16_t opCode, const void *param, uint8_t length)
1066 {
1067 uint16_t ocf = GET_OCF(opCode);
1068 if (ocf > LECONTROLLER_OCF_MAX) {
1069 return;
1070 }
1071
1072 HciLeCmdCompleteFunc func = g_leControllerCommandCompleteMap[ocf];
1073 if (func != NULL) {
1074 func(param, length);
1075 }
1076 }