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_cmd_failure_le_controller.h"
17
18 #include "btstack.h"
19 #include "platform/include/list.h"
20
21 #include "hci/evt/hci_evt.h"
22 #include "hci/hci.h"
23 #include "hci/hci_def.h"
24
25 #include "hci_cmd_failure.h"
26
HciCmdOnLeSetEventMaskFailed(uint8_t status,const void * param)27 static void HciCmdOnLeSetEventMaskFailed(uint8_t status, const void *param)
28 {
29 HciLeSetEventMaskReturnParam returnParam = {
30 .status = status,
31 };
32
33 HciEventCallbacks *callbacks = NULL;
34 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
35 if (callbacks->leSetEventMaskComplete != NULL) {
36 callbacks->leSetEventMaskComplete(&returnParam);
37 }
38 HCI_FOREACH_EVT_CALLBACKS_END;
39 }
40
HciCmdOnLeReadBufferSizeFailed(uint8_t status,const void * param)41 static void HciCmdOnLeReadBufferSizeFailed(uint8_t status, const void *param)
42 {
43 HciLeReadBufferSizeReturnParam returnParam = {
44 .status = status,
45 };
46
47 HciEventCallbacks *callbacks = NULL;
48 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
49 if (callbacks->leReadBufferSizeComplete != NULL) {
50 callbacks->leReadBufferSizeComplete(&returnParam);
51 }
52 HCI_FOREACH_EVT_CALLBACKS_END;
53 }
54
HciCmdOnLeReadLocalSupportedFeaturesFailed(uint8_t status,const void * param)55 static void HciCmdOnLeReadLocalSupportedFeaturesFailed(uint8_t status, const void *param)
56 {
57 HciLeReadLocalSupportedFeaturesReturnParam returnParam = {
58 .status = status,
59 };
60
61 HciEventCallbacks *callbacks = NULL;
62 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
63 if (callbacks->leReadLocalSupportedFeaturesComplete != NULL) {
64 callbacks->leReadLocalSupportedFeaturesComplete(&returnParam);
65 }
66 HCI_FOREACH_EVT_CALLBACKS_END;
67 }
68
HciCmdOnLeSetRandomAddressFailed(uint8_t status,const void * param)69 static void HciCmdOnLeSetRandomAddressFailed(uint8_t status, const void *param)
70 {
71 HciLeSetRandomAddressReturnParam returnParam = {
72 .status = status,
73 };
74
75 HciEventCallbacks *callbacks = NULL;
76 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
77 if (callbacks->leSetRandomAddressComplete != NULL) {
78 callbacks->leSetRandomAddressComplete(&returnParam);
79 }
80 HCI_FOREACH_EVT_CALLBACKS_END;
81 }
82
HciCmdOnLeSetAdvertisingParametersFailed(uint8_t status,const void * param)83 static void HciCmdOnLeSetAdvertisingParametersFailed(uint8_t status, const void *param)
84 {
85 HciLeSetAdvertisingParametersReturnParam returnParam = {
86 .status = status,
87 };
88
89 HciEventCallbacks *callbacks = NULL;
90 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
91 if (callbacks->leSetAdvertisingParametersComplete != NULL) {
92 callbacks->leSetAdvertisingParametersComplete(&returnParam);
93 }
94 HCI_FOREACH_EVT_CALLBACKS_END;
95 }
96
HciCmdOnReadAdvertisingChannelTxPowerFailed(uint8_t status,const void * param)97 static void HciCmdOnReadAdvertisingChannelTxPowerFailed(uint8_t status, const void *param)
98 {
99 HciLeReadAdvertisingChannelTxPowerReturnParam returnParam = {
100 .status = status,
101 };
102
103 HciEventCallbacks *callbacks = NULL;
104 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
105 if (callbacks->leReadAdvertisingChannelTxPowerComplete != NULL) {
106 callbacks->leReadAdvertisingChannelTxPowerComplete(&returnParam);
107 }
108 HCI_FOREACH_EVT_CALLBACKS_END;
109 }
110
HciCmdOnLeSetAdvertisingDataFailed(uint8_t status,const void * param)111 static void HciCmdOnLeSetAdvertisingDataFailed(uint8_t status, const void *param)
112 {
113 HciLeSetAdvertisingDataReturnParam returnParam = {
114 .status = status,
115 };
116
117 HciEventCallbacks *callbacks = NULL;
118 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
119 if (callbacks->leSetAdvertisingDataComplete != NULL) {
120 callbacks->leSetAdvertisingDataComplete(&returnParam);
121 }
122 HCI_FOREACH_EVT_CALLBACKS_END;
123 }
124
HciCmdOnLeSetScanResponseDataFailed(uint8_t status,const void * param)125 static void HciCmdOnLeSetScanResponseDataFailed(uint8_t status, const void *param)
126 {
127 HciLeSetScanResponseDataReturnParam returnParam = {
128 .status = status,
129 };
130
131 HciEventCallbacks *callbacks = NULL;
132 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
133 if (callbacks->leSetScanResponseDataComplete != NULL) {
134 callbacks->leSetScanResponseDataComplete(&returnParam);
135 }
136 HCI_FOREACH_EVT_CALLBACKS_END;
137 }
138
HciCmdOnLeSetAdvertisingEnableFailed(uint8_t status,const void * param)139 static void HciCmdOnLeSetAdvertisingEnableFailed(uint8_t status, const void *param)
140 {
141 HciLeSetAdvertisingEnableReturnParam returnParam = {
142 .status = status,
143 };
144
145 HciEventCallbacks *callbacks = NULL;
146 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
147 if (callbacks->leSetAdvertisingEnableComplete != NULL) {
148 callbacks->leSetAdvertisingEnableComplete(&returnParam);
149 }
150 HCI_FOREACH_EVT_CALLBACKS_END;
151 }
152
HciCmdOnLeSetScanParametersFailed(uint8_t status,const void * param)153 static void HciCmdOnLeSetScanParametersFailed(uint8_t status, const void *param)
154 {
155 HciLeSetScanParametersReturnParam returnParam = {
156 .status = status,
157 };
158
159 HciEventCallbacks *callbacks = NULL;
160 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
161 if (callbacks->leSetScanParametersComplete != NULL) {
162 callbacks->leSetScanParametersComplete(&returnParam);
163 }
164 HCI_FOREACH_EVT_CALLBACKS_END;
165 }
166
HciCmdOnLeSetScanEnableFailed(uint8_t status,const void * param)167 static void HciCmdOnLeSetScanEnableFailed(uint8_t status, const void *param)
168 {
169 HciLeSetScanEnableReturnParam returnParam = {
170 .status = status,
171 };
172
173 HciEventCallbacks *callbacks = NULL;
174 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
175 if (callbacks->leSetScanEnableComplete != NULL) {
176 callbacks->leSetScanEnableComplete(&returnParam);
177 }
178 HCI_FOREACH_EVT_CALLBACKS_END;
179 }
180
HciCmdOnLeCreateConnectionFailed(uint8_t status,const void * param)181 static void HciCmdOnLeCreateConnectionFailed(uint8_t status, const void *param)
182 {
183 HciLeConnectionCompleteEventParam eventParam = {
184 .status = status,
185 .peerAddress = ((HciLeCreateConnectionParam *)param)->peerAddress,
186 .peerAddressType = ((HciLeCreateConnectionParam *)param)->peerAddressType,
187 };
188
189 HciEventCallbacks *callbacks = NULL;
190 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
191 if (callbacks->leConnectionComplete != NULL) {
192 callbacks->leConnectionComplete(&eventParam);
193 }
194 HCI_FOREACH_EVT_CALLBACKS_END;
195 }
196
HciCmdOnLeCreateConnectionCancelFailed(uint8_t status,const void * param)197 static void HciCmdOnLeCreateConnectionCancelFailed(uint8_t status, const void *param)
198 {
199 HciLeCreateConnectionCancelReturnParam returnParam = {
200 .status = status,
201 };
202
203 HciEventCallbacks *callbacks = NULL;
204 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
205 if (callbacks->leCreateConnectionCancelComplete != NULL) {
206 callbacks->leCreateConnectionCancelComplete(&returnParam);
207 }
208 HCI_FOREACH_EVT_CALLBACKS_END;
209 }
210
HciCmdOnLeReadWhiteListSizeFailed(uint8_t status,const void * param)211 static void HciCmdOnLeReadWhiteListSizeFailed(uint8_t status, const void *param)
212 {
213 HciLeReadWhiteListSizeReturnParam returnParam = {
214 .status = status,
215 };
216
217 HciEventCallbacks *callbacks = NULL;
218 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
219 if (callbacks->leReadWhiteListSizeComplete != NULL) {
220 callbacks->leReadWhiteListSizeComplete(&returnParam);
221 }
222 HCI_FOREACH_EVT_CALLBACKS_END;
223 }
224
HciCmdOnLeClearWhiteListFailed(uint8_t status,const void * param)225 static void HciCmdOnLeClearWhiteListFailed(uint8_t status, const void *param)
226 {
227 HciLeClearWhiteListReturnParam returnParam = {
228 .status = status,
229 };
230
231 HciEventCallbacks *callbacks = NULL;
232 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
233 if (callbacks->leClearWhiteListComplete != NULL) {
234 callbacks->leClearWhiteListComplete(&returnParam);
235 }
236 HCI_FOREACH_EVT_CALLBACKS_END;
237 }
238
HciCmdOnLeAddDeviceToWhiteListFailed(uint8_t status,const void * param)239 static void HciCmdOnLeAddDeviceToWhiteListFailed(uint8_t status, const void *param)
240 {
241 HciLeAddDeviceToWhiteListReturnParam returnParam = {
242 .status = status,
243 };
244
245 HciEventCallbacks *callbacks = NULL;
246 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
247 if (callbacks->leAddDeviceToWhiteListComplete != NULL) {
248 callbacks->leAddDeviceToWhiteListComplete(&returnParam);
249 }
250 HCI_FOREACH_EVT_CALLBACKS_END;
251 }
252
HciCmdOnLeRemoveDeviceFromWhiteListFailed(uint8_t status,const void * param)253 static void HciCmdOnLeRemoveDeviceFromWhiteListFailed(uint8_t status, const void *param)
254 {
255 HciLeRemoveDeviceFromWhiteListReturnParam returnParam = {
256 .status = status,
257 };
258
259 HciEventCallbacks *callbacks = NULL;
260 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
261 if (callbacks->leRemoveDeviceFromWhiteListComplete != NULL) {
262 callbacks->leRemoveDeviceFromWhiteListComplete(&returnParam);
263 }
264 HCI_FOREACH_EVT_CALLBACKS_END;
265 }
266
HciCmdOnLeConnectionUpdateFailed(uint8_t status,const void * param)267 static void HciCmdOnLeConnectionUpdateFailed(uint8_t status, const void *param)
268 {
269 HciLeConnectionUpdateCompleteEventParam eventParam = {
270 .status = status,
271 .connectionHandle = ((HciLeConnectionUpdateParam *)param)->connectionHandle,
272 .connLatency = ((HciLeConnectionUpdateParam *)param)->connLatency,
273 .supervisionTimeout = ((HciLeConnectionUpdateParam *)param)->supervisionTimeout,
274 };
275
276 HciEventCallbacks *callbacks = NULL;
277 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
278 if (callbacks->leConnectionUpdateComplete != NULL) {
279 callbacks->leConnectionUpdateComplete(&eventParam);
280 }
281 HCI_FOREACH_EVT_CALLBACKS_END;
282 }
283
HciCmdOnLeSetHostChannelClassificationFailed(uint8_t status,const void * param)284 static void HciCmdOnLeSetHostChannelClassificationFailed(uint8_t status, const void *param)
285 {
286 HciLeSetHostChannelClassificationReturnParam returnParam = {
287 .status = status,
288 };
289
290 HciEventCallbacks *callbacks = NULL;
291 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
292 if (callbacks->leSetHostChannelClassificationComplete != NULL) {
293 callbacks->leSetHostChannelClassificationComplete(&returnParam);
294 }
295 HCI_FOREACH_EVT_CALLBACKS_END;
296 }
297
HciCmdOnLeReadChannelMapFailed(uint8_t status,const void * param)298 static void HciCmdOnLeReadChannelMapFailed(uint8_t status, const void *param)
299 {
300 HciLeReadChannelMapReturnParam returnParam = {
301 .status = status,
302 .connectionHandle = ((HciLeReadChannelMapParam *)param)->connectionHandle,
303 };
304
305 HciEventCallbacks *callbacks = NULL;
306 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
307 if (callbacks->leReadChannelMapComplete != NULL) {
308 callbacks->leReadChannelMapComplete(&returnParam);
309 }
310 HCI_FOREACH_EVT_CALLBACKS_END;
311 }
312
HciCmdOnLeReadRemoteFeaturesFailed(uint8_t status,const void * param)313 static void HciCmdOnLeReadRemoteFeaturesFailed(uint8_t status, const void *param)
314 {
315 HciLeReadRemoteFeaturesCompleteEventParam eventParam = {
316 .status = status,
317 .connectionHandle = ((HciLeReadRemoteFeaturesParam *)param)->connectionHandle,
318 };
319
320 HciEventCallbacks *callbacks = NULL;
321 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
322 if (callbacks->leReadRemoteFeaturesComplete != NULL) {
323 callbacks->leReadRemoteFeaturesComplete(&eventParam);
324 }
325 HCI_FOREACH_EVT_CALLBACKS_END;
326 }
327
HciCmdOnLeEncryptFailed(uint8_t status,const void * param)328 static void HciCmdOnLeEncryptFailed(uint8_t status, const void *param)
329 {
330 HciLeEncryptReturnParam returnParam = {
331 .status = status,
332 };
333
334 HciEventCallbacks *callbacks = NULL;
335 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
336 if (callbacks->leEncryptComplete != NULL) {
337 callbacks->leEncryptComplete(&returnParam);
338 }
339 HCI_FOREACH_EVT_CALLBACKS_END;
340 }
341
HciCmdOnLeRandFailed(uint8_t status,const void * param)342 static void HciCmdOnLeRandFailed(uint8_t status, const void *param)
343 {
344 HciLeRandReturnParam returnParam = {
345 .status = status,
346 };
347
348 HciEventCallbacks *callbacks = NULL;
349 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
350 if (callbacks->leRandComplete != NULL) {
351 callbacks->leRandComplete(&returnParam);
352 }
353 HCI_FOREACH_EVT_CALLBACKS_END;
354 }
355
HciCmdOnLeStartEncryptionFailed(uint8_t status,const void * param)356 static void HciCmdOnLeStartEncryptionFailed(uint8_t status, const void *param)
357 {
358 HciEncryptionKeyRefreshCompleteEventParam eventParam = {
359 .status = status,
360 .connectionHandle = ((HciLeStartEncryptionParam *)param)->connectionHandle,
361 };
362
363 HciEventCallbacks *callbacks = NULL;
364 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
365 if (callbacks->encryptionKeyRefreshComplete != NULL) {
366 callbacks->encryptionKeyRefreshComplete(&eventParam);
367 }
368 HCI_FOREACH_EVT_CALLBACKS_END;
369 }
370
HciCmdOnLeLongTermKeyRequestReplyFailed(uint8_t status,const void * param)371 static void HciCmdOnLeLongTermKeyRequestReplyFailed(uint8_t status, const void *param)
372 {
373 HciLeLongTermKeyRequestReplyReturnParam returnParam = {
374 .status = status,
375 .connectionHandle = ((HciLeLongTermKeyRequestReplyParam *)param)->connectionHandle,
376 };
377
378 HciEventCallbacks *callbacks = NULL;
379 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
380 if (callbacks->leLongTermKeyRequestReplyComplete != NULL) {
381 callbacks->leLongTermKeyRequestReplyComplete(&returnParam);
382 }
383 HCI_FOREACH_EVT_CALLBACKS_END;
384 }
385
HciCmdOnLeLongTermKeyRequestNegativeReplyFailed(uint8_t status,const void * param)386 static void HciCmdOnLeLongTermKeyRequestNegativeReplyFailed(uint8_t status, const void *param)
387 {
388 HciLeLongTermKeyRequestNegativeReplyReturnParam returnParam = {
389 .status = status,
390 .connectionHandle = ((HciLeLongTermKeyRequestNegativeReplyParam *)param)->connectionHandle,
391 };
392
393 HciEventCallbacks *callbacks = NULL;
394 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
395 if (callbacks->leLongTermKeyRequestNegativeReplyComplete != NULL) {
396 callbacks->leLongTermKeyRequestNegativeReplyComplete(&returnParam);
397 }
398 HCI_FOREACH_EVT_CALLBACKS_END;
399 }
400
HciCmdOnLeReadSupportedStatesFailed(uint8_t status,const void * param)401 static void HciCmdOnLeReadSupportedStatesFailed(uint8_t status, const void *param)
402 {
403 HciLeReadSupportedStatesReturnParam returnParam = {
404 .status = status,
405 };
406
407 HciEventCallbacks *callbacks = NULL;
408 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
409 if (callbacks->leReadSupportedStatesComplete != NULL) {
410 callbacks->leReadSupportedStatesComplete(&returnParam);
411 }
412 HCI_FOREACH_EVT_CALLBACKS_END;
413 }
414
HciCmdOnLeReceiverTestFailed(uint8_t status,const void * param)415 static void HciCmdOnLeReceiverTestFailed(uint8_t status, const void *param)
416 {
417 HciLeReceiverTestReturnParam returnParam = {
418 .status = status,
419 };
420
421 HciEventCallbacks *callbacks = NULL;
422 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
423 if (callbacks->leReceiverTestComplete != NULL) {
424 callbacks->leReceiverTestComplete(&returnParam);
425 }
426 HCI_FOREACH_EVT_CALLBACKS_END;
427 }
428
HciCmdOnLeTransmitterTestFailed(uint8_t status,const void * param)429 static void HciCmdOnLeTransmitterTestFailed(uint8_t status, const void *param)
430 {
431 HciLeTransmitterTestReturnParam returnParam = {
432 .status = status,
433 };
434
435 HciEventCallbacks *callbacks = NULL;
436 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
437 if (callbacks->leTransmitterTestComplete != NULL) {
438 callbacks->leTransmitterTestComplete(&returnParam);
439 }
440 HCI_FOREACH_EVT_CALLBACKS_END;
441 }
442
HciCmdOnLeTestEndFailed(uint8_t status,const void * param)443 static void HciCmdOnLeTestEndFailed(uint8_t status, const void *param)
444 {
445 HciLeTestEndReturnParam returnParam = {
446 .status = status,
447 };
448
449 HciEventCallbacks *callbacks = NULL;
450 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
451 if (callbacks->leTestEndComplete != NULL) {
452 callbacks->leTestEndComplete(&returnParam);
453 }
454 HCI_FOREACH_EVT_CALLBACKS_END;
455 }
456
HciCmdOnLeRemoteConnectionParameterRequestFailed(uint8_t status,const void * param)457 static void HciCmdOnLeRemoteConnectionParameterRequestFailed(uint8_t status, const void *param)
458 {
459 HciLeRemoteConnectionParameterRequestReplyReturnParam returnParam = {
460 .status = status,
461 .connectionHandle = ((HciLeRemoteConnectionParameterRequestReplyParam *)param)->connectionHandle,
462 };
463
464 HciEventCallbacks *callbacks = NULL;
465 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
466 if (callbacks->leRemoteConnectionParameterRequestReplyComplete != NULL) {
467 callbacks->leRemoteConnectionParameterRequestReplyComplete(&returnParam);
468 }
469 HCI_FOREACH_EVT_CALLBACKS_END;
470 }
471
HciCmdOnLeRemoteConnectionParameterRequestNegativeReplyFailed(uint8_t status,const void * param)472 static void HciCmdOnLeRemoteConnectionParameterRequestNegativeReplyFailed(uint8_t status, const void *param)
473 {
474 HciLeRemoteConnectionParameterRequestNegativeReplyReturnParam returnParam = {
475 .status = status,
476 .connectionHandle = ((HciLeRemoteConnectionParameterRequestNegativeReplyParam *)param)->connectionHandle,
477 };
478
479 HciEventCallbacks *callbacks = NULL;
480 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
481 if (callbacks->leRemoteConnectionParameterRequestNegativeReplyComplete != NULL) {
482 callbacks->leRemoteConnectionParameterRequestNegativeReplyComplete(&returnParam);
483 }
484 HCI_FOREACH_EVT_CALLBACKS_END;
485 }
486
HciCmdOnLeSetDataLengthFailed(uint8_t status,const void * param)487 static void HciCmdOnLeSetDataLengthFailed(uint8_t status, const void *param)
488 {
489 HciLeSetDataLengthReturnParam returnParam = {
490 .status = status,
491 .connectionHandle = ((HciLeSetDataLengthReturnParam *)param)->connectionHandle,
492 };
493
494 MutexUnlock(HciGetEventCallbackListLock());
495
496 HciEventCallbacks *callbacks = NULL;
497 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
498 if (callbacks->leSetDataLengthComplete != NULL) {
499 callbacks->leSetDataLengthComplete(&returnParam);
500 }
501 HCI_FOREACH_EVT_CALLBACKS_END;
502 }
503
HciCmdOnLeReadSuggestedDefaultDataLengthFailed(uint8_t status,const void * param)504 static void HciCmdOnLeReadSuggestedDefaultDataLengthFailed(uint8_t status, const void *param)
505 {
506 HciLeReadSuggestedDefaultDataLengthReturnParam returnParam = {
507 .status = status,
508 };
509
510 HciEventCallbacks *callbacks = NULL;
511 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
512 if (callbacks->leReadSuggestedDefaultDataLengthComplete != NULL) {
513 callbacks->leReadSuggestedDefaultDataLengthComplete(&returnParam);
514 }
515 HCI_FOREACH_EVT_CALLBACKS_END;
516 }
517
HciCmdOnLeWriteSuggestedDefaultDataLengthFailed(uint8_t status,const void * param)518 static void HciCmdOnLeWriteSuggestedDefaultDataLengthFailed(uint8_t status, const void *param)
519 {
520 HciLeWriteSuggestedDefaultDataLengthReturnParam returnParam = {
521 .status = status,
522 };
523
524 HciEventCallbacks *callbacks = NULL;
525 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
526 if (callbacks->leWriteSuggestedDefaultDataLengthComplete != NULL) {
527 callbacks->leWriteSuggestedDefaultDataLengthComplete(&returnParam);
528 }
529 HCI_FOREACH_EVT_CALLBACKS_END;
530 }
531
HciCmdOnLeReadLocalP256PublicKeyFailed(uint8_t status,const void * param)532 static void HciCmdOnLeReadLocalP256PublicKeyFailed(uint8_t status, const void *param)
533 {
534 HciLeReadLocalP256PublicKeyCompleteEventParam eventParam = {
535 .status = status,
536 };
537
538 HciEventCallbacks *callbacks = NULL;
539 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
540 if (callbacks->leReadLocalP256PublicKeyComplete != NULL) {
541 callbacks->leReadLocalP256PublicKeyComplete(&eventParam);
542 }
543 HCI_FOREACH_EVT_CALLBACKS_END;
544 }
545
HciCmdOnLeGenerateDhKeyFailed(uint8_t status,const void * param)546 static void HciCmdOnLeGenerateDhKeyFailed(uint8_t status, const void *param)
547 {
548 HciLeGenerateDHKeyCompleteEventParam eventParam = {
549 .status = status,
550 };
551
552 HciEventCallbacks *callbacks = NULL;
553 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
554 if (callbacks->leGenerateDHKeyComplete != NULL) {
555 callbacks->leGenerateDHKeyComplete(&eventParam);
556 }
557 HCI_FOREACH_EVT_CALLBACKS_END;
558 }
559
HciCmdOnLeAddDeviceToResolvingListFailed(uint8_t status,const void * param)560 static void HciCmdOnLeAddDeviceToResolvingListFailed(uint8_t status, const void *param)
561 {
562 HciLeAddDeviceToResolvingListReturnParam returnParam = {
563 .status = status,
564 };
565
566 HciEventCallbacks *callbacks = NULL;
567 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
568 if (callbacks->leAddDeviceToResolvingListComplete != NULL) {
569 callbacks->leAddDeviceToResolvingListComplete(&returnParam);
570 }
571 HCI_FOREACH_EVT_CALLBACKS_END;
572 }
573
HciCmdOnLeRemoveDeviceFromResolvingListFailed(uint8_t status,const void * param)574 static void HciCmdOnLeRemoveDeviceFromResolvingListFailed(uint8_t status, const void *param)
575 {
576 HciLeRemoveDeviceFromResolvingListReturnParam returnParam = {
577 .status = status,
578 };
579
580 HciEventCallbacks *callbacks = NULL;
581 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
582 if (callbacks->leRemoveDeviceFromResolvingListComplete != NULL) {
583 callbacks->leRemoveDeviceFromResolvingListComplete(&returnParam);
584 }
585 HCI_FOREACH_EVT_CALLBACKS_END;
586 }
587
HciCmdOnLeClearResolvingListFailed(uint8_t status,const void * param)588 static void HciCmdOnLeClearResolvingListFailed(uint8_t status, const void *param)
589 {
590 HciLeClearResolvingListReturnParam returnParam = {
591 .status = status,
592 };
593
594 HciEventCallbacks *callbacks = NULL;
595 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
596 if (callbacks->leClearResolvingListComplete != NULL) {
597 callbacks->leClearResolvingListComplete(&returnParam);
598 }
599 HCI_FOREACH_EVT_CALLBACKS_END;
600 }
601
HciCmdOnLeReadResolvingListSizeFailed(uint8_t status,const void * param)602 static void HciCmdOnLeReadResolvingListSizeFailed(uint8_t status, const void *param)
603 {
604 HciLeReadResolvingListSizeReturnParam returnParam = {
605 .status = status,
606 };
607
608 HciEventCallbacks *callbacks = NULL;
609 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
610 if (callbacks->leReadResolvingListSizeComplete != NULL) {
611 callbacks->leReadResolvingListSizeComplete(&returnParam);
612 }
613 HCI_FOREACH_EVT_CALLBACKS_END;
614 }
615
HciCmdOnLeReadPeerResolvableAddressFailed(uint8_t status,const void * param)616 static void HciCmdOnLeReadPeerResolvableAddressFailed(uint8_t status, const void *param)
617 {
618 HciLeReadPeerResolvableAddressReturnParam returnParam = {
619 .status = status,
620 };
621
622 HciEventCallbacks *callbacks = NULL;
623 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
624 if (callbacks->leReadPeerResolvableAddressComplete != NULL) {
625 callbacks->leReadPeerResolvableAddressComplete(&returnParam);
626 }
627 HCI_FOREACH_EVT_CALLBACKS_END;
628 }
629
HciCmdOnLeReadLocalResolvableAddressFailed(uint8_t status,const void * param)630 static void HciCmdOnLeReadLocalResolvableAddressFailed(uint8_t status, const void *param)
631 {
632 HciLeReadLocalResolvableAddressReturnParam returnParam = {
633 .status = status,
634 };
635
636 HciEventCallbacks *callbacks = NULL;
637 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
638 if (callbacks->leReadLocalResolvableAddressComplete != NULL) {
639 callbacks->leReadLocalResolvableAddressComplete(&returnParam);
640 }
641 HCI_FOREACH_EVT_CALLBACKS_END;
642 }
643
HciCmdOnLeSetAddressResolutionEnableFailed(uint8_t status,const void * param)644 static void HciCmdOnLeSetAddressResolutionEnableFailed(uint8_t status, const void *param)
645 {
646 HciLeSetAddressResolutionEnableReturnParam returnParam = {
647 .status = status,
648 };
649
650 HciEventCallbacks *callbacks = NULL;
651 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
652 if (callbacks->leSetAddressResolutionEnableComplete != NULL) {
653 callbacks->leSetAddressResolutionEnableComplete(&returnParam);
654 }
655 HCI_FOREACH_EVT_CALLBACKS_END;
656 }
657
HciCmdOnLeSetResolvablePrivateAddressTimeoutFailed(uint8_t status,const void * param)658 static void HciCmdOnLeSetResolvablePrivateAddressTimeoutFailed(uint8_t status, const void *param)
659 {
660 HciLeSetResolvablePrivateAddressTimeoutReturnParam returnParam = {
661 .status = status,
662 };
663
664 HciEventCallbacks *callbacks = NULL;
665 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
666 if (callbacks->leSetResolvablePrivateAddressTimeoutComplete != NULL) {
667 callbacks->leSetResolvablePrivateAddressTimeoutComplete(&returnParam);
668 }
669 HCI_FOREACH_EVT_CALLBACKS_END;
670 }
671
HciCmdOnLeReadMaximumDataLengthFailed(uint8_t status,const void * param)672 static void HciCmdOnLeReadMaximumDataLengthFailed(uint8_t status, const void *param)
673 {
674 HciLeReadMaximumDataLengthReturnParam returnParam = {
675 .status = status,
676 };
677
678 HciEventCallbacks *callbacks = NULL;
679 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
680 if (callbacks->leReadMaximumDataLengthComplete != NULL) {
681 callbacks->leReadMaximumDataLengthComplete(&returnParam);
682 }
683 HCI_FOREACH_EVT_CALLBACKS_END;
684 }
685
HciCmdOnLeReadPhyFailed(uint8_t status,const void * param)686 static void HciCmdOnLeReadPhyFailed(uint8_t status, const void *param)
687 {
688 HciLeReadPhyReturnParam returnParam = {
689 .status = status,
690 .connectionHandle = ((HciLeReadPhyReturnParam *)param)->connectionHandle,
691 };
692
693 MutexUnlock(HciGetEventCallbackListLock());
694
695 HciEventCallbacks *callbacks = NULL;
696 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
697 if (callbacks->leReadPhyComplete != NULL) {
698 callbacks->leReadPhyComplete(&returnParam);
699 }
700 HCI_FOREACH_EVT_CALLBACKS_END;
701 }
702
HciCmdOnLeSetDefaultPhyFailed(uint8_t status,const void * param)703 static void HciCmdOnLeSetDefaultPhyFailed(uint8_t status, const void *param)
704 {
705 HciLeSetDefaultPhyReturnParam returnParam = {
706 .status = status,
707 };
708
709 HciEventCallbacks *callbacks = NULL;
710 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
711 if (callbacks->leSetDefaultPhyComplete != NULL) {
712 callbacks->leSetDefaultPhyComplete(&returnParam);
713 }
714 HCI_FOREACH_EVT_CALLBACKS_END;
715 }
716
HciCmdOnLeEnhancedReceiverTestFailed(uint8_t status,const void * param)717 static void HciCmdOnLeEnhancedReceiverTestFailed(uint8_t status, const void *param)
718 {
719 HciLeEnhancedReceiverTestReturnParam returnParam = {
720 .status = status,
721 };
722
723 HciEventCallbacks *callbacks = NULL;
724 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
725 if (callbacks->leEnhancedReceiverTestComplete != NULL) {
726 callbacks->leEnhancedReceiverTestComplete(&returnParam);
727 }
728 HCI_FOREACH_EVT_CALLBACKS_END;
729 }
730
HciCmdOnLeEnhancedTransmitterTestFailed(uint8_t status,const void * param)731 static void HciCmdOnLeEnhancedTransmitterTestFailed(uint8_t status, const void *param)
732 {
733 HciLeEnhancedTransmitterTestReturnParam returnParam = {
734 .status = status,
735 };
736
737 HciEventCallbacks *callbacks = NULL;
738 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
739 if (callbacks->leEnhancedTransmitterTestComplete != NULL) {
740 callbacks->leEnhancedTransmitterTestComplete(&returnParam);
741 }
742 HCI_FOREACH_EVT_CALLBACKS_END;
743 }
744
HciCmdOnLeSetAdvertisingSetRandomAddressFailed(uint8_t status,const void * param)745 static void HciCmdOnLeSetAdvertisingSetRandomAddressFailed(uint8_t status, const void *param)
746 {
747 HciLeSetAdvertisingSetRandomAddressReturnParam returnParam = {
748 .status = status,
749 };
750
751 HciEventCallbacks *callbacks = NULL;
752 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
753 if (callbacks->leSetAdvertisingSetRandomAddressComplete != NULL) {
754 callbacks->leSetAdvertisingSetRandomAddressComplete(&returnParam);
755 }
756 HCI_FOREACH_EVT_CALLBACKS_END;
757 }
758
HciCmdOnLeSetExtendedAdvertisingParametersFailed(uint8_t status,const void * param)759 static void HciCmdOnLeSetExtendedAdvertisingParametersFailed(uint8_t status, const void *param)
760 {
761 HciLeSetExtendedAdvertisingParametersReturnParam returnParam = {
762 .status = status,
763 };
764
765 HciEventCallbacks *callbacks = NULL;
766 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
767 if (callbacks->leSetExtendedAdvertisingParametersComplete != NULL) {
768 callbacks->leSetExtendedAdvertisingParametersComplete(&returnParam);
769 }
770 HCI_FOREACH_EVT_CALLBACKS_END;
771 }
772
HciCmdOnLeSetExtendedAdvertisingDataFailed(uint8_t status,const void * param)773 static void HciCmdOnLeSetExtendedAdvertisingDataFailed(uint8_t status, const void *param)
774 {
775 HciLeSetExtendedAdvertisingDataReturnParam returnParam = {
776 .status = status,
777 };
778
779 HciEventCallbacks *callbacks = NULL;
780 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
781 if (callbacks->leSetExtendedAdvertisingDataComplete != NULL) {
782 callbacks->leSetExtendedAdvertisingDataComplete(&returnParam);
783 }
784 HCI_FOREACH_EVT_CALLBACKS_END;
785 }
786
HciCmdOnLeSetExtendedScanResponseDataFailed(uint8_t status,const void * param)787 static void HciCmdOnLeSetExtendedScanResponseDataFailed(uint8_t status, const void *param)
788 {
789 HciLeSetExtendedScanResponseDataReturnParam returnParam = {
790 .status = status,
791 };
792
793 HciEventCallbacks *callbacks = NULL;
794 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
795 if (callbacks->leSetExtendedScanResponseDataComplete != NULL) {
796 callbacks->leSetExtendedScanResponseDataComplete(&returnParam);
797 }
798 HCI_FOREACH_EVT_CALLBACKS_END;
799 }
800
HciCmdOnLeSetExtendedAdvertisingEnableFailed(uint8_t status,const void * param)801 static void HciCmdOnLeSetExtendedAdvertisingEnableFailed(uint8_t status, const void *param)
802 {
803 HciLeSetExtendedAdvertisingEnableReturnParam returnParam = {
804 .status = status,
805 };
806
807 HciEventCallbacks *callbacks = NULL;
808 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
809 if (callbacks->leSetExtendedAdvertisingEnableComplete != NULL) {
810 callbacks->leSetExtendedAdvertisingEnableComplete(&returnParam);
811 }
812 HCI_FOREACH_EVT_CALLBACKS_END;
813 }
814
HciCmdOnLeReadMaximumAdvertisingDataLengthFailed(uint8_t status,const void * param)815 static void HciCmdOnLeReadMaximumAdvertisingDataLengthFailed(uint8_t status, const void *param)
816 {
817 HciLeReadMaximumAdvertisingDataLengthReturnParam returnParam = {
818 .status = status,
819 };
820
821 HciEventCallbacks *callbacks = NULL;
822 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
823 if (callbacks->leReadMaximumAdvertisingDataLengthComplete != NULL) {
824 callbacks->leReadMaximumAdvertisingDataLengthComplete(&returnParam);
825 }
826 HCI_FOREACH_EVT_CALLBACKS_END;
827 }
828
HciCmdOnLeReadNumberofSupportedAdvertisingSetsFailed(uint8_t status,const void * param)829 static void HciCmdOnLeReadNumberofSupportedAdvertisingSetsFailed(uint8_t status, const void *param)
830 {
831 HciLeReadNumberofSupportedAdvertisingSetsReturnParam returnParam = {
832 .status = status,
833 };
834
835 HciEventCallbacks *callbacks = NULL;
836 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
837 if (callbacks->leReadNumberofSupportedAdvertisingSetsComplete != NULL) {
838 callbacks->leReadNumberofSupportedAdvertisingSetsComplete(&returnParam);
839 }
840 HCI_FOREACH_EVT_CALLBACKS_END;
841 }
842
HciCmdOnLeRemoveAdvertisingSetFailed(uint8_t status,const void * param)843 static void HciCmdOnLeRemoveAdvertisingSetFailed(uint8_t status, const void *param)
844 {
845 HciLeRemoveAdvertisingSetReturnParam returnParam = {
846 .status = status,
847 };
848
849 HciEventCallbacks *callbacks = NULL;
850 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
851 if (callbacks->leRemoveAdvertisingSetComplete != NULL) {
852 callbacks->leRemoveAdvertisingSetComplete(&returnParam);
853 }
854 HCI_FOREACH_EVT_CALLBACKS_END;
855 }
856
HciCmdOnLeClearAdvertisingSetsFailed(uint8_t status,const void * param)857 static void HciCmdOnLeClearAdvertisingSetsFailed(uint8_t status, const void *param)
858 {
859 HciLeClearAdvertisingSetsReturnParam returnParam = {
860 .status = status,
861 };
862
863 HciEventCallbacks *callbacks = NULL;
864 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
865 if (callbacks->leClearAdvertisingSetsComplete != NULL) {
866 callbacks->leClearAdvertisingSetsComplete(&returnParam);
867 }
868 HCI_FOREACH_EVT_CALLBACKS_END;
869 }
870
HciCmdOnLeSetPeriodicAdvertisingParametersFailed(uint8_t status,const void * param)871 static void HciCmdOnLeSetPeriodicAdvertisingParametersFailed(uint8_t status, const void *param)
872 {
873 HciLeSetPeriodicAdvertisingParametersReturnParameters returnParam = {
874 .status = status,
875 };
876
877 HciEventCallbacks *callbacks = NULL;
878 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
879 if (callbacks->leSetPeriodicAdvertisingParametersComplete != NULL) {
880 callbacks->leSetPeriodicAdvertisingParametersComplete(&returnParam);
881 }
882 HCI_FOREACH_EVT_CALLBACKS_END;
883 }
884
HciCmdOnLeSetPeriodicAdvertisingDataFailed(uint8_t status,const void * param)885 static void HciCmdOnLeSetPeriodicAdvertisingDataFailed(uint8_t status, const void *param)
886 {
887 HciLeSetPeriodicAdvertisingDataReturnParameters returnParam = {
888 .status = status,
889 };
890
891 HciEventCallbacks *callbacks = NULL;
892 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
893 if (callbacks->leSetPeriodicAdvertisingDataComplete != NULL) {
894 callbacks->leSetPeriodicAdvertisingDataComplete(&returnParam);
895 }
896 HCI_FOREACH_EVT_CALLBACKS_END;
897 }
898
HciCmdOnLeSetPeriodicAdvertisingEnableFailed(uint8_t status,const void * param)899 static void HciCmdOnLeSetPeriodicAdvertisingEnableFailed(uint8_t status, const void *param)
900 {
901 HciLeSetPeriodicAdvertisingEnableReturnParameters returnParam = {
902 .status = status,
903 };
904
905 HciEventCallbacks *callbacks = NULL;
906 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
907 if (callbacks->leSetPeriodicAdvertisingEnableComplete != NULL) {
908 callbacks->leSetPeriodicAdvertisingEnableComplete(&returnParam);
909 }
910 HCI_FOREACH_EVT_CALLBACKS_END;
911 }
912
HciCmdOnLeSetExtendedScanParametersFailed(uint8_t status,const void * param)913 static void HciCmdOnLeSetExtendedScanParametersFailed(uint8_t status, const void *param)
914 {
915 HciLeSetExtendedScanParametersReturnParam returnParam = {
916 .status = status,
917 };
918
919 HciEventCallbacks *callbacks = NULL;
920 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
921 if (callbacks->leSetExtendedScanParametersComplete != NULL) {
922 callbacks->leSetExtendedScanParametersComplete(&returnParam);
923 }
924 HCI_FOREACH_EVT_CALLBACKS_END;
925 }
926
HciCmdOnLeSetExtendedScanEnableFailed(uint8_t status,const void * param)927 static void HciCmdOnLeSetExtendedScanEnableFailed(uint8_t status, const void *param)
928 {
929 HciLeSetExtendedScanEnableReturnParam returnParam = {
930 .status = status,
931 };
932
933 HciEventCallbacks *callbacks = NULL;
934 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
935 if (callbacks->leSetExtendedScanEnableComplete != NULL) {
936 callbacks->leSetExtendedScanEnableComplete(&returnParam);
937 }
938 HCI_FOREACH_EVT_CALLBACKS_END;
939 }
940
HciCmdOnLeExtendedCreateConnectionFailed(uint8_t status,const void * param)941 static void HciCmdOnLeExtendedCreateConnectionFailed(uint8_t status, const void *param)
942 {
943 const HciLeExtendedCreateConnectionParam *cmdParam = param;
944
945 HciLeEnhancedConnectionCompleteEventParam eventParam = {
946 .status = status,
947 .peerAddressType = cmdParam->peerAddressType,
948 .peerAddress = cmdParam->peerAddress,
949 };
950
951 HciEventCallbacks *callbacks = NULL;
952 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
953 if (callbacks->leEnhancedConnectionComplete != NULL) {
954 callbacks->leEnhancedConnectionComplete(&eventParam);
955 }
956 HCI_FOREACH_EVT_CALLBACKS_END;
957 }
958
HciCmdOnLePeriodicAdvertisingCreateSyncCancelFailed(uint8_t status,const void * param)959 static void HciCmdOnLePeriodicAdvertisingCreateSyncCancelFailed(uint8_t status, const void *param)
960 {
961 HciLePeriodicAdvertisingCreateSyncCancelReturnParam returnParam = {
962 .status = status,
963 };
964
965 HciEventCallbacks *callbacks = NULL;
966 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
967 if (callbacks->lePeriodicAdvertisingCreateSyncCancelComplete != NULL) {
968 callbacks->lePeriodicAdvertisingCreateSyncCancelComplete(&returnParam);
969 }
970 HCI_FOREACH_EVT_CALLBACKS_END;
971 }
972
HciCmdOnLePeriodicAdvertisingTerminateSyncFailed(uint8_t status,const void * param)973 static void HciCmdOnLePeriodicAdvertisingTerminateSyncFailed(uint8_t status, const void *param)
974 {
975 HciLePeriodicAdvertisingTerminateSyncReturnParam returnParam = {
976 .status = status,
977 };
978
979 HciEventCallbacks *callbacks = NULL;
980 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
981 if (callbacks->lePeriodicAdvertisingTerminateSyncComplete != NULL) {
982 callbacks->lePeriodicAdvertisingTerminateSyncComplete(&returnParam);
983 }
984 HCI_FOREACH_EVT_CALLBACKS_END;
985 }
986
HciCmdOnLeAddDeviceToPeriodicAdvertiserListFailed(uint8_t status,const void * param)987 static void HciCmdOnLeAddDeviceToPeriodicAdvertiserListFailed(uint8_t status, const void *param)
988 {
989 HciLeAddDeviceToPeriodicAdvertiserListReturnParam returnParam = {
990 .status = status,
991 };
992
993 HciEventCallbacks *callbacks = NULL;
994 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
995 if (callbacks->leAddDeviceToPeriodicAdvertiserListComplete != NULL) {
996 callbacks->leAddDeviceToPeriodicAdvertiserListComplete(&returnParam);
997 }
998 HCI_FOREACH_EVT_CALLBACKS_END;
999 }
1000
HciCmdOnLeRemoveDeviceFromPeriodicAdvertiserListFailed(uint8_t status,const void * param)1001 static void HciCmdOnLeRemoveDeviceFromPeriodicAdvertiserListFailed(uint8_t status, const void *param)
1002 {
1003 HciLeRemoveDeviceFromPeriodicAdvertiserListReturnParam returnParam = {
1004 .status = status,
1005 };
1006
1007 HciEventCallbacks *callbacks = NULL;
1008 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1009 if (callbacks->leRemoveDeviceFromPeriodicAdvertiserListComplete != NULL) {
1010 callbacks->leRemoveDeviceFromPeriodicAdvertiserListComplete(&returnParam);
1011 }
1012 HCI_FOREACH_EVT_CALLBACKS_END;
1013 }
1014
HciCmdOnLeClearPeriodicAdvertiserListFailed(uint8_t status,const void * param)1015 static void HciCmdOnLeClearPeriodicAdvertiserListFailed(uint8_t status, const void *param)
1016 {
1017 HciLeClearPeriodicAdvertiserListReturnParam returnParam = {
1018 .status = status,
1019 };
1020
1021 HciEventCallbacks *callbacks = NULL;
1022 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1023 if (callbacks->leClearPeriodicAdvertiserListComplete != NULL) {
1024 callbacks->leClearPeriodicAdvertiserListComplete(&returnParam);
1025 }
1026 HCI_FOREACH_EVT_CALLBACKS_END;
1027 }
1028
HciCmdOnLeReadPeriodicAdvertiserListSizeFailed(uint8_t status,const void * param)1029 static void HciCmdOnLeReadPeriodicAdvertiserListSizeFailed(uint8_t status, const void *param)
1030 {
1031 HciLeReadPeriodicAdvertiserListSizeReturnParam returnParam = {
1032 .status = status,
1033 };
1034
1035 HciEventCallbacks *callbacks = NULL;
1036 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1037 if (callbacks->leReadPeriodicAdvertiserListSizeComplete != NULL) {
1038 callbacks->leReadPeriodicAdvertiserListSizeComplete(&returnParam);
1039 }
1040 HCI_FOREACH_EVT_CALLBACKS_END;
1041 }
1042
HciCmdOnLeReadTransmitPowerFailed(uint8_t status,const void * param)1043 static void HciCmdOnLeReadTransmitPowerFailed(uint8_t status, const void *param)
1044 {
1045 HciLeReadTransmitPowerReturnParam returnParam = {
1046 .status = status,
1047 };
1048
1049 HciEventCallbacks *callbacks = NULL;
1050 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1051 if (callbacks->leReadTransmitPowerComplete != NULL) {
1052 callbacks->leReadTransmitPowerComplete(&returnParam);
1053 }
1054 HCI_FOREACH_EVT_CALLBACKS_END;
1055 }
1056
HciCmdOnLeReadRfPathCompensationFailed(uint8_t status,const void * param)1057 static void HciCmdOnLeReadRfPathCompensationFailed(uint8_t status, const void *param)
1058 {
1059 HciLeReadRfPathCompensationReturnParam returnParam = {
1060 .status = status,
1061 };
1062
1063 HciEventCallbacks *callbacks = NULL;
1064 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1065 if (callbacks->leReadRfPathCompensationComplete != NULL) {
1066 callbacks->leReadRfPathCompensationComplete(&returnParam);
1067 }
1068 HCI_FOREACH_EVT_CALLBACKS_END;
1069 }
1070
HciCmdOnLeWriteRfPathCompensationParamFailed(uint8_t status,const void * param)1071 static void HciCmdOnLeWriteRfPathCompensationParamFailed(uint8_t status, const void *param)
1072 {
1073 HciLeWriteRfPathCompensationReturnParam returnParam = {
1074 .status = status,
1075 };
1076
1077 HciEventCallbacks *callbacks = NULL;
1078 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1079 if (callbacks->leWriteRfPathCompensationComplete != NULL) {
1080 callbacks->leWriteRfPathCompensationComplete(&returnParam);
1081 }
1082 HCI_FOREACH_EVT_CALLBACKS_END;
1083 }
1084
HciCmdOnLeSetPrivacyModeFailed(uint8_t status,const void * param)1085 static void HciCmdOnLeSetPrivacyModeFailed(uint8_t status, const void *param)
1086 {
1087 HciLeSetPrivacyModeReturnParam returnParam = {
1088 .status = status,
1089 };
1090
1091 HciEventCallbacks *callbacks = NULL;
1092 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1093 if (callbacks->leSetPrivacyModeComplete != NULL) {
1094 callbacks->leSetPrivacyModeComplete(&returnParam);
1095 }
1096 HCI_FOREACH_EVT_CALLBACKS_END;
1097 }
1098
1099 static HciCmdOnFailedFunc g_funcMap[] = {
1100 NULL, // 0x0000
1101 HciCmdOnLeSetEventMaskFailed, // 0x0001
1102 HciCmdOnLeReadBufferSizeFailed, // 0x0002
1103 HciCmdOnLeReadLocalSupportedFeaturesFailed, // 0x0003
1104 NULL, // 0x0004
1105 HciCmdOnLeSetRandomAddressFailed, // 0x0005
1106 HciCmdOnLeSetAdvertisingParametersFailed, // 0x0006
1107 HciCmdOnReadAdvertisingChannelTxPowerFailed, // 0x0007
1108 HciCmdOnLeSetAdvertisingDataFailed, // 0x0008
1109 HciCmdOnLeSetScanResponseDataFailed, // 0x0009
1110 HciCmdOnLeSetAdvertisingEnableFailed, // 0x000A
1111 HciCmdOnLeSetScanParametersFailed, // 0x000B
1112 HciCmdOnLeSetScanEnableFailed, // 0x000C
1113 HciCmdOnLeCreateConnectionFailed, // 0x000D
1114 HciCmdOnLeCreateConnectionCancelFailed, // 0x000E
1115 HciCmdOnLeReadWhiteListSizeFailed, // 0x000F
1116 HciCmdOnLeClearWhiteListFailed, // 0x0010
1117 HciCmdOnLeAddDeviceToWhiteListFailed, // 0x0011
1118 HciCmdOnLeRemoveDeviceFromWhiteListFailed, // 0x0012
1119 HciCmdOnLeConnectionUpdateFailed, // 0x0013
1120 HciCmdOnLeSetHostChannelClassificationFailed, // 0x0014
1121 HciCmdOnLeReadChannelMapFailed, // 0x0015
1122 HciCmdOnLeReadRemoteFeaturesFailed, // 0x0016
1123 HciCmdOnLeEncryptFailed, // 0x0017
1124 HciCmdOnLeRandFailed, // 0x0018
1125 HciCmdOnLeStartEncryptionFailed, // 0x0019
1126 HciCmdOnLeLongTermKeyRequestReplyFailed, // 0x001A
1127 HciCmdOnLeLongTermKeyRequestNegativeReplyFailed, // 0x001B
1128 HciCmdOnLeReadSupportedStatesFailed, // 0x001C
1129 HciCmdOnLeReceiverTestFailed, // 0x001D
1130 HciCmdOnLeTransmitterTestFailed, // 0x001E
1131 HciCmdOnLeTestEndFailed, // 0x001F
1132 HciCmdOnLeRemoteConnectionParameterRequestFailed, // 0x0020
1133 HciCmdOnLeRemoteConnectionParameterRequestNegativeReplyFailed, // 0x0021
1134 HciCmdOnLeSetDataLengthFailed, // 0x0022
1135 HciCmdOnLeReadSuggestedDefaultDataLengthFailed, // 0x0023
1136 HciCmdOnLeWriteSuggestedDefaultDataLengthFailed, // 0x0024
1137 HciCmdOnLeReadLocalP256PublicKeyFailed, // 0x0025
1138 HciCmdOnLeGenerateDhKeyFailed, // 0x0026
1139 HciCmdOnLeAddDeviceToResolvingListFailed, // 0x0027
1140 HciCmdOnLeRemoveDeviceFromResolvingListFailed, // 0x0028
1141 HciCmdOnLeClearResolvingListFailed, // 0x0029
1142 HciCmdOnLeReadResolvingListSizeFailed, // 0x002A
1143 HciCmdOnLeReadPeerResolvableAddressFailed, // 0x002B
1144 HciCmdOnLeReadLocalResolvableAddressFailed, // 0x002C
1145 HciCmdOnLeSetAddressResolutionEnableFailed, // 0x002D
1146 HciCmdOnLeSetResolvablePrivateAddressTimeoutFailed, // 0x002E
1147 HciCmdOnLeReadMaximumDataLengthFailed, // 0x002F
1148 HciCmdOnLeReadPhyFailed, // 0x0030
1149 HciCmdOnLeSetDefaultPhyFailed, // 0x0031
1150 NULL, // 0x0032
1151 HciCmdOnLeEnhancedReceiverTestFailed, // 0x0033
1152 HciCmdOnLeEnhancedTransmitterTestFailed, // 0x0034
1153 HciCmdOnLeSetAdvertisingSetRandomAddressFailed, // 0x0035
1154 HciCmdOnLeSetExtendedAdvertisingParametersFailed, // 0x0036
1155 HciCmdOnLeSetExtendedAdvertisingDataFailed, // 0x0037
1156 HciCmdOnLeSetExtendedScanResponseDataFailed, // 0x0038
1157 HciCmdOnLeSetExtendedAdvertisingEnableFailed, // 0x0039
1158 HciCmdOnLeReadMaximumAdvertisingDataLengthFailed, // 0x003A
1159 HciCmdOnLeReadNumberofSupportedAdvertisingSetsFailed, // 0x003B
1160 HciCmdOnLeRemoveAdvertisingSetFailed, // 0x003C
1161 HciCmdOnLeClearAdvertisingSetsFailed, // 0x003D
1162 HciCmdOnLeSetPeriodicAdvertisingParametersFailed, // 0x003E
1163 HciCmdOnLeSetPeriodicAdvertisingDataFailed, // 0x003F
1164 HciCmdOnLeSetPeriodicAdvertisingEnableFailed, // 0x0040
1165 HciCmdOnLeSetExtendedScanParametersFailed, // 0x0041
1166 HciCmdOnLeSetExtendedScanEnableFailed, // 0x0042
1167 HciCmdOnLeExtendedCreateConnectionFailed, // 0x0043
1168 NULL, // 0x0044
1169 HciCmdOnLePeriodicAdvertisingCreateSyncCancelFailed, // 0x0045
1170 HciCmdOnLePeriodicAdvertisingTerminateSyncFailed, // 0x0046
1171 HciCmdOnLeAddDeviceToPeriodicAdvertiserListFailed, // 0x0047
1172 HciCmdOnLeRemoveDeviceFromPeriodicAdvertiserListFailed, // 0x0048
1173 HciCmdOnLeClearPeriodicAdvertiserListFailed, // 0x0049
1174 HciCmdOnLeReadPeriodicAdvertiserListSizeFailed, // 0x004A
1175 HciCmdOnLeReadTransmitPowerFailed, // 0x004B
1176 HciCmdOnLeReadRfPathCompensationFailed, // 0x004C
1177 HciCmdOnLeWriteRfPathCompensationParamFailed, // 0x004D
1178 HciCmdOnLeSetPrivacyModeFailed, // 0x004E
1179 };
1180
1181 #define LECONTROLLER_OCF_MAX 0x004E
1182
HciOnLeControllerCmdFailed(uint16_t opCode,uint8_t status,const void * param)1183 void HciOnLeControllerCmdFailed(uint16_t opCode, uint8_t status, const void *param)
1184 {
1185 uint16_t ocf = GET_OCF(opCode);
1186 if (ocf > LECONTROLLER_OCF_MAX) {
1187 return;
1188 }
1189
1190 HciCmdOnFailedFunc func = g_funcMap[ocf];
1191 if (func != NULL) {
1192 func(status, param);
1193 }
1194 }