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