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_controller_baseband.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
HciCmdOnSetEventMaskFailed(uint8_t status,const void * param)27 static void HciCmdOnSetEventMaskFailed(uint8_t status, const void *param)
28 {
29 HciSetEventMaskReturnParam returnParam = {
30 .status = status,
31 };
32
33 HciEventCallbacks *callbacks = NULL;
34 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
35 if (callbacks->setEventMaskComplete != NULL) {
36 callbacks->setEventMaskComplete(&returnParam);
37 }
38 HCI_FOREACH_EVT_CALLBACKS_END;
39 }
40
HciCmdOnResetFailed(uint8_t status,const void * param)41 static void HciCmdOnResetFailed(uint8_t status, const void *param)
42 {
43 HciResetReturnParam returnParam = {
44 .status = status,
45 };
46
47 HciEventCallbacks *callbacks = NULL;
48 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
49 if (callbacks->resetComplete != NULL) {
50 callbacks->resetComplete(&returnParam);
51 }
52 HCI_FOREACH_EVT_CALLBACKS_END;
53 }
54
HciCmdOnSetEventFilterFailed(uint8_t status,const void * param)55 static void HciCmdOnSetEventFilterFailed(uint8_t status, const void *param)
56 {
57 HciSetEventFilterReturnParam returnParam = {
58 .status = status,
59 };
60
61 HciEventCallbacks *callbacks = NULL;
62 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
63 if (callbacks->setEventFilterComplete != NULL) {
64 callbacks->setEventFilterComplete(&returnParam);
65 }
66 HCI_FOREACH_EVT_CALLBACKS_END;
67 }
68
HciCmdOnFlushFailed(uint8_t status,const void * param)69 static void HciCmdOnFlushFailed(uint8_t status, const void *param)
70 {
71 HciFlushReturnParam returnParam = {
72 .status = status,
73 };
74
75 HciEventCallbacks *callbacks = NULL;
76 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
77 if (callbacks->flushComplete != NULL) {
78 callbacks->flushComplete(&returnParam);
79 }
80 HCI_FOREACH_EVT_CALLBACKS_END;
81 }
82
HciCmdOnReadPinTypeFailed(uint8_t status,const void * param)83 static void HciCmdOnReadPinTypeFailed(uint8_t status, const void *param)
84 {
85 HciReadPinTypeReturnParam returnParam = {
86 .status = status,
87 };
88
89 HciEventCallbacks *callbacks = NULL;
90 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
91 if (callbacks->readPinTypeComplete != NULL) {
92 callbacks->readPinTypeComplete(&returnParam);
93 }
94 HCI_FOREACH_EVT_CALLBACKS_END;
95 }
96
HciCmdOnWritePinTypeFailed(uint8_t status,const void * param)97 static void HciCmdOnWritePinTypeFailed(uint8_t status, const void *param)
98 {
99 HciWritePinTypeReturnParam returnParam = {
100 .status = status,
101 };
102
103 HciEventCallbacks *callbacks = NULL;
104 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
105 if (callbacks->writePinTypeComplete != NULL) {
106 callbacks->writePinTypeComplete(&returnParam);
107 }
108 HCI_FOREACH_EVT_CALLBACKS_END;
109 }
110
HciCmdOnCreateNewUnitKeyFailed(uint8_t status,const void * param)111 static void HciCmdOnCreateNewUnitKeyFailed(uint8_t status, const void *param)
112 {
113 HciCreateNewUnitKeyReturnParam returnParam = {
114 .status = status,
115 };
116
117 HciEventCallbacks *callbacks = NULL;
118 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
119 if (callbacks->createNewUnitKeyComplete != NULL) {
120 callbacks->createNewUnitKeyComplete(&returnParam);
121 }
122 HCI_FOREACH_EVT_CALLBACKS_END;
123 }
124
HciCmdOnReadStoredLinkKeyFailed(uint8_t status,const void * param)125 static void HciCmdOnReadStoredLinkKeyFailed(uint8_t status, const void *param)
126 {
127 HciReadStoredLinkKeyReturnParam returnParam = {
128 .status = status,
129 };
130
131 HciEventCallbacks *callbacks = NULL;
132 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
133 if (callbacks->readStoredLinkKeyComplete != NULL) {
134 callbacks->readStoredLinkKeyComplete(&returnParam);
135 }
136 HCI_FOREACH_EVT_CALLBACKS_END;
137 }
138
HciCmdOnDeleteStoredLinkKeyFailed(uint8_t status,const void * param)139 static void HciCmdOnDeleteStoredLinkKeyFailed(uint8_t status, const void *param)
140 {
141 HciDeleteStoredLinkKeyReturnParam returnParam = {
142 .status = status,
143 };
144
145 HciEventCallbacks *callbacks = NULL;
146 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
147 if (callbacks->deleteStoredLinkKeyComplete != NULL) {
148 callbacks->deleteStoredLinkKeyComplete(&returnParam);
149 }
150 HCI_FOREACH_EVT_CALLBACKS_END;
151 }
152
HciCmdOnWriteLocalNameFailed(uint8_t status,const void * param)153 static void HciCmdOnWriteLocalNameFailed(uint8_t status, const void *param)
154 {
155 HciWriteLocalNameReturnParam returnParam = {
156 .status = status,
157 };
158
159 HciEventCallbacks *callbacks = NULL;
160 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
161 if (callbacks->writeLocalNameComplete != NULL) {
162 callbacks->writeLocalNameComplete(&returnParam);
163 }
164 HCI_FOREACH_EVT_CALLBACKS_END;
165 }
166
HciCmdOnReadLocalNameFailed(uint8_t status,const void * param)167 static void HciCmdOnReadLocalNameFailed(uint8_t status, const void *param)
168 {
169 HciReadLocalNameReturnParam returnParam = {
170 .status = status,
171 };
172
173 HciEventCallbacks *callbacks = NULL;
174 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
175 if (callbacks->readLocalNameComplete != NULL) {
176 callbacks->readLocalNameComplete(&returnParam);
177 }
178 HCI_FOREACH_EVT_CALLBACKS_END;
179 }
180
HciCmdOnReadConnectionAcceptTimeoutFailed(uint8_t status,const void * param)181 static void HciCmdOnReadConnectionAcceptTimeoutFailed(uint8_t status, const void *param)
182 {
183 HciReadConnectionAcceptTimeoutReturnParam returnParam = {
184 .status = status,
185 };
186
187 HciEventCallbacks *callbacks = NULL;
188 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
189 if (callbacks->readConnectionAcceptTimeoutComplete != NULL) {
190 callbacks->readConnectionAcceptTimeoutComplete(&returnParam);
191 }
192 HCI_FOREACH_EVT_CALLBACKS_END;
193 }
194
HciCmdOnWriteConnectionAcceptTimeoutFailed(uint8_t status,const void * param)195 static void HciCmdOnWriteConnectionAcceptTimeoutFailed(uint8_t status, const void *param)
196 {
197 HciWriteConnectionAcceptTimeoutReturnParam returnParam = {
198 .status = status,
199 };
200
201 HciEventCallbacks *callbacks = NULL;
202 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
203 if (callbacks->writeConnectionAcceptTimeoutComplete != NULL) {
204 callbacks->writeConnectionAcceptTimeoutComplete(&returnParam);
205 }
206 HCI_FOREACH_EVT_CALLBACKS_END;
207 }
208
HciCmdOnReadPageTimeoutFailed(uint8_t status,const void * param)209 static void HciCmdOnReadPageTimeoutFailed(uint8_t status, const void *param)
210 {
211 HciReadPageTimeoutReturnParam returnParam = {
212 .status = status,
213 };
214
215 HciEventCallbacks *callbacks = NULL;
216 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
217 if (callbacks->readPageTimeoutComplete != NULL) {
218 callbacks->readPageTimeoutComplete(&returnParam);
219 }
220 HCI_FOREACH_EVT_CALLBACKS_END;
221 }
222
HciCmdOnWritePageTimeoutFailed(uint8_t status,const void * param)223 static void HciCmdOnWritePageTimeoutFailed(uint8_t status, const void *param)
224 {
225 HciWritePageTimeoutReturnParam returnParam = {
226 .status = status,
227 };
228
229 HciEventCallbacks *callbacks = NULL;
230 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
231 if (callbacks->writePageTimeoutComplete != NULL) {
232 callbacks->writePageTimeoutComplete(&returnParam);
233 }
234 HCI_FOREACH_EVT_CALLBACKS_END;
235 }
236
HciCmdOnReadScanEnableFailed(uint8_t status,const void * param)237 static void HciCmdOnReadScanEnableFailed(uint8_t status, const void *param)
238 {
239 HciReadScanEnableReturnParam returnParam = {
240 .status = status,
241 };
242
243 HciEventCallbacks *callbacks = NULL;
244 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
245 if (callbacks->readScanEnableComplete != NULL) {
246 callbacks->readScanEnableComplete(&returnParam);
247 }
248 HCI_FOREACH_EVT_CALLBACKS_END;
249 }
250
HciCmdOnWriteScanEnableFailed(uint8_t status,const void * param)251 static void HciCmdOnWriteScanEnableFailed(uint8_t status, const void *param)
252 {
253 HciWriteScanEnableReturnParam returnParam = {
254 .status = status,
255 };
256
257 HciEventCallbacks *callbacks = NULL;
258 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
259 if (callbacks->writeScanEnableComplete != NULL) {
260 callbacks->writeScanEnableComplete(&returnParam);
261 }
262 HCI_FOREACH_EVT_CALLBACKS_END;
263 }
264
HciCmdOnReadPageScanActivityFailed(uint8_t status,const void * param)265 static void HciCmdOnReadPageScanActivityFailed(uint8_t status, const void *param)
266 {
267 HciReadPageScanActivityReturnParam returnParam = {
268 .status = status,
269 };
270
271 HciEventCallbacks *callbacks = NULL;
272 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
273 if (callbacks->readPageScanActivityComplete != NULL) {
274 callbacks->readPageScanActivityComplete(&returnParam);
275 }
276 HCI_FOREACH_EVT_CALLBACKS_END;
277 }
278
HciCmdOnWritePageScanActivityFailed(uint8_t status,const void * param)279 static void HciCmdOnWritePageScanActivityFailed(uint8_t status, const void *param)
280 {
281 HciWritePageScanActivityReturnParam returnParam = {
282 .status = status,
283 };
284
285 HciEventCallbacks *callbacks = NULL;
286 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
287 if (callbacks->writePageScanActivityComplete != NULL) {
288 callbacks->writePageScanActivityComplete(&returnParam);
289 }
290 HCI_FOREACH_EVT_CALLBACKS_END;
291 }
292
HciCmdOnReadInquiryScanActivityFailed(uint8_t status,const void * param)293 static void HciCmdOnReadInquiryScanActivityFailed(uint8_t status, const void *param)
294 {
295 HciReadInquiryScanActivityReturnParam returnParam = {
296 .status = status,
297 };
298
299 HciEventCallbacks *callbacks = NULL;
300 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
301 if (callbacks->readInquiryScanActivityComplete != NULL) {
302 callbacks->readInquiryScanActivityComplete(&returnParam);
303 }
304 HCI_FOREACH_EVT_CALLBACKS_END;
305 }
306
HciCmdOnWriteInquiryScanActivityFailed(uint8_t status,const void * param)307 static void HciCmdOnWriteInquiryScanActivityFailed(uint8_t status, const void *param)
308 {
309 HciWriteInquiryScanActivityReturnParam returnParam = {
310 .status = status,
311 };
312
313 HciEventCallbacks *callbacks = NULL;
314 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
315 if (callbacks->writeInquiryScanActivityComplete != NULL) {
316 callbacks->writeInquiryScanActivityComplete(&returnParam);
317 }
318 HCI_FOREACH_EVT_CALLBACKS_END;
319 }
320
HciCmdOnReadAuthenticationEnableFailed(uint8_t status,const void * param)321 static void HciCmdOnReadAuthenticationEnableFailed(uint8_t status, const void *param)
322 {
323 HciReadAuthenticationEnableReturnParam returnParam = {
324 .status = status,
325 };
326
327 HciEventCallbacks *callbacks = NULL;
328 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
329 if (callbacks->readAuthenticationEnableComplete != NULL) {
330 callbacks->readAuthenticationEnableComplete(&returnParam);
331 }
332 HCI_FOREACH_EVT_CALLBACKS_END;
333 }
334
HciCmdOnWriteAuthenticationEnableFailed(uint8_t status,const void * param)335 static void HciCmdOnWriteAuthenticationEnableFailed(uint8_t status, const void *param)
336 {
337 HciWriteAuthenticationEnableReturnParam returnParam = {
338 .status = status,
339 };
340
341 HciEventCallbacks *callbacks = NULL;
342 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
343 if (callbacks->writeAuthenticationEnableComplete != NULL) {
344 callbacks->writeAuthenticationEnableComplete(&returnParam);
345 }
346 HCI_FOREACH_EVT_CALLBACKS_END;
347 }
348
HciCmdOnReadClassofDeviceFailed(uint8_t status,const void * param)349 static void HciCmdOnReadClassofDeviceFailed(uint8_t status, const void *param)
350 {
351 HciReadClassofDeviceReturnParam returnParam = {
352 .status = status,
353 };
354
355 HciEventCallbacks *callbacks = NULL;
356 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
357 if (callbacks->readClassofDeviceComplete != NULL) {
358 callbacks->readClassofDeviceComplete(&returnParam);
359 }
360 HCI_FOREACH_EVT_CALLBACKS_END;
361 }
362
HciCmdOnWriteClassofDeviceFailed(uint8_t status,const void * param)363 static void HciCmdOnWriteClassofDeviceFailed(uint8_t status, const void *param)
364 {
365 HciWriteClassofDeviceReturnParam returnParam = {
366 .status = status,
367 };
368
369 HciEventCallbacks *callbacks = NULL;
370 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
371 if (callbacks->writeClassofDeviceComplete != NULL) {
372 callbacks->writeClassofDeviceComplete(&returnParam);
373 }
374 HCI_FOREACH_EVT_CALLBACKS_END;
375 }
376
HciCmdOnReadVoiceSettingFailed(uint8_t status,const void * param)377 static void HciCmdOnReadVoiceSettingFailed(uint8_t status, const void *param)
378 {
379 HciReadVoiceSettingReturnParam returnParam = {
380 .status = status,
381 };
382
383 HciEventCallbacks *callbacks = NULL;
384 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
385 if (callbacks->readVoiceSettingComplete != NULL) {
386 callbacks->readVoiceSettingComplete(&returnParam);
387 }
388 HCI_FOREACH_EVT_CALLBACKS_END;
389 }
390
HciCmdOnWriteVoiceSettingFailed(uint8_t status,const void * param)391 static void HciCmdOnWriteVoiceSettingFailed(uint8_t status, const void *param)
392 {
393 HciWriteVoiceSettingParamReturnParam returnParam = {
394 .status = status,
395 };
396
397 HciEventCallbacks *callbacks = NULL;
398 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
399 if (callbacks->writeVoiceSettingComplete != NULL) {
400 callbacks->writeVoiceSettingComplete(&returnParam);
401 }
402 HCI_FOREACH_EVT_CALLBACKS_END;
403 }
404
HciCmdOnReadAutomaticFlushTimeoutFailed(uint8_t status,const void * param)405 static void HciCmdOnReadAutomaticFlushTimeoutFailed(uint8_t status, const void *param)
406 {
407 HciReadAutomaticFlushTimeoutReturnParam returnParam = {
408 .status = status,
409 .connectionHandle = ((HciReadAutomaticFlushTimeoutReturnParam *)param)->connectionHandle,
410 };
411
412 HciEventCallbacks *callbacks = NULL;
413 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
414 if (callbacks->readAutomaticFlushTimeoutComplete != NULL) {
415 callbacks->readAutomaticFlushTimeoutComplete(&returnParam);
416 }
417 HCI_FOREACH_EVT_CALLBACKS_END;
418 }
419
HciCmdOnWriteAutomaticFlushTimeoutFailed(uint8_t status,const void * param)420 static void HciCmdOnWriteAutomaticFlushTimeoutFailed(uint8_t status, const void *param)
421 {
422 HciWriteAutomaticFlushTimeoutReturnParam returnParam = {
423 .status = status,
424 .connectionHandle = ((HciWriteAutomaticFlushTimeoutReturnParam *)param)->connectionHandle,
425 };
426
427 HciEventCallbacks *callbacks = NULL;
428 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
429 if (callbacks->writeAutomaticFlushTimeoutComplete != NULL) {
430 callbacks->writeAutomaticFlushTimeoutComplete(&returnParam);
431 }
432 HCI_FOREACH_EVT_CALLBACKS_END;
433 }
434
HciCmdOnReadNumBroadcastRetransmissionsFailed(uint8_t status,const void * param)435 static void HciCmdOnReadNumBroadcastRetransmissionsFailed(uint8_t status, const void *param)
436 {
437 HciReadNumBroadcastRetransmissionsReturnParam returnParam = {
438 .status = status,
439 };
440
441 HciEventCallbacks *callbacks = NULL;
442 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
443 if (callbacks->readNumBroadcastRetransmissionsComplete != NULL) {
444 callbacks->readNumBroadcastRetransmissionsComplete(&returnParam);
445 }
446 HCI_FOREACH_EVT_CALLBACKS_END;
447 }
448
HciCmdOnWriteNumBroadcastRetransmissionsFailed(uint8_t status,const void * param)449 static void HciCmdOnWriteNumBroadcastRetransmissionsFailed(uint8_t status, const void *param)
450 {
451 HciWriteNumBroadcastRetransmissionsReturnParam returnParam = {
452 .status = status,
453 };
454
455 HciEventCallbacks *callbacks = NULL;
456 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
457 if (callbacks->writeNumBroadcastRetransmissionsComplete != NULL) {
458 callbacks->writeNumBroadcastRetransmissionsComplete(&returnParam);
459 }
460 HCI_FOREACH_EVT_CALLBACKS_END;
461 }
462
HciCmdOnReadHoldModeActivityFailed(uint8_t status,const void * param)463 static void HciCmdOnReadHoldModeActivityFailed(uint8_t status, const void *param)
464 {
465 HciReadHoldModeActivityReturnParam returnParam = {
466 .status = status,
467 };
468
469 HciEventCallbacks *callbacks = NULL;
470 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
471 if (callbacks->readHoldModeActivityComplete != NULL) {
472 callbacks->readHoldModeActivityComplete(&returnParam);
473 }
474 HCI_FOREACH_EVT_CALLBACKS_END;
475 }
476
HciCmdOnWriteHoldModeActivityFailed(uint8_t status,const void * param)477 static void HciCmdOnWriteHoldModeActivityFailed(uint8_t status, const void *param)
478 {
479 HciWriteHoldModeActivityReturnParam returnParam = {
480 .status = status,
481 };
482
483 HciEventCallbacks *callbacks = NULL;
484 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
485 if (callbacks->writeHoldModeActivityComplete != NULL) {
486 callbacks->writeHoldModeActivityComplete(&returnParam);
487 }
488 HCI_FOREACH_EVT_CALLBACKS_END;
489 }
490
HciCmdOnReadTransmitPowerLevelFailed(uint8_t status,const void * param)491 static void HciCmdOnReadTransmitPowerLevelFailed(uint8_t status, const void *param)
492 {
493 HciReadTransmitPowerLevelReturnParam returnParam = {
494 .status = status,
495 };
496
497 HciEventCallbacks *callbacks = NULL;
498 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
499 if (callbacks->readTransmitPowerLevelComplete != NULL) {
500 callbacks->readTransmitPowerLevelComplete(&returnParam);
501 }
502 HCI_FOREACH_EVT_CALLBACKS_END;
503 }
504
HciCmdOnReadSynchronousFlowControlEnableFailed(uint8_t status,const void * param)505 static void HciCmdOnReadSynchronousFlowControlEnableFailed(uint8_t status, const void *param)
506 {
507 HciReadSynchronousFlowControlEnableReturnParam returnParam = {
508 .status = status,
509 };
510
511 HciEventCallbacks *callbacks = NULL;
512 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
513 if (callbacks->readSynchronousFlowControlEnableComplete != NULL) {
514 callbacks->readSynchronousFlowControlEnableComplete(&returnParam);
515 }
516 HCI_FOREACH_EVT_CALLBACKS_END;
517 }
518
HciCmdOnWriteSynchronousFlowControlEnableFailed(uint8_t status,const void * param)519 static void HciCmdOnWriteSynchronousFlowControlEnableFailed(uint8_t status, const void *param)
520 {
521 HciWriteSynchronousFlowControlEnableReturnParam returnParam = {
522 .status = status,
523 };
524
525 HciEventCallbacks *callbacks = NULL;
526 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
527 if (callbacks->writeSynchronousFlowControlEnableComplete != NULL) {
528 callbacks->writeSynchronousFlowControlEnableComplete(&returnParam);
529 }
530 HCI_FOREACH_EVT_CALLBACKS_END;
531 }
532
HciCmdOnSetControllerToHostFlowControlFailed(uint8_t status,const void * param)533 static void HciCmdOnSetControllerToHostFlowControlFailed(uint8_t status, const void *param)
534 {
535 HciSetControllerToHostFlowControlReturnParam returnParam = {
536 .status = status,
537 };
538
539 HciEventCallbacks *callbacks = NULL;
540 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
541 if (callbacks->setControllerToHostFlowControlComplete != NULL) {
542 callbacks->setControllerToHostFlowControlComplete(&returnParam);
543 }
544 HCI_FOREACH_EVT_CALLBACKS_END;
545 }
546
HciCmdOnHostBufferSizeFailed(uint8_t status,const void * param)547 static void HciCmdOnHostBufferSizeFailed(uint8_t status, const void *param)
548 {
549 HciHostBufferSizeReturnParam returnParam = {
550 .status = status,
551 };
552
553 HciEventCallbacks *callbacks = NULL;
554 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
555 if (callbacks->hostBufferSizeComplete != NULL) {
556 callbacks->hostBufferSizeComplete(&returnParam);
557 }
558 HCI_FOREACH_EVT_CALLBACKS_END;
559 }
560
HciCmdOnReadLinkSupervisionTimeoutFailed(uint8_t status,const void * param)561 static void HciCmdOnReadLinkSupervisionTimeoutFailed(uint8_t status, const void *param)
562 {
563 HciReadLinkSupervisionTimeoutReturnParam returnParam = {
564 .status = status,
565 .handle = ((HciReadLinkSupervisionTimeoutReturnParam *)param)->handle,
566 };
567
568 HciEventCallbacks *callbacks = NULL;
569 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
570 if (callbacks->readLinkSupervisionTimeoutComplete != NULL) {
571 callbacks->readLinkSupervisionTimeoutComplete(&returnParam);
572 }
573 HCI_FOREACH_EVT_CALLBACKS_END;
574 }
575
HciCmdOnWriteLinkSupervisionTimeoutFailed(uint8_t status,const void * param)576 static void HciCmdOnWriteLinkSupervisionTimeoutFailed(uint8_t status, const void *param)
577 {
578 HciWriteLinkSupervisionTimeoutReturnParam returnParam = {
579 .status = status,
580 .handle = ((HciWriteLinkSupervisionTimeoutReturnParam *)param)->handle,
581 };
582
583 HciEventCallbacks *callbacks = NULL;
584 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
585 if (callbacks->writeLinkSupervisionTimeoutComplete != NULL) {
586 callbacks->writeLinkSupervisionTimeoutComplete(&returnParam);
587 }
588 HCI_FOREACH_EVT_CALLBACKS_END;
589 }
590
HciCmdOnReadNumberOfSupportedIACFailed(uint8_t status,const void * param)591 static void HciCmdOnReadNumberOfSupportedIACFailed(uint8_t status, const void *param)
592 {
593 HciReadNumberOfSupportedIacReturnParam returnParam = {
594 .status = status,
595 };
596
597 HciEventCallbacks *callbacks = NULL;
598 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
599 if (callbacks->readNumberOfSupportedIacComplete != NULL) {
600 callbacks->readNumberOfSupportedIacComplete(&returnParam);
601 }
602 HCI_FOREACH_EVT_CALLBACKS_END;
603 }
604
HciCmdOnReadCurrentIacLapFailed(uint8_t status,const void * param)605 static void HciCmdOnReadCurrentIacLapFailed(uint8_t status, const void *param)
606 {
607 HciReadCurrentIacLapReturnParam returParam = {
608 .status = status,
609 };
610
611 HciEventCallbacks *callbacks = NULL;
612 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
613 if (callbacks->readCurrentIacLapComplete != NULL) {
614 callbacks->readCurrentIacLapComplete(&returParam);
615 }
616 HCI_FOREACH_EVT_CALLBACKS_END;
617 }
618
HciCmdOnWriteCurrentIacLapFailed(uint8_t status,const void * param)619 static void HciCmdOnWriteCurrentIacLapFailed(uint8_t status, const void *param)
620 {
621 HciWriteCurrentIacLapReturnParam returnParam = {
622 .status = status,
623 };
624
625 HciEventCallbacks *callbacks = NULL;
626 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
627 if (callbacks->writeCurrentIacLapComplete != NULL) {
628 callbacks->writeCurrentIacLapComplete(&returnParam);
629 }
630 HCI_FOREACH_EVT_CALLBACKS_END;
631 }
632
HciCmdOnSetAfhHostChannelClassificationFailed(uint8_t status,const void * param)633 static void HciCmdOnSetAfhHostChannelClassificationFailed(uint8_t status, const void *param)
634 {
635 HciSetAfhHostChannelClassificationReturnParam returnParam = {
636 .status = status,
637 };
638
639 HciEventCallbacks *callbacks = NULL;
640 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
641 if (callbacks->setAfhHostChannelClassificationComplete != NULL) {
642 callbacks->setAfhHostChannelClassificationComplete(&returnParam);
643 }
644 HCI_FOREACH_EVT_CALLBACKS_END;
645 }
646
HciCmdOnReadInquiryScanTypeFailed(uint8_t status,const void * param)647 static void HciCmdOnReadInquiryScanTypeFailed(uint8_t status, const void *param)
648 {
649 HciReadInquiryScanTypeReturnParam returnParam = {
650 .status = status,
651 };
652
653 HciEventCallbacks *callbacks = NULL;
654 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
655 if (callbacks->readInquiryScanTypeComplete != NULL) {
656 callbacks->readInquiryScanTypeComplete(&returnParam);
657 }
658 HCI_FOREACH_EVT_CALLBACKS_END;
659 }
660
HciCmdOnWriteInquiryScanTypeFailed(uint8_t status,const void * param)661 static void HciCmdOnWriteInquiryScanTypeFailed(uint8_t status, const void *param)
662 {
663 HciWriteInquiryScanTypeReturnParam returnParam = {
664 .status = status,
665 };
666
667 HciEventCallbacks *callbacks = NULL;
668 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
669 if (callbacks->writeInquiryScanTypeComplete != NULL) {
670 callbacks->writeInquiryScanTypeComplete(&returnParam);
671 }
672 HCI_FOREACH_EVT_CALLBACKS_END;
673 }
674
HciCmdOnReadInquiryModeFailed(uint8_t status,const void * param)675 static void HciCmdOnReadInquiryModeFailed(uint8_t status, const void *param)
676 {
677 HciReadInquiryModeReturnParam returnParam = {
678 .status = status,
679 };
680
681 HciEventCallbacks *callbacks = NULL;
682 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
683 if (callbacks->readInquiryModeComplete != NULL) {
684 callbacks->readInquiryModeComplete(&returnParam);
685 }
686 HCI_FOREACH_EVT_CALLBACKS_END;
687 }
688
HciCmdOnWriteInquiryModeFailed(uint8_t status,const void * param)689 static void HciCmdOnWriteInquiryModeFailed(uint8_t status, const void *param)
690 {
691 HciWriteInquiryModeReturnParam returnParam = {
692 .status = status,
693 };
694
695 HciEventCallbacks *callbacks = NULL;
696 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
697 if (callbacks->writeInquiryModeComplete != NULL) {
698 callbacks->writeInquiryModeComplete(&returnParam);
699 }
700 HCI_FOREACH_EVT_CALLBACKS_END;
701 }
702
HciCmdOnReadPageScanTypeFailed(uint8_t status,const void * param)703 static void HciCmdOnReadPageScanTypeFailed(uint8_t status, const void *param)
704 {
705 HciReadPageScanTypeReturnParam returnParam = {
706 .status = status,
707 };
708
709 HciEventCallbacks *callbacks = NULL;
710 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
711 if (callbacks->readPageScanTypeComplete != NULL) {
712 callbacks->readPageScanTypeComplete(&returnParam);
713 }
714 HCI_FOREACH_EVT_CALLBACKS_END;
715 }
716
HciCmdOnWritePageScanTypeFailed(uint8_t status,const void * pararm)717 static void HciCmdOnWritePageScanTypeFailed(uint8_t status, const void *pararm)
718 {
719 HciWritePageScanTypeReturnParam returnParam = {
720 .status = status,
721 };
722
723 HciEventCallbacks *callbacks = NULL;
724 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
725 if (callbacks->writePageScanTypeComplete != NULL) {
726 callbacks->writePageScanTypeComplete(&returnParam);
727 }
728 HCI_FOREACH_EVT_CALLBACKS_END;
729 }
730
HciCmdOnReadAfhChannelAssessmentModeFailed(uint8_t status,const void * pararm)731 static void HciCmdOnReadAfhChannelAssessmentModeFailed(uint8_t status, const void *pararm)
732 {
733 HciReadAfhChannelAssessmentModeReturnParam returnParam = {
734 .status = status,
735 };
736
737 HciEventCallbacks *callbacks = NULL;
738 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
739 if (callbacks->readAfhChannelAssessmentModeComplete != NULL) {
740 callbacks->readAfhChannelAssessmentModeComplete(&returnParam);
741 }
742 HCI_FOREACH_EVT_CALLBACKS_END;
743 }
744
HciCmdOnWriteAfhChannelAssessmentModeFailed(uint8_t status,const void * pararm)745 static void HciCmdOnWriteAfhChannelAssessmentModeFailed(uint8_t status, const void *pararm)
746 {
747 HciWriteAfhChannelAssessmentModeReturnParam returnParam = {
748 .status = status,
749 };
750
751 HciEventCallbacks *callbacks = NULL;
752 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
753 if (callbacks->writeAfhChannelAssessmentModeComplete != NULL) {
754 callbacks->writeAfhChannelAssessmentModeComplete(&returnParam);
755 }
756 HCI_FOREACH_EVT_CALLBACKS_END;
757 }
758
HciCmdOnReadExtendedInquiryResponseFailed(uint8_t status,const void * pararm)759 static void HciCmdOnReadExtendedInquiryResponseFailed(uint8_t status, const void *pararm)
760 {
761 HciReadExtendedInquiryResponseReturnParam returnParam = {
762 .status = status,
763 };
764
765 HciEventCallbacks *callbacks = NULL;
766 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
767 if (callbacks->readExtendedInquiryResponseComplete != NULL) {
768 callbacks->readExtendedInquiryResponseComplete(&returnParam);
769 }
770 HCI_FOREACH_EVT_CALLBACKS_END;
771 }
772
HciCmdOnWriteExtendedInquiryResponseFailed(uint8_t status,const void * param)773 static void HciCmdOnWriteExtendedInquiryResponseFailed(uint8_t status, const void *param)
774 {
775 HciWriteExtendedInquiryResponseReturnParam returnParam = {
776 .status = status,
777 };
778
779 HciEventCallbacks *callbacks = NULL;
780 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
781 if (callbacks->writeExtendedInquiryResponseComplete != NULL) {
782 callbacks->writeExtendedInquiryResponseComplete(&returnParam);
783 }
784 HCI_FOREACH_EVT_CALLBACKS_END;
785 }
786
HciCmdOnReadSimplePairingModeFailed(uint8_t status,const void * param)787 static void HciCmdOnReadSimplePairingModeFailed(uint8_t status, const void *param)
788 {
789 HciReadSimplePairingModeReturnParam returnParam = {
790 .status = status,
791 };
792
793 HciEventCallbacks *callbacks = NULL;
794 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
795 if (callbacks->readSimplePairingModeComplete != NULL) {
796 callbacks->readSimplePairingModeComplete(&returnParam);
797 }
798 HCI_FOREACH_EVT_CALLBACKS_END;
799 }
800
HciCmdOnWriteSimplePairingModeFailed(uint8_t status,const void * param)801 static void HciCmdOnWriteSimplePairingModeFailed(uint8_t status, const void *param)
802 {
803 HciWriteSimplePairingModeReturnParam returnParam = {
804 .status = status,
805 };
806
807 HciEventCallbacks *callbacks = NULL;
808 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
809 if (callbacks->writeSimplePairingModeComplete != NULL) {
810 callbacks->writeSimplePairingModeComplete(&returnParam);
811 }
812 HCI_FOREACH_EVT_CALLBACKS_END;
813 }
814
HciCmdOnReadLocalOobDataFailed(uint8_t status,const void * param)815 static void HciCmdOnReadLocalOobDataFailed(uint8_t status, const void *param)
816 {
817 HciReadLocalOOBDataReturnParam returnParam = {
818 .status = status,
819 };
820
821 HciEventCallbacks *callbacks = NULL;
822 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
823 if (callbacks->readLocalOOBDataComplete != NULL) {
824 callbacks->readLocalOOBDataComplete(&returnParam);
825 }
826 HCI_FOREACH_EVT_CALLBACKS_END;
827 }
828
HciCmdOnReadInquiryResponseTransmitPowerLevelFailed(uint8_t status,const void * param)829 static void HciCmdOnReadInquiryResponseTransmitPowerLevelFailed(uint8_t status, const void *param)
830 {
831 HciReadInquiryResponseTransmitPowerLevelReturnParam returnParam = {
832 .status = status,
833 };
834
835 HciEventCallbacks *callbacks = NULL;
836 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
837 if (callbacks->readInquiryResponseTransmitPowerLevelComplete != NULL) {
838 callbacks->readInquiryResponseTransmitPowerLevelComplete(&returnParam);
839 }
840 HCI_FOREACH_EVT_CALLBACKS_END;
841 }
842
HciCmdOnWriteInquiryTransmitPowerLevelFailed(uint8_t status,const void * param)843 static void HciCmdOnWriteInquiryTransmitPowerLevelFailed(uint8_t status, const void *param)
844 {
845 HciWriteInquiryTransmitPowerLevelReturnParam returnParam = {
846 .status = status,
847 };
848
849 HciEventCallbacks *callbacks = NULL;
850 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
851 if (callbacks->writeInquiryTransmitPowerLevelComplete != NULL) {
852 callbacks->writeInquiryTransmitPowerLevelComplete(&returnParam);
853 }
854 HCI_FOREACH_EVT_CALLBACKS_END;
855 }
856
HciCmdOnSendKeypressNotificationFailed(uint8_t status,const void * param)857 static void HciCmdOnSendKeypressNotificationFailed(uint8_t status, const void *param)
858 {
859 HciSendKeypressNotificationReturnParam returnParam = {
860 .status = status,
861 .bdAddr = ((HciSendKeypressNotificationParam *)param)->bdAddr,
862 };
863
864 HciEventCallbacks *callbacks = NULL;
865 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
866 if (callbacks->sendKeypressNotificationComplete != NULL) {
867 callbacks->sendKeypressNotificationComplete(&returnParam);
868 }
869 HCI_FOREACH_EVT_CALLBACKS_END;
870 }
871
HciCmdOnReadDefaultErroneousDataReportingFailed(uint8_t status,const void * param)872 static void HciCmdOnReadDefaultErroneousDataReportingFailed(uint8_t status, const void *param)
873 {
874 HciReadDefaultErroneousDataReportingReturnParam returnParam = {
875 .status = status,
876 };
877
878 HciEventCallbacks *callbacks = NULL;
879 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
880 if (callbacks->readDefaultErroneousDataReportingComplete != NULL) {
881 callbacks->readDefaultErroneousDataReportingComplete(&returnParam);
882 }
883 HCI_FOREACH_EVT_CALLBACKS_END;
884 }
885
HciCmdOnWriteDefaultErroneousDataReportingFailed(uint8_t status,const void * param)886 static void HciCmdOnWriteDefaultErroneousDataReportingFailed(uint8_t status, const void *param)
887 {
888 HciWriteDefaultErroneousDataReportingReturnParam returnParam = {
889 .status = status,
890 };
891
892 HciEventCallbacks *callbacks = NULL;
893 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
894 if (callbacks->writeDefaultErroneousDataReportingComplete != NULL) {
895 callbacks->writeDefaultErroneousDataReportingComplete(&returnParam);
896 }
897 HCI_FOREACH_EVT_CALLBACKS_END;
898 }
899
HciCmdOnReadLogicalLinkAcceptTimeoutFailed(uint8_t status,const void * param)900 static void HciCmdOnReadLogicalLinkAcceptTimeoutFailed(uint8_t status, const void *param)
901 {
902 HciReadLogicalLinkAcceptTimeoutReturnParam returnParam = {
903 .status = status,
904 };
905
906 HciEventCallbacks *callbacks = NULL;
907 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
908 if (callbacks->readLogicalLinkAcceptTimeoutComplete != NULL) {
909 callbacks->readLogicalLinkAcceptTimeoutComplete(&returnParam);
910 }
911 HCI_FOREACH_EVT_CALLBACKS_END;
912 }
913
HciCmdOnWriteLogicalLinkAcceptTimeoutFailed(uint8_t status,const void * param)914 static void HciCmdOnWriteLogicalLinkAcceptTimeoutFailed(uint8_t status, const void *param)
915 {
916 HciWriteLogicalLinkAcceptTimeoutReturnParam returnParam = {
917 .status = status,
918 };
919
920 HciEventCallbacks *callbacks = NULL;
921 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
922 if (callbacks->writeLogicalLinkAcceptTimeoutComplete != NULL) {
923 callbacks->writeLogicalLinkAcceptTimeoutComplete(&returnParam);
924 }
925 HCI_FOREACH_EVT_CALLBACKS_END;
926 }
927
HciCmdOnSetEventMaskPage2Failed(uint8_t status,const void * param)928 static void HciCmdOnSetEventMaskPage2Failed(uint8_t status, const void *param)
929 {
930 HciSetEventMaskPage2ReturnParam returnParam = {
931 .status = status,
932 };
933
934 HciEventCallbacks *callbacks = NULL;
935 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
936 if (callbacks->setEventMaskPage2Complete != NULL) {
937 callbacks->setEventMaskPage2Complete(&returnParam);
938 }
939 HCI_FOREACH_EVT_CALLBACKS_END;
940 }
941
HciCmdOnReadLocationDataFailed(uint8_t status,const void * param)942 static void HciCmdOnReadLocationDataFailed(uint8_t status, const void *param)
943 {
944 HciReadLocationDataReturnParam returnParam = {
945 .status = status,
946 };
947
948 HciEventCallbacks *callbacks = NULL;
949 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
950 if (callbacks->readLocationDataComplete != NULL) {
951 callbacks->readLocationDataComplete(&returnParam);
952 }
953 HCI_FOREACH_EVT_CALLBACKS_END;
954 }
955
HciCmdOnWriteLocationDataFailed(uint8_t status,const void * param)956 static void HciCmdOnWriteLocationDataFailed(uint8_t status, const void *param)
957 {
958 HciWriteLocationDataReturnParam returnParam = {
959 .status = status,
960 };
961
962 HciEventCallbacks *callbacks = NULL;
963 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
964 if (callbacks->writeLocationDataComplete != NULL) {
965 callbacks->writeLocationDataComplete(&returnParam);
966 }
967 HCI_FOREACH_EVT_CALLBACKS_END;
968 }
969
HciCmdOnReadFlowControlModeFailed(uint8_t status,const void * param)970 static void HciCmdOnReadFlowControlModeFailed(uint8_t status, const void *param)
971 {
972 HciReadFlowControlModeReturnParam returnParam = {
973 .status = status,
974 };
975
976 HciEventCallbacks *callbacks = NULL;
977 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
978 if (callbacks->readFlowControlModeComplete != NULL) {
979 callbacks->readFlowControlModeComplete(&returnParam);
980 }
981 HCI_FOREACH_EVT_CALLBACKS_END;
982 }
983
HciCmdOnWriteFlowControlModeFailed(uint8_t status,const void * param)984 static void HciCmdOnWriteFlowControlModeFailed(uint8_t status, const void *param)
985 {
986 HciWriteFlowControlModeReturnParam returnParam = {
987 .status = status,
988 };
989
990 HciEventCallbacks *callbacks = NULL;
991 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
992 if (callbacks->writeFlowControlModeComplete != NULL) {
993 callbacks->writeFlowControlModeComplete(&returnParam);
994 }
995 HCI_FOREACH_EVT_CALLBACKS_END;
996 }
997
HciCmdOnReadEnhancedTransmitPowerLevelFailed(uint8_t status,const void * param)998 static void HciCmdOnReadEnhancedTransmitPowerLevelFailed(uint8_t status, const void *param)
999 {
1000 HciReadEnhancedTransmitPowerLevelReturnParam returnParam = {
1001 .status = status,
1002 .connectionHandle = ((HciReadEnhancedTransmitPowerLevelReturnParam *)param)->connectionHandle,
1003 };
1004
1005 HciEventCallbacks *callbacks = NULL;
1006 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1007 if (callbacks->readEnhancedTransmitPowerLevelComplete != NULL) {
1008 callbacks->readEnhancedTransmitPowerLevelComplete(&returnParam);
1009 }
1010 HCI_FOREACH_EVT_CALLBACKS_END;
1011 }
1012
HciCmdOnReadBestEffortFlushTimeoutFailed(uint8_t status,const void * param)1013 static void HciCmdOnReadBestEffortFlushTimeoutFailed(uint8_t status, const void *param)
1014 {
1015 HciReadBestEffortFlushTimeoutReturnParam returnParam = {
1016 .status = status,
1017 };
1018
1019 HciEventCallbacks *callbacks = NULL;
1020 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1021 if (callbacks->readBestEffortFlushTimeoutComplete != NULL) {
1022 callbacks->readBestEffortFlushTimeoutComplete(&returnParam);
1023 }
1024 HCI_FOREACH_EVT_CALLBACKS_END;
1025 }
1026
HciCmdOnWriteBestEffortFlushTimeoutFailed(uint8_t status,const void * param)1027 static void HciCmdOnWriteBestEffortFlushTimeoutFailed(uint8_t status, const void *param)
1028 {
1029 HciWriteBestEffortFlushTimeoutReturnParam returnParam = {
1030 .status = status,
1031 };
1032
1033 HciEventCallbacks *callbacks = NULL;
1034 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1035 if (callbacks->writeBestEffortFlushTimeoutComplete != NULL) {
1036 callbacks->writeBestEffortFlushTimeoutComplete(&returnParam);
1037 }
1038 HCI_FOREACH_EVT_CALLBACKS_END;
1039 }
1040
HciCmdOnReadLeHostSupportFailed(uint8_t status,const void * param)1041 static void HciCmdOnReadLeHostSupportFailed(uint8_t status, const void *param)
1042 {
1043 HciReadLeHostSupportReturnParam returnParam = {
1044 .status = status,
1045 };
1046
1047 HciEventCallbacks *callbacks = NULL;
1048 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1049 if (callbacks->readLeHostSupportComplete != NULL) {
1050 callbacks->readLeHostSupportComplete(&returnParam);
1051 }
1052 HCI_FOREACH_EVT_CALLBACKS_END;
1053 }
1054
HciCmdOnWriteLeHostSupportFailed(uint8_t status,const void * param)1055 static void HciCmdOnWriteLeHostSupportFailed(uint8_t status, const void *param)
1056 {
1057 HciWriteLeHostSupportReturnParam returnParam = {
1058 .status = status,
1059 };
1060
1061 HciEventCallbacks *callbacks = NULL;
1062 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1063 if (callbacks->writeLeHostSupportComplete != NULL) {
1064 callbacks->writeLeHostSupportComplete(&returnParam);
1065 }
1066 HCI_FOREACH_EVT_CALLBACKS_END;
1067 }
1068
HciCmdOnSetMwsChannelParametersFailed(uint8_t status,const void * param)1069 static void HciCmdOnSetMwsChannelParametersFailed(uint8_t status, const void *param)
1070 {
1071 HciSetMwsChannelParametersReturnParam returnParam = {
1072 .status = status,
1073 };
1074
1075 HciEventCallbacks *callbacks = NULL;
1076 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1077 if (callbacks->setMwsChannelParametersComplete != NULL) {
1078 callbacks->setMwsChannelParametersComplete(&returnParam);
1079 }
1080 HCI_FOREACH_EVT_CALLBACKS_END;
1081 }
1082
HciCmdOnSetMwsSignalingFailed(uint8_t status,const void * param)1083 static void HciCmdOnSetMwsSignalingFailed(uint8_t status, const void *param)
1084 {
1085 HciSetMwsSignalingReturnParam returnParam = {
1086 .status = status,
1087 };
1088
1089 HciEventCallbacks *callbacks = NULL;
1090 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1091 if (callbacks->setMwsSignalingComplete != NULL) {
1092 callbacks->setMwsSignalingComplete(&returnParam);
1093 }
1094 HCI_FOREACH_EVT_CALLBACKS_END;
1095 }
1096
HciCmdOnSetMwsTransportLayerFailed(uint8_t status,const void * param)1097 static void HciCmdOnSetMwsTransportLayerFailed(uint8_t status, const void *param)
1098 {
1099 HciSetMwsTransportLayerReturnParam returnParam = {
1100 .status = status,
1101 };
1102
1103 HciEventCallbacks *callbacks = NULL;
1104 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1105 if (callbacks->setMwsTransportLayerComplete != NULL) {
1106 callbacks->setMwsTransportLayerComplete(&returnParam);
1107 }
1108 HCI_FOREACH_EVT_CALLBACKS_END;
1109 }
1110
HciCmdOnSetReservedLtAddrFailed(uint8_t status,const void * param)1111 static void HciCmdOnSetReservedLtAddrFailed(uint8_t status, const void *param)
1112 {
1113 HciSetReservedLtAddrReturnParam returnParam = {
1114 .status = status,
1115 };
1116
1117 HciEventCallbacks *callbacks = NULL;
1118 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1119 if (callbacks->setReservedLtAddrComplete != NULL) {
1120 callbacks->setReservedLtAddrComplete(&returnParam);
1121 }
1122 HCI_FOREACH_EVT_CALLBACKS_END;
1123 }
1124
HciCmdOnDeleteReservedLtAddrFailed(uint8_t status,const void * param)1125 static void HciCmdOnDeleteReservedLtAddrFailed(uint8_t status, const void *param)
1126 {
1127 HciDeleteReservedLtAddrReturnParam returnParam = {
1128 .status = status,
1129 };
1130
1131 HciEventCallbacks *callbacks = NULL;
1132 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1133 if (callbacks->deleteReservedLtAddrComplete != NULL) {
1134 callbacks->deleteReservedLtAddrComplete(&returnParam);
1135 }
1136 HCI_FOREACH_EVT_CALLBACKS_END;
1137 }
1138
HciCmdOnReadSynchronizationTrainParametersFailed(uint8_t status,const void * param)1139 static void HciCmdOnReadSynchronizationTrainParametersFailed(uint8_t status, const void *param)
1140 {
1141 HciReadSynchronizationTrainParametersReturnParam returnParam = {
1142 .status = status,
1143 };
1144
1145 HciEventCallbacks *callbacks = NULL;
1146 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1147 if (callbacks->readSynchronizationTrainParametersComplete != NULL) {
1148 callbacks->readSynchronizationTrainParametersComplete(&returnParam);
1149 }
1150 HCI_FOREACH_EVT_CALLBACKS_END;
1151 }
1152
HciCmdOnWriteSynchronizationTrainParametersFailed(uint8_t status,const void * param)1153 static void HciCmdOnWriteSynchronizationTrainParametersFailed(uint8_t status, const void *param)
1154 {
1155 HciWriteSynchronizationTrainParametersReturnParam returnParam = {
1156 .status = status,
1157 };
1158
1159 HciEventCallbacks *callbacks = NULL;
1160 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1161 if (callbacks->writeSynchronizationTrainParametersComplete != NULL) {
1162 callbacks->writeSynchronizationTrainParametersComplete(&returnParam);
1163 }
1164 HCI_FOREACH_EVT_CALLBACKS_END;
1165 }
1166
HciCmdOnReadSecureConnectionsHostSupportFailed(uint8_t status,const void * param)1167 static void HciCmdOnReadSecureConnectionsHostSupportFailed(uint8_t status, const void *param)
1168 {
1169 HciReadSecureConnectionsHostSupportReturnParam returnParam = {
1170 .status = status,
1171 };
1172
1173 HciEventCallbacks *callbacks = NULL;
1174 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1175 if (callbacks->readSecureConnectionsHostSupportComplete != NULL) {
1176 callbacks->readSecureConnectionsHostSupportComplete(&returnParam);
1177 }
1178 HCI_FOREACH_EVT_CALLBACKS_END;
1179 }
1180
HciCmdOnWriteSecureConnectionsHostSupportFailed(uint8_t status,const void * param)1181 static void HciCmdOnWriteSecureConnectionsHostSupportFailed(uint8_t status, const void *param)
1182 {
1183 HciWriteSecureConnectionsHostSupportReturnParam returnParam = {
1184 .status = status,
1185 };
1186
1187 HciEventCallbacks *callbacks = NULL;
1188 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1189 if (callbacks->writeSecureConnectionsHostSupportComplete != NULL) {
1190 callbacks->writeSecureConnectionsHostSupportComplete(&returnParam);
1191 }
1192 HCI_FOREACH_EVT_CALLBACKS_END;
1193 }
1194
HciCmdOnReadAuthenticatedPayloadTimeoutFailed(uint8_t status,const void * param)1195 static void HciCmdOnReadAuthenticatedPayloadTimeoutFailed(uint8_t status, const void *param)
1196 {
1197 HciReadAuthenticatedPayloadTimeoutReturnParam returnParam = {
1198 .status = status,
1199 .connectionHandle = ((HciReadAuthenticatedPayloadTimeoutReturnParam *)param)->connectionHandle,
1200 };
1201
1202 HciEventCallbacks *callbacks = NULL;
1203 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1204 if (callbacks->readAuthenticatedPayloadTimeoutComplete != NULL) {
1205 callbacks->readAuthenticatedPayloadTimeoutComplete(&returnParam);
1206 }
1207 HCI_FOREACH_EVT_CALLBACKS_END;
1208 }
1209
HciCmdOnWriteAuthenticatedPayloadTimeoutFailed(uint8_t status,const void * param)1210 static void HciCmdOnWriteAuthenticatedPayloadTimeoutFailed(uint8_t status, const void *param)
1211 {
1212 HciWriteAuthenticatedPayloadTimeoutReturnParam returnParam = {
1213 .status = status,
1214 .connectionHandle = ((HciWriteAuthenticatedPayloadTimeoutParam *)param)->connectionHandle,
1215 };
1216
1217 HciEventCallbacks *callbacks = NULL;
1218 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1219 if (callbacks->writeAuthenticatedPayloadTimeoutComplete != NULL) {
1220 callbacks->writeAuthenticatedPayloadTimeoutComplete(&returnParam);
1221 }
1222 HCI_FOREACH_EVT_CALLBACKS_END;
1223 }
1224
HciCmdOnReadLocalOobExtendedDataFailed(uint8_t status,const void * param)1225 static void HciCmdOnReadLocalOobExtendedDataFailed(uint8_t status, const void *param)
1226 {
1227 HciReadLocalOobExtendedDataReturnParam returnParam = {
1228 .status = status,
1229 };
1230
1231 HciEventCallbacks *callbacks = NULL;
1232 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1233 if (callbacks->readLocalOOBExtendedDataComplete != NULL) {
1234 callbacks->readLocalOOBExtendedDataComplete(&returnParam);
1235 }
1236 HCI_FOREACH_EVT_CALLBACKS_END;
1237 }
1238
HciCmdOnReadExtendedPageTimeoutFailed(uint8_t status,const void * param)1239 static void HciCmdOnReadExtendedPageTimeoutFailed(uint8_t status, const void *param)
1240 {
1241 HciReadExtendedPageTimeoutReturnParam returnParam = {
1242 .status = status,
1243 };
1244
1245 HciEventCallbacks *callbacks = NULL;
1246 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1247 if (callbacks->readExtendedPageTimeoutComplete != NULL) {
1248 callbacks->readExtendedPageTimeoutComplete(&returnParam);
1249 }
1250 HCI_FOREACH_EVT_CALLBACKS_END;
1251 }
1252
HciCmdOnWriteExtendedPageTimeoutFailed(uint8_t status,const void * param)1253 static void HciCmdOnWriteExtendedPageTimeoutFailed(uint8_t status, const void *param)
1254 {
1255 HciWriteExtendedPageTimeoutReturnParam returnParam = {
1256 .status = status,
1257 };
1258
1259 HciEventCallbacks *callbacks = NULL;
1260 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1261 if (callbacks->writeExtendedPageTimeoutComplete != NULL) {
1262 callbacks->writeExtendedPageTimeoutComplete(&returnParam);
1263 }
1264 HCI_FOREACH_EVT_CALLBACKS_END;
1265 }
1266
HciCmdOnReadExtendedInquiryLengthFailed(uint8_t status,const void * param)1267 static void HciCmdOnReadExtendedInquiryLengthFailed(uint8_t status, const void *param)
1268 {
1269 HciReadExtendedInquiryLengthReturnParam returnParam = {
1270 .status = status,
1271 };
1272
1273 HciEventCallbacks *callbacks = NULL;
1274 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1275 if (callbacks->readExtendedInquiryLengthComplete != NULL) {
1276 callbacks->readExtendedInquiryLengthComplete(&returnParam);
1277 }
1278 HCI_FOREACH_EVT_CALLBACKS_END;
1279 }
1280
HciCmdOnWriteExtendedInquiryLengthFailed(uint8_t status,const void * param)1281 static void HciCmdOnWriteExtendedInquiryLengthFailed(uint8_t status, const void *param)
1282 {
1283 HciWriteExtendedInquiryLengthReturnParam returnParam = {
1284 .status = status,
1285 };
1286
1287 HciEventCallbacks *callbacks = NULL;
1288 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1289 if (callbacks->writeExtendedInquiryLengthComplete != NULL) {
1290 callbacks->writeExtendedInquiryLengthComplete(&returnParam);
1291 }
1292 HCI_FOREACH_EVT_CALLBACKS_END;
1293 }
1294
1295 static HciCmdOnFailedFunc g_funcMap[] = {
1296 NULL, // 0x0000
1297 HciCmdOnSetEventMaskFailed, // 0x0001
1298 NULL, // 0x0002
1299 HciCmdOnResetFailed, // 0x0003
1300 NULL, // 0x0004
1301 HciCmdOnSetEventFilterFailed, // 0x0005
1302 NULL, // 0x0006
1303 NULL, // 0x0007
1304 HciCmdOnFlushFailed, // 0x0008
1305 HciCmdOnReadPinTypeFailed, // 0x0009
1306 HciCmdOnWritePinTypeFailed, // 0x000A
1307 HciCmdOnCreateNewUnitKeyFailed, // 0x000B
1308 NULL, // 0x000C
1309 HciCmdOnReadStoredLinkKeyFailed, // 0x000D
1310 NULL, // 0x000E
1311 NULL, // 0x000F
1312 NULL, // 0x0010
1313 NULL, // 0x0011
1314 HciCmdOnDeleteStoredLinkKeyFailed, // 0x0012
1315 HciCmdOnWriteLocalNameFailed, // 0x0013
1316 HciCmdOnReadLocalNameFailed, // 0x0014
1317 HciCmdOnReadConnectionAcceptTimeoutFailed, // 0x0015
1318 HciCmdOnWriteConnectionAcceptTimeoutFailed, // 0x0016
1319 HciCmdOnReadPageTimeoutFailed, // 0x0017
1320 HciCmdOnWritePageTimeoutFailed, // 0x0018
1321 HciCmdOnReadScanEnableFailed, // 0x0019
1322 HciCmdOnWriteScanEnableFailed, // 0x001A
1323 HciCmdOnReadPageScanActivityFailed, // 0x001B
1324 HciCmdOnWritePageScanActivityFailed, // 0x001C
1325 HciCmdOnReadInquiryScanActivityFailed, // 0x001D
1326 HciCmdOnWriteInquiryScanActivityFailed, // 0x001E
1327 HciCmdOnReadAuthenticationEnableFailed, // 0x001F
1328 HciCmdOnWriteAuthenticationEnableFailed, // 0x0020
1329 NULL, // 0x0021
1330 NULL, // 0x0022
1331 HciCmdOnReadClassofDeviceFailed, // 0x0023
1332 HciCmdOnWriteClassofDeviceFailed, // 0x0024
1333 HciCmdOnReadVoiceSettingFailed, // 0x0025
1334 HciCmdOnWriteVoiceSettingFailed, // 0x0026
1335 HciCmdOnReadAutomaticFlushTimeoutFailed, // 0x0027
1336 HciCmdOnWriteAutomaticFlushTimeoutFailed, // 0x0028
1337 HciCmdOnReadNumBroadcastRetransmissionsFailed, // 0x0029
1338 HciCmdOnWriteNumBroadcastRetransmissionsFailed, // 0x002A
1339 HciCmdOnReadHoldModeActivityFailed, // 0x002B
1340 HciCmdOnWriteHoldModeActivityFailed, // 0x002C
1341 HciCmdOnReadTransmitPowerLevelFailed, // 0x002D
1342 HciCmdOnReadSynchronousFlowControlEnableFailed, // 0x002E
1343 HciCmdOnWriteSynchronousFlowControlEnableFailed, // 0x002F
1344 NULL, // 0x0030
1345 HciCmdOnSetControllerToHostFlowControlFailed, // 0x0031
1346 NULL, // 0x0032
1347 HciCmdOnHostBufferSizeFailed, // 0x0033
1348 NULL, // 0x0034
1349 NULL, // 0x0035
1350 HciCmdOnReadLinkSupervisionTimeoutFailed, // 0x0036
1351 HciCmdOnWriteLinkSupervisionTimeoutFailed, // 0x0037
1352 HciCmdOnReadNumberOfSupportedIACFailed, // 0x0038
1353 HciCmdOnReadCurrentIacLapFailed, // 0x0039
1354 HciCmdOnWriteCurrentIacLapFailed, // 0x003A
1355 NULL, // 0x003B
1356 NULL, // 0x003C
1357 NULL, // 0x003D
1358 NULL, // 0x003E
1359 HciCmdOnSetAfhHostChannelClassificationFailed, // 0x003F
1360 NULL, // 0x0040
1361 NULL, // 0x0041
1362 HciCmdOnReadInquiryScanTypeFailed, // 0x0042
1363 HciCmdOnWriteInquiryScanTypeFailed, // 0x0043
1364 HciCmdOnReadInquiryModeFailed, // 0x0044
1365 HciCmdOnWriteInquiryModeFailed, // 0x0045
1366 HciCmdOnReadPageScanTypeFailed, // 0x0046
1367 HciCmdOnWritePageScanTypeFailed, // 0x0047
1368 HciCmdOnReadAfhChannelAssessmentModeFailed, // 0x0048
1369 HciCmdOnWriteAfhChannelAssessmentModeFailed, // 0x0049
1370 NULL, // 0x004A
1371 NULL, // 0x004B
1372 NULL, // 0x004C
1373 NULL, // 0x004D
1374 NULL, // 0x004E
1375 NULL, // 0x004F
1376 NULL, // 0x0050
1377 HciCmdOnReadExtendedInquiryResponseFailed, // 0x0051
1378 HciCmdOnWriteExtendedInquiryResponseFailed, // 0x0052
1379 NULL, // 0x0053
1380 NULL, // 0x0054
1381 HciCmdOnReadSimplePairingModeFailed, // 0x0055
1382 HciCmdOnWriteSimplePairingModeFailed, // 0x0056
1383 HciCmdOnReadLocalOobDataFailed, // 0x0057
1384 HciCmdOnReadInquiryResponseTransmitPowerLevelFailed, // 0x0058
1385 HciCmdOnWriteInquiryTransmitPowerLevelFailed, // 0x0059
1386 HciCmdOnReadDefaultErroneousDataReportingFailed, // 0x005A
1387 HciCmdOnWriteDefaultErroneousDataReportingFailed, // 0x005B
1388 NULL, // 0x005C
1389 NULL, // 0x005D
1390 NULL, // 0x005E
1391 NULL, // 0x005F
1392 HciCmdOnSendKeypressNotificationFailed, // 0x0060
1393 HciCmdOnReadLogicalLinkAcceptTimeoutFailed, // 0x0061
1394 HciCmdOnWriteLogicalLinkAcceptTimeoutFailed, // 0x0062
1395 HciCmdOnSetEventMaskPage2Failed, // 0x0063
1396 HciCmdOnReadLocationDataFailed, // 0x0064
1397 HciCmdOnWriteLocationDataFailed, // 0x0065
1398 HciCmdOnReadFlowControlModeFailed, // 0x0066
1399 HciCmdOnWriteFlowControlModeFailed, // 0x0067
1400 HciCmdOnReadEnhancedTransmitPowerLevelFailed, // 0x0068
1401 HciCmdOnReadBestEffortFlushTimeoutFailed, // 0x0069
1402 HciCmdOnWriteBestEffortFlushTimeoutFailed, // 0x006A
1403 NULL, // 0x006B
1404 HciCmdOnReadLeHostSupportFailed, // 0x006C
1405 HciCmdOnWriteLeHostSupportFailed, // 0x006D
1406 HciCmdOnSetMwsChannelParametersFailed, // 0x006E
1407 NULL, // 0x006F
1408 HciCmdOnSetMwsSignalingFailed, // 0x0070
1409 HciCmdOnSetMwsTransportLayerFailed, // 0x0071
1410 NULL, // 0x0072
1411 NULL, // 0x0073
1412 HciCmdOnSetReservedLtAddrFailed, // 0x0074
1413 HciCmdOnDeleteReservedLtAddrFailed, // 0x0075
1414 NULL, // 0x0076
1415 HciCmdOnReadSynchronizationTrainParametersFailed, // 0x0077
1416 HciCmdOnWriteSynchronizationTrainParametersFailed, // 0x0078
1417 HciCmdOnReadSecureConnectionsHostSupportFailed, // 0x0079
1418 HciCmdOnWriteSecureConnectionsHostSupportFailed, // 0x007A
1419 HciCmdOnReadAuthenticatedPayloadTimeoutFailed, // 0x007B
1420 HciCmdOnWriteAuthenticatedPayloadTimeoutFailed, // 0x007C
1421 HciCmdOnReadLocalOobExtendedDataFailed, // 0x007D
1422 HciCmdOnReadExtendedPageTimeoutFailed, // 0x007E
1423 HciCmdOnWriteExtendedPageTimeoutFailed, // 0x007F
1424 HciCmdOnReadExtendedInquiryLengthFailed, // 0x0080
1425 HciCmdOnWriteExtendedInquiryLengthFailed, // 0x0081
1426 };
1427
1428 #define CONTROLLERBASEBAND_OCF_MAX 0x0081
1429
HciOnControllerBasebandCmdFailed(uint16_t opCode,uint8_t status,const void * param)1430 void HciOnControllerBasebandCmdFailed(uint16_t opCode, uint8_t status, const void *param)
1431 {
1432 uint16_t ocf = GET_OCF(opCode);
1433 if (ocf > CONTROLLERBASEBAND_OCF_MAX) {
1434 return;
1435 }
1436
1437 HciCmdOnFailedFunc func = g_funcMap[ocf];
1438 if (func != NULL) {
1439 func(status, param);
1440 }
1441 }