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_link_ctrl.h"
17
18 #include <securec.h>
19
20 #include "btm/btm_acl.h"
21 #include "btstack.h"
22 #include "platform/include/list.h"
23
24 #include "hci/evt/hci_evt.h"
25 #include "hci/hci.h"
26 #include "hci/hci_def.h"
27
28 #include "hci_cmd_failure.h"
29
HciCmdOnInquiryFailed(uint8_t status,const void * param)30 static void HciCmdOnInquiryFailed(uint8_t status, const void *param)
31 {
32 HciInquiryCompleteEventParam eventParam = {
33 .status = status,
34 };
35
36 HciEventCallbacks *callbacks = NULL;
37 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
38 if (callbacks->inquiryComplete != NULL) {
39 callbacks->inquiryComplete(&eventParam);
40 }
41 HCI_FOREACH_EVT_CALLBACKS_END;
42 }
43
HciCmdOnInquiryCancelFailed(uint8_t status,const void * param)44 static void HciCmdOnInquiryCancelFailed(uint8_t status, const void *param)
45 {
46 HciInquiryCancelReturnParam returnParam = {
47 .status = status,
48 };
49
50 HciEventCallbacks *callbacks = NULL;
51 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
52 if (callbacks->inquiryCancelComplete != NULL) {
53 callbacks->inquiryCancelComplete(&returnParam);
54 }
55 HCI_FOREACH_EVT_CALLBACKS_END;
56 }
57
HciCmdOnPeriodicInquiryModeFailed(uint8_t status,const void * param)58 static void HciCmdOnPeriodicInquiryModeFailed(uint8_t status, const void *param)
59 {
60 HciPeriodicInquiryModeReturnParam returnParam = {
61 .status = status,
62 };
63
64 HciEventCallbacks *callbacks = NULL;
65 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
66 if (callbacks->periodicInquiryModeComplete != NULL) {
67 callbacks->periodicInquiryModeComplete(&returnParam);
68 }
69 HCI_FOREACH_EVT_CALLBACKS_END;
70 }
71
HciCmdOnExitPeriodicInquiryModeFailed(uint8_t status,const void * param)72 static void HciCmdOnExitPeriodicInquiryModeFailed(uint8_t status, const void *param)
73 {
74 HciExitPeriodicInquiryModeReturnParam returnParam = {
75 .status = status,
76 };
77
78 HciEventCallbacks *callbacks = NULL;
79 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
80 if (callbacks->exitPeriodicInquiryModeComplete != NULL) {
81 callbacks->exitPeriodicInquiryModeComplete(&returnParam);
82 }
83 HCI_FOREACH_EVT_CALLBACKS_END;
84 }
85
HciCmdOnCreateConnectionFailed(uint8_t status,const void * param)86 static void HciCmdOnCreateConnectionFailed(uint8_t status, const void *param)
87 {
88 HciConnectionCompleteEventParam returnParam = {
89 .status = status,
90 .connectionHandle = 0xffff,
91 .bdAddr = ((HciCreateConnectionParam *)param)->bdAddr,
92 .linkType = HCI_LINK_TYPE_ACL,
93 .encryptionEnabled = 0,
94 };
95
96 HciEventCallbacks *callbacks = NULL;
97 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
98 if (callbacks->connectionComplete != NULL) {
99 callbacks->connectionComplete(&returnParam);
100 }
101 HCI_FOREACH_EVT_CALLBACKS_END;
102 }
103
HciCmdOnDisconnectFailed(uint8_t status,const void * param)104 static void HciCmdOnDisconnectFailed(uint8_t status, const void *param)
105 {
106 HciDisconnectCompleteEventParam eventParam = {
107 .status = status,
108 .connectionHandle = ((HciDisconnectParam *)param)->connectionHandle,
109 .reason = ((HciDisconnectParam *)param)->reason,
110 };
111
112 HciEventCallbacks *callbacks = NULL;
113 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
114 if (callbacks->disconnectComplete != NULL) {
115 callbacks->disconnectComplete(&eventParam);
116 }
117 HCI_FOREACH_EVT_CALLBACKS_END;
118 }
119
HciCmdOnCreateConnectionCancelFailed(uint8_t status,const void * param)120 static void HciCmdOnCreateConnectionCancelFailed(uint8_t status, const void *param)
121 {
122 HciCreateConnectionCancelReturnParam returnParam = {
123 .status = status,
124 .bdAddr = ((HciCreateConnectionCancelParam *)param)->bdAddr,
125 };
126
127 HciEventCallbacks *callbacks = NULL;
128 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
129 if (callbacks->createConnectionCancelComplete != NULL) {
130 callbacks->createConnectionCancelComplete(&returnParam);
131 }
132 HCI_FOREACH_EVT_CALLBACKS_END;
133 }
134
HciCmdOnAcceptConnectionRequestFailed(uint8_t status,const void * param)135 static void HciCmdOnAcceptConnectionRequestFailed(uint8_t status, const void *param)
136 {
137 HciConnectionCompleteEventParam returnParam = {
138 .status = status,
139 .bdAddr = ((HciAcceptConnectionReqestParam *)param)->bdAddr,
140 };
141
142 HciEventCallbacks *callbacks = NULL;
143 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
144 if (callbacks->connectionComplete != NULL) {
145 callbacks->connectionComplete(&returnParam);
146 }
147 HCI_FOREACH_EVT_CALLBACKS_END;
148 }
149
HciCmdOnRejectConnectionRequestFailed(uint8_t status,const void * param)150 static void HciCmdOnRejectConnectionRequestFailed(uint8_t status, const void *param)
151 {
152 HciConnectionCompleteEventParam returnParam = {
153 .status = status,
154 .bdAddr = ((HciRejectConnectionRequestParam *)param)->bdAddr,
155 };
156
157 HciEventCallbacks *callbacks = NULL;
158 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
159 if (callbacks->connectionComplete != NULL) {
160 callbacks->connectionComplete(&returnParam);
161 }
162 HCI_FOREACH_EVT_CALLBACKS_END;
163 }
164
HciCmdOnLinkKeyRequestReplyFailed(uint8_t status,const void * param)165 static void HciCmdOnLinkKeyRequestReplyFailed(uint8_t status, const void *param)
166 {
167 HciLinkKeyRequestReplyReturnParam returnParam = {
168 .status = status,
169 .bdAddr = ((HciLinkKeyRequestReplyParam *)param)->bdAddr,
170 };
171
172 HciEventCallbacks *callbacks = NULL;
173 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
174 if (callbacks->linkKeyRequestReplyComplete != NULL) {
175 callbacks->linkKeyRequestReplyComplete(&returnParam);
176 }
177 HCI_FOREACH_EVT_CALLBACKS_END;
178 }
179
HciCmdOnLinkKeyRequestNegativeReplyFailed(uint8_t status,const void * param)180 static void HciCmdOnLinkKeyRequestNegativeReplyFailed(uint8_t status, const void *param)
181 {
182 HciLinkKeyRequestNegativeReplyReturnParam returnParam = {
183 .status = status,
184 .bdAddr = ((HciLinkKeyRequestNegativeReplyParam *)param)->bdAddr,
185 };
186
187 HciEventCallbacks *callbacks = NULL;
188 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
189 if (callbacks->linkKeyRequestNegativeReplyComplete != NULL) {
190 callbacks->linkKeyRequestNegativeReplyComplete(&returnParam);
191 }
192 HCI_FOREACH_EVT_CALLBACKS_END;
193 }
194
HciCmdOnPinCodeRequestReplyFailed(uint8_t status,const void * param)195 static void HciCmdOnPinCodeRequestReplyFailed(uint8_t status, const void *param)
196 {
197 HciPinCodeRequestReplyReturnParam returnParam = {
198 .status = status,
199 .bdAddr = ((HciPinCodeRequestReplyParam *)param)->bdAddr,
200 };
201
202 HciEventCallbacks *callbacks = NULL;
203 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
204 if (callbacks->pinCodeRequestReplyComplete != NULL) {
205 callbacks->pinCodeRequestReplyComplete(&returnParam);
206 }
207 HCI_FOREACH_EVT_CALLBACKS_END;
208 }
209
HciCmdOnPinCodeRequestNegativeReplyFailed(uint8_t status,const void * param)210 static void HciCmdOnPinCodeRequestNegativeReplyFailed(uint8_t status, const void *param)
211 {
212 HciPinCodeRequestNegativeReplyReturnParam returnParam = {
213 .status = status,
214 .bdAddr = ((HciPinCodeRequestNegativeReplyParam *)param)->bdAddr,
215 };
216
217 HciEventCallbacks *callbacks = NULL;
218 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
219 if (callbacks->pinCodeRequestNegativeReplyComplete != NULL) {
220 callbacks->pinCodeRequestNegativeReplyComplete(&returnParam);
221 }
222 HCI_FOREACH_EVT_CALLBACKS_END;
223 }
224
HciCmdOnAuthenticationRequestedFailed(uint8_t status,const void * param)225 static void HciCmdOnAuthenticationRequestedFailed(uint8_t status, const void *param)
226 {
227 HciAuthenticationCompleteEventParam eventParam = {
228 .status = status,
229 .connectionHandle = ((HciAuthenticationRequestedParam *)param)->connectionHandle,
230 };
231
232 HciEventCallbacks *callbacks = NULL;
233 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
234 if (callbacks->authenticationComplete != NULL) {
235 callbacks->authenticationComplete(&eventParam);
236 }
237 HCI_FOREACH_EVT_CALLBACKS_END;
238 }
239
HciCmdOnSetConnectionEncryptionFailed(uint8_t status,const void * param)240 static void HciCmdOnSetConnectionEncryptionFailed(uint8_t status, const void *param)
241 {
242 HciEncryptionChangeEventParam eventParam = {
243 .status = status,
244 .connectionHandle = ((HciSetConnectionEncryptionParam *)param)->connectionHandle,
245 };
246
247 HciEventCallbacks *callbacks = NULL;
248 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
249 if (callbacks->encryptionChange != NULL) {
250 callbacks->encryptionChange(&eventParam);
251 }
252 HCI_FOREACH_EVT_CALLBACKS_END;
253 }
254
HciCmdOnRemoteNameRequestFailed(uint8_t status,const void * param)255 static void HciCmdOnRemoteNameRequestFailed(uint8_t status, const void *param)
256 {
257 HciRemoteNameRequestCompleteEventParam eventParam = {
258 .status = status,
259 .bdAddr = ((HciRemoteNameRequestParam *)param)->addr,
260 };
261
262 HciEventCallbacks *callbacks = NULL;
263 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
264 if (callbacks->remoteNameRequestComplete != NULL) {
265 callbacks->remoteNameRequestComplete(&eventParam);
266 }
267 HCI_FOREACH_EVT_CALLBACKS_END;
268 }
269
HciCmdOnRemoteNameRequestCancelFailed(uint8_t status,const void * param)270 static void HciCmdOnRemoteNameRequestCancelFailed(uint8_t status, const void *param)
271 {
272 HciRemoteNameRequestCancelReturnParam returnParam = {
273 .status = status,
274 .addr = ((HciRemoteNameRequestCancelParam *)param)->addr,
275 };
276
277 HciEventCallbacks *callbacks = NULL;
278 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
279 if (callbacks->remoteNameRequestCancelComplete != NULL) {
280 callbacks->remoteNameRequestCancelComplete(&returnParam);
281 }
282 HCI_FOREACH_EVT_CALLBACKS_END;
283 }
284
HciCmdOnReadRemoteSupportedFeaturesFailed(uint8_t status,const void * param)285 static void HciCmdOnReadRemoteSupportedFeaturesFailed(uint8_t status, const void *param)
286 {
287 HciReadRemoteSupportedFeaturesCompleteEventParam eventParam = {
288 .status = status,
289 .connectionHandle = ((HciReadRemoteSupportedFeaturesParam *)param)->connectionHandle,
290 };
291
292 HciEventCallbacks *callbacks = NULL;
293 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
294 if (callbacks->readRemoteSupportedFeaturesComplete != NULL) {
295 callbacks->readRemoteSupportedFeaturesComplete(&eventParam);
296 }
297 HCI_FOREACH_EVT_CALLBACKS_END;
298 }
299
HciCmdOnReadRemoteExtendedFeaturesFailed(uint8_t status,const void * param)300 static void HciCmdOnReadRemoteExtendedFeaturesFailed(uint8_t status, const void *param)
301 {
302 HciReadRemoteExtendedFeaturesCompleteEventParam eventParam = {
303 .status = status,
304 .connectionHandle = ((HciReadRemoteExtendedFeaturesParam *)param)->connectionHandle,
305 .pageNumber = ((HciReadRemoteExtendedFeaturesParam *)param)->pageNumber,
306 };
307
308 HciEventCallbacks *callbacks = NULL;
309 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
310 if (callbacks->readRemoteExtendedFeaturesComplete != NULL) {
311 callbacks->readRemoteExtendedFeaturesComplete(&eventParam);
312 }
313 HCI_FOREACH_EVT_CALLBACKS_END;
314 }
315
HciCmdOnReadRemoteVersionInformationFailed(uint8_t status,const void * param)316 static void HciCmdOnReadRemoteVersionInformationFailed(uint8_t status, const void *param)
317 {
318 HciReadRemoteVersionInformationCompleteEventParam eventParam = {
319 .status = status,
320 .connectionHandle = ((HciReadRemoteVersionInformationParam *)param)->connectionHandle,
321 };
322
323 HciEventCallbacks *callbacks = NULL;
324 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
325 if (callbacks->readRemoteVersionInformationComplete != NULL) {
326 callbacks->readRemoteVersionInformationComplete(&eventParam);
327 }
328 HCI_FOREACH_EVT_CALLBACKS_END;
329 }
330
HciCmdOnReadLmpHandleFailed(uint8_t status,const void * param)331 static void HciCmdOnReadLmpHandleFailed(uint8_t status, const void *param)
332 {
333 HciReadLmpHandleReturnParam returnParam = {
334 .status = status,
335 .connectionHandle = ((HciReadLmpHandleReturnParam *)param)->connectionHandle,
336 };
337
338 HciEventCallbacks *callbacks = NULL;
339 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
340 if (callbacks->readLmpHandleComplete != NULL) {
341 callbacks->readLmpHandleComplete(&returnParam);
342 }
343 HCI_FOREACH_EVT_CALLBACKS_END;
344 }
345
HciCmdOnSetupSynchronousConnectionFailed(uint8_t status,const void * param)346 static void HciCmdOnSetupSynchronousConnectionFailed(uint8_t status, const void *param)
347 {
348 BtAddr addr = {0};
349 BtmGetAclAddressByHandle(((HciSetupSynchronousConnectionParam *)param)->connectionHandle, &addr);
350
351 HciSynchronousConnectionCompleteEventParam eventParam = {
352 .status = status,
353 .bdAddr = {.raw = {0}},
354 };
355 (void)memcpy_s(eventParam.bdAddr.raw, BT_ADDRESS_SIZE, addr.addr, BT_ADDRESS_SIZE);
356
357 HciEventCallbacks *callbacks = NULL;
358 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
359 if (callbacks->synchronousConnectionComplete != NULL) {
360 callbacks->synchronousConnectionComplete(&eventParam);
361 }
362 HCI_FOREACH_EVT_CALLBACKS_END;
363 }
364
HciCmdOnAcceptSynchronousConnectionRequestFailed(uint8_t status,const void * param)365 static void HciCmdOnAcceptSynchronousConnectionRequestFailed(uint8_t status, const void *param)
366 {
367 HciSynchronousConnectionCompleteEventParam returnParam = {
368 .status = status,
369 .bdAddr = ((HciAcceptSynchronousConnectionRequestParam *)param)->addr,
370 };
371
372 HciEventCallbacks *callbacks = NULL;
373 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
374 if (callbacks->synchronousConnectionComplete != NULL) {
375 callbacks->synchronousConnectionComplete(&returnParam);
376 }
377 HCI_FOREACH_EVT_CALLBACKS_END;
378 }
379
HciCmdOnRejectSynchronousConnectionRequestFailed(uint8_t status,const void * param)380 static void HciCmdOnRejectSynchronousConnectionRequestFailed(uint8_t status, const void *param)
381 {
382 HciSynchronousConnectionCompleteEventParam eventParam = {
383 .status = status,
384 .bdAddr = ((HciRejectSynchronousConnectionRequestParam *)param)->bdAddr,
385 };
386
387 HciEventCallbacks *callbacks = NULL;
388 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
389 if (callbacks->synchronousConnectionComplete != NULL) {
390 callbacks->synchronousConnectionComplete(&eventParam);
391 }
392 HCI_FOREACH_EVT_CALLBACKS_END;
393 }
394
HciCmdOnIoCapabilityRequestReplyFailed(uint8_t status,const void * param)395 static void HciCmdOnIoCapabilityRequestReplyFailed(uint8_t status, const void *param)
396 {
397 HciIOCapabilityRequestReplyReturnParam returnParam = {
398 .status = status,
399 .bdAddr = ((HciIOCapabilityRequestReplyParam *)param)->bdAddr,
400 };
401
402 HciEventCallbacks *callbacks = NULL;
403 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
404 if (callbacks->ioCapabilityRequestReplyComplete != NULL) {
405 callbacks->ioCapabilityRequestReplyComplete(&returnParam);
406 }
407 HCI_FOREACH_EVT_CALLBACKS_END;
408 }
409
HciCmdOnUserConfirmationRequestReplyFailed(uint8_t status,const void * param)410 static void HciCmdOnUserConfirmationRequestReplyFailed(uint8_t status, const void *param)
411 {
412 HciUserConfirmationRequestReplyReturnParam returnParam = {
413 .status = status,
414 .bdAddr = ((HciUserConfirmationRequestReplyParam *)param)->bdAddr,
415 };
416
417 HciEventCallbacks *callbacks = NULL;
418 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
419 if (callbacks->userConfirmationRequestReplyComplete != NULL) {
420 callbacks->userConfirmationRequestReplyComplete(&returnParam);
421 }
422 HCI_FOREACH_EVT_CALLBACKS_END;
423 }
424
HciCmdOnUserPasskeyRequestReplyFailed(uint8_t status,const void * param)425 static void HciCmdOnUserPasskeyRequestReplyFailed(uint8_t status, const void *param)
426 {
427 HciUserPasskeyRequestReplyReturnParam returnParam = {
428 .status = status,
429 .bdAddr = ((HciUserPasskeyRequestReplyParam *)param)->bdAddr,
430 };
431
432 HciEventCallbacks *callbacks = NULL;
433 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
434 if (callbacks->userPasskeyRequestReplyComplete != NULL) {
435 callbacks->userPasskeyRequestReplyComplete(&returnParam);
436 }
437 HCI_FOREACH_EVT_CALLBACKS_END;
438 }
439
HciCmdOnUserPasskeyRequestNegativeReplyFailed(uint8_t status,const void * param)440 static void HciCmdOnUserPasskeyRequestNegativeReplyFailed(uint8_t status, const void *param)
441 {
442 HciUserPasskeyRequestNegativeReplyReturnParam returnParam = {
443 .status = status,
444 .bdAddr = ((HciUserPasskeyRequestNegativeReplyParam *)param)->bdAddr,
445 };
446
447 HciEventCallbacks *callbacks = NULL;
448 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
449 if (callbacks->userPasskeyRequestNegativeReplyComplete != NULL) {
450 callbacks->userPasskeyRequestNegativeReplyComplete(&returnParam);
451 }
452 HCI_FOREACH_EVT_CALLBACKS_END;
453 }
454
HciCmdOnRemoteOobDataRequestReplyFailed(uint8_t status,const void * param)455 static void HciCmdOnRemoteOobDataRequestReplyFailed(uint8_t status, const void *param)
456 {
457 HciRemoteOobDataRequestReplyReturnParam returnParam = {
458 .status = status,
459 .bdAddr = ((HciRemoteOobDataRequestReplyParam *)param)->bdAddr,
460 };
461
462 HciEventCallbacks *callbacks = NULL;
463 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
464 if (callbacks->remoteOOBDataRequestReplyComplete != NULL) {
465 callbacks->remoteOOBDataRequestReplyComplete(&returnParam);
466 }
467 HCI_FOREACH_EVT_CALLBACKS_END;
468 }
469
HciCmdOnRemoteOobDataRequestNegativeReplyFailed(uint8_t status,const void * param)470 static void HciCmdOnRemoteOobDataRequestNegativeReplyFailed(uint8_t status, const void *param)
471 {
472 HciRemoteOobDataRequestNegativeReplyReturnParam returnParam = {
473 .status = status,
474 .bdAddr = ((HciRemoteOobDataRequestNegativeReplyParam *)param)->bdAddr,
475 };
476
477 HciEventCallbacks *callbacks = NULL;
478 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
479 if (callbacks->remoteOOBDataRequestNegativeReplyComplete != NULL) {
480 callbacks->remoteOOBDataRequestNegativeReplyComplete(&returnParam);
481 }
482 HCI_FOREACH_EVT_CALLBACKS_END;
483 }
484
HciCmdOnIoCapabilityRequestNegativeReplyFailed(uint8_t status,const void * param)485 static void HciCmdOnIoCapabilityRequestNegativeReplyFailed(uint8_t status, const void *param)
486 {
487 HciIoCapabilityRequestNegativeReplyReturnParam returnParam = {
488 .status = status,
489 .bdAddr = ((HciIoCapabilityRequestNegativeReplyParam *)param)->bdAddr,
490 };
491
492 HciEventCallbacks *callbacks = NULL;
493 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
494 if (callbacks->iOCapabilityRequestNegativeReplyComplete != NULL) {
495 callbacks->iOCapabilityRequestNegativeReplyComplete(&returnParam);
496 }
497 HCI_FOREACH_EVT_CALLBACKS_END;
498 }
499
HciCmdOnLogicalLinkCancelFailed(uint8_t status,const void * param)500 static void HciCmdOnLogicalLinkCancelFailed(uint8_t status, const void *param)
501 {
502 HciLogicalLinkCancelReturnParam returnParam = {
503 .status = status,
504 };
505
506 HciEventCallbacks *callbacks = NULL;
507 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
508 if (callbacks->logicalLinkCancelComplete != NULL) {
509 callbacks->logicalLinkCancelComplete(&returnParam);
510 }
511 HCI_FOREACH_EVT_CALLBACKS_END;
512 }
513
HciCmdOnUserConfirmationRequestNegativeReplyFailed(uint8_t status,const void * param)514 static void HciCmdOnUserConfirmationRequestNegativeReplyFailed(uint8_t status, const void *param)
515 {
516 HciUserConfirmationRequestNegativeReplyReturnParam returnParam = {
517 .status = status,
518 .bdAddr = ((HciUserConfirmationRequestNegativeReplyParam *)param)->bdAddr,
519 };
520
521 HciEventCallbacks *callbacks = NULL;
522 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
523 if (callbacks->userConfirmationRequestNegativeReplyComplete != NULL) {
524 callbacks->userConfirmationRequestNegativeReplyComplete(&returnParam);
525 }
526 HCI_FOREACH_EVT_CALLBACKS_END;
527 }
528
HciCmdOnEnhancedSetupSynchronousConnectionFailed(uint8_t status,const void * param)529 static void HciCmdOnEnhancedSetupSynchronousConnectionFailed(uint8_t status, const void *param)
530 {
531 BtAddr addr = {0};
532 BtmGetAclAddressByHandle(((HciEnhancedSetupSynchronousConnectionParam *)param)->connectionHandle, &addr);
533
534 HciSynchronousConnectionCompleteEventParam eventParam = {
535 .status = status,
536 .bdAddr = {.raw = {0}},
537 };
538 (void)memcpy_s(eventParam.bdAddr.raw, BT_ADDRESS_SIZE, addr.addr, BT_ADDRESS_SIZE);
539
540 HciEventCallbacks *callbacks = NULL;
541 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
542 if (callbacks->synchronousConnectionComplete != NULL) {
543 callbacks->synchronousConnectionComplete(&eventParam);
544 }
545 HCI_FOREACH_EVT_CALLBACKS_END;
546 }
547
HciCmdOnEnhancedAcceptSynchronousConnectionRequestFailed(uint8_t status,const void * param)548 static void HciCmdOnEnhancedAcceptSynchronousConnectionRequestFailed(uint8_t status, const void *param)
549 {
550 HciSynchronousConnectionCompleteEventParam eventParam = {
551 .status = status,
552 .bdAddr = ((HciEnhancedAcceptSynchronousConnectionRequestParam *)param)->bdAddr,
553 };
554
555 HciEventCallbacks *callbacks = NULL;
556 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
557 if (callbacks->synchronousConnectionComplete != NULL) {
558 callbacks->synchronousConnectionComplete(&eventParam);
559 }
560 HCI_FOREACH_EVT_CALLBACKS_END;
561 }
562
HciCmdOnRemoteOobExtendedDataRequestReplyFailed(uint8_t status,const void * param)563 static void HciCmdOnRemoteOobExtendedDataRequestReplyFailed(uint8_t status, const void *param)
564 {
565 HciRemoteOobExtendedDataRequestReplyReturnParam returnParam = {
566 .status = status,
567 .bdAddr = ((HciRemoteOobExtendedDataRequestReplyParam *)param)->bdAddr,
568 };
569
570 HciEventCallbacks *callbacks = NULL;
571 HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
572 if (callbacks->remoteOOBExtendedDataRequestReplyComplete != NULL) {
573 callbacks->remoteOOBExtendedDataRequestReplyComplete(&returnParam);
574 }
575 HCI_FOREACH_EVT_CALLBACKS_END;
576 }
577
578 static HciCmdOnFailedFunc g_funcMap[] = {
579 NULL, // 0x0000
580 HciCmdOnInquiryFailed, // 0x0001
581 HciCmdOnInquiryCancelFailed, // 0x0002
582 HciCmdOnPeriodicInquiryModeFailed, // 0x0003
583 HciCmdOnExitPeriodicInquiryModeFailed, // 0x0004
584 HciCmdOnCreateConnectionFailed, // 0x0005
585 HciCmdOnDisconnectFailed, // 0x0006
586 NULL, // 0x0007
587 HciCmdOnCreateConnectionCancelFailed, // 0x0008
588 HciCmdOnAcceptConnectionRequestFailed, // 0x0009
589 HciCmdOnRejectConnectionRequestFailed, // 0x000A
590 HciCmdOnLinkKeyRequestReplyFailed, // 0x000B
591 HciCmdOnLinkKeyRequestNegativeReplyFailed, // 0x000C
592 HciCmdOnPinCodeRequestReplyFailed, // 0x000D
593 HciCmdOnPinCodeRequestNegativeReplyFailed, // 0x000E
594 NULL, // 0x000F
595 NULL, // 0x0010
596 HciCmdOnAuthenticationRequestedFailed, // 0x0011
597 NULL, // 0x0012
598 HciCmdOnSetConnectionEncryptionFailed, // 0x0013
599 NULL, // 0x0014
600 NULL, // 0x0015
601 NULL, // 0x0016
602 NULL, // 0x0017
603 NULL, // 0x0018
604 HciCmdOnRemoteNameRequestFailed, // 0x0019
605 HciCmdOnRemoteNameRequestCancelFailed, // 0x001A
606 HciCmdOnReadRemoteSupportedFeaturesFailed, // 0x001B
607 HciCmdOnReadRemoteExtendedFeaturesFailed, // 0x001C
608 HciCmdOnReadRemoteVersionInformationFailed, // 0x001D
609 NULL, // 0x001E
610 NULL, // 0x001F
611 HciCmdOnReadLmpHandleFailed, // 0x0020
612 NULL, // 0x0021
613 NULL, // 0x0022
614 NULL, // 0x0023
615 NULL, // 0x0024
616 NULL, // 0x0025
617 NULL, // 0x0026
618 NULL, // 0x0027
619 HciCmdOnSetupSynchronousConnectionFailed, // 0x0028
620 HciCmdOnAcceptSynchronousConnectionRequestFailed, // 0x0029
621 HciCmdOnRejectSynchronousConnectionRequestFailed, // 0x002A
622 HciCmdOnIoCapabilityRequestReplyFailed, // 0x002B
623 HciCmdOnUserConfirmationRequestReplyFailed, // 0x002C
624 HciCmdOnUserConfirmationRequestNegativeReplyFailed, // 0x002D
625 HciCmdOnUserPasskeyRequestReplyFailed, // 0x002E
626 HciCmdOnUserPasskeyRequestNegativeReplyFailed, // 0x002F
627 HciCmdOnRemoteOobDataRequestReplyFailed, // 0x0030
628 NULL, // 0x0031
629 NULL, // 0x0032
630 HciCmdOnRemoteOobDataRequestNegativeReplyFailed, // 0x0033
631 HciCmdOnIoCapabilityRequestNegativeReplyFailed, // 0x0034
632 NULL, // 0x0035
633 NULL, // 0x0036
634 NULL, // 0x0037
635 NULL, // 0x0038
636 NULL, // 0x0039
637 NULL, // 0x003A
638 HciCmdOnLogicalLinkCancelFailed, // 0x003B
639 NULL, // 0x003C
640 HciCmdOnEnhancedSetupSynchronousConnectionFailed, // 0x003D
641 HciCmdOnEnhancedAcceptSynchronousConnectionRequestFailed, // 0x003E
642 NULL, // 0x003F
643 NULL, // 0x0040
644 NULL, // 0x0041
645 NULL, // 0x0042
646 NULL, // 0x0043
647 NULL, // 0x0044
648 HciCmdOnRemoteOobExtendedDataRequestReplyFailed, // 0x0045
649 };
650
651 #define LINKCONTROL_OCF_MAX 0x0045
652
HciOnLinkControlCmdFailed(uint16_t opCode,uint8_t status,const void * param)653 void HciOnLinkControlCmdFailed(uint16_t opCode, uint8_t status, const void *param)
654 {
655 uint16_t ocf = GET_OCF(opCode);
656 if (ocf > LINKCONTROL_OCF_MAX) {
657 return;
658 }
659
660 HciCmdOnFailedFunc func = g_funcMap[ocf];
661 if (func != NULL) {
662 func(status, param);
663 }
664 }