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_link_ctrl_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
HciEventOnInquiryCancelComplete(const void * param,uint8_t length)31 static void HciEventOnInquiryCancelComplete(const void *param, uint8_t length)
32 {
33 HciInquiryCancelReturnParam 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->inquiryCancelComplete != NULL) {
40 callbacks->inquiryCancelComplete(&returnParam);
41 }
42 HCI_FOREACH_EVT_CALLBACKS_END;
43 }
44
HciEventOnCreateConnectionCancelComplete(const void * param,uint8_t length)45 static void HciEventOnCreateConnectionCancelComplete(const void *param, uint8_t length)
46 {
47 HciCreateConnectionCancelReturnParam 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->createConnectionCancelComplete != NULL) {
54 callbacks->createConnectionCancelComplete(&returnParam);
55 }
56 HCI_FOREACH_EVT_CALLBACKS_END;
57 }
58
HciEventOnLinkKeyRequestReplyComplete(const void * param,uint8_t length)59 static void HciEventOnLinkKeyRequestReplyComplete(const void *param, uint8_t length)
60 {
61 HciLinkKeyRequestReplyReturnParam 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->linkKeyRequestReplyComplete != NULL) {
68 callbacks->linkKeyRequestReplyComplete(&returnParam);
69 }
70 HCI_FOREACH_EVT_CALLBACKS_END;
71 }
72
HciEventOnLinkKeyRequestNegativeReplyComplete(const void * param,uint8_t length)73 static void HciEventOnLinkKeyRequestNegativeReplyComplete(const void *param, uint8_t length)
74 {
75 HciLinkKeyRequestNegativeReplyReturnParam 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->linkKeyRequestNegativeReplyComplete != NULL) {
82 callbacks->linkKeyRequestNegativeReplyComplete(&returnParam);
83 }
84 HCI_FOREACH_EVT_CALLBACKS_END;
85 }
86
HciEventOnPINCodeRequestReplyCompete(const void * param,uint8_t length)87 static void HciEventOnPINCodeRequestReplyCompete(const void *param, uint8_t length)
88 {
89 HciPinCodeRequestReplyReturnParam 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->pinCodeRequestReplyComplete != NULL) {
96 callbacks->pinCodeRequestReplyComplete(&returnParam);
97 }
98 HCI_FOREACH_EVT_CALLBACKS_END;
99 }
100
HciEventOnPINCodeRequestNegativeReplyComplete(const void * param,uint8_t length)101 static void HciEventOnPINCodeRequestNegativeReplyComplete(const void *param, uint8_t length)
102 {
103 HciPinCodeRequestNegativeReplyReturnParam 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->pinCodeRequestNegativeReplyComplete != NULL) {
110 callbacks->pinCodeRequestNegativeReplyComplete(&returnParam);
111 }
112 HCI_FOREACH_EVT_CALLBACKS_END;
113 }
114
HciEventOnRemoteNameRequestCancelComplete(const void * param,uint8_t length)115 static void HciEventOnRemoteNameRequestCancelComplete(const void *param, uint8_t length)
116 {
117 HciRemoteNameRequestCancelReturnParam 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->remoteNameRequestCancelComplete != NULL) {
124 callbacks->remoteNameRequestCancelComplete(&returnParam);
125 }
126 HCI_FOREACH_EVT_CALLBACKS_END;
127 }
128
HciEventOnIOCapabilityRequestReplyComplete(const void * param,uint8_t length)129 static void HciEventOnIOCapabilityRequestReplyComplete(const void *param, uint8_t length)
130 {
131 HciIOCapabilityRequestReplyReturnParam 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->ioCapabilityRequestReplyComplete != NULL) {
138 callbacks->ioCapabilityRequestReplyComplete(&returnParam);
139 }
140 HCI_FOREACH_EVT_CALLBACKS_END;
141 }
142
HciEventOnUserConfirmationRequestReplyComplete(const void * param,uint8_t length)143 static void HciEventOnUserConfirmationRequestReplyComplete(const void *param, uint8_t length)
144 {
145 HciUserConfirmationRequestReplyReturnParam 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->userConfirmationRequestReplyComplete != NULL) {
152 callbacks->userConfirmationRequestReplyComplete(&returnParam);
153 }
154 HCI_FOREACH_EVT_CALLBACKS_END;
155 }
156
HciEventOnUserConfirmationRequestNegativeReplyComplete(const void * param,uint8_t length)157 static void HciEventOnUserConfirmationRequestNegativeReplyComplete(const void *param, uint8_t length)
158 {
159 HciUserConfirmationRequestNegativeReplyReturnParam 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->userConfirmationRequestNegativeReplyComplete != NULL) {
166 callbacks->userConfirmationRequestNegativeReplyComplete(&returnParam);
167 }
168 HCI_FOREACH_EVT_CALLBACKS_END;
169 }
170
HciEventOnUserPasskeyRequestReplyComplete(const void * param,uint8_t length)171 static void HciEventOnUserPasskeyRequestReplyComplete(const void *param, uint8_t length)
172 {
173 HciUserPasskeyRequestReplyReturnParam 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->userPasskeyRequestReplyComplete != NULL) {
180 callbacks->userPasskeyRequestReplyComplete(&returnParam);
181 }
182 HCI_FOREACH_EVT_CALLBACKS_END;
183 }
184
HciEventOnUserPasskeyRequestNegativeReplyComplete(const void * param,uint8_t length)185 static void HciEventOnUserPasskeyRequestNegativeReplyComplete(const void *param, uint8_t length)
186 {
187 HciUserPasskeyRequestNegativeReplyReturnParam 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->userPasskeyRequestNegativeReplyComplete != NULL) {
194 callbacks->userPasskeyRequestNegativeReplyComplete(&returnParam);
195 }
196 HCI_FOREACH_EVT_CALLBACKS_END;
197 }
198
HciEventOnRemoteOOBDataRequestReplyComplete(const void * param,uint8_t length)199 static void HciEventOnRemoteOOBDataRequestReplyComplete(const void *param, uint8_t length)
200 {
201 HciRemoteOobDataRequestReplyReturnParam 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->remoteOOBDataRequestReplyComplete != NULL) {
208 callbacks->remoteOOBDataRequestReplyComplete(&returnParam);
209 }
210 HCI_FOREACH_EVT_CALLBACKS_END;
211 }
212
HciEventOnRemoteOOBDataRequestNegativeReplyComplete(const void * param,uint8_t length)213 static void HciEventOnRemoteOOBDataRequestNegativeReplyComplete(const void *param, uint8_t length)
214 {
215 HciRemoteOobDataRequestNegativeReplyReturnParam 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->remoteOOBDataRequestNegativeReplyComplete != NULL) {
222 callbacks->remoteOOBDataRequestNegativeReplyComplete(&returnParam);
223 }
224 HCI_FOREACH_EVT_CALLBACKS_END;
225 }
226
HciEventOnIOCapabilityRequestNegativeReplyComplete(const void * param,uint8_t length)227 static void HciEventOnIOCapabilityRequestNegativeReplyComplete(const void *param, uint8_t length)
228 {
229 HciIoCapabilityRequestNegativeReplyReturnParam 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->iOCapabilityRequestNegativeReplyComplete != NULL) {
236 callbacks->iOCapabilityRequestNegativeReplyComplete(&returnParam);
237 }
238 HCI_FOREACH_EVT_CALLBACKS_END;
239 }
240
HciEventOnRemoteOOBExtendedDataRequestReplyComplete(const void * param,uint8_t length)241 static void HciEventOnRemoteOOBExtendedDataRequestReplyComplete(const void *param, uint8_t length)
242 {
243 HciRemoteOobExtendedDataRequestReplyReturnParam 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->remoteOOBExtendedDataRequestReplyComplete != NULL) {
250 callbacks->remoteOOBExtendedDataRequestReplyComplete(&returnParam);
251 }
252 HCI_FOREACH_EVT_CALLBACKS_END;
253 }
254
HciEventOnExitPeriodicInquiryModeComplete(const void * param,uint8_t length)255 static void HciEventOnExitPeriodicInquiryModeComplete(const void *param, uint8_t length)
256 {
257 HciExitPeriodicInquiryModeReturnParam 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->exitPeriodicInquiryModeComplete != NULL) {
264 callbacks->exitPeriodicInquiryModeComplete(&returnParam);
265 }
266 HCI_FOREACH_EVT_CALLBACKS_END;
267 }
268
HciEventOnPeriodicInquiryModeComplete(const void * param,uint8_t length)269 static void HciEventOnPeriodicInquiryModeComplete(const void *param, uint8_t length)
270 {
271 HciPeriodicInquiryModeReturnParam 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->periodicInquiryModeComplete != NULL) {
278 callbacks->periodicInquiryModeComplete(&returnParam);
279 }
280 HCI_FOREACH_EVT_CALLBACKS_END;
281 }
282
HciEventOnReadLMPHandleComplete(const void * param,uint8_t length)283 static void HciEventOnReadLMPHandleComplete(const void *param, uint8_t length)
284 {
285 HciReadLmpHandleReturnParam 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->readLmpHandleComplete != NULL) {
292 callbacks->readLmpHandleComplete(&returnParam);
293 }
294 HCI_FOREACH_EVT_CALLBACKS_END;
295 }
296
HciEventOnLogicalLinkCancelComplete(const void * param,uint8_t length)297 static void HciEventOnLogicalLinkCancelComplete(const void *param, uint8_t length)
298 {
299 HciLogicalLinkCancelReturnParam 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->logicalLinkCancelComplete != NULL) {
306 callbacks->logicalLinkCancelComplete(&returnParam);
307 }
308 HCI_FOREACH_EVT_CALLBACKS_END;
309 }
310
HciEventOnTruncatedPageCancelComplete(const void * param,uint8_t length)311 static void HciEventOnTruncatedPageCancelComplete(const void *param, uint8_t length)
312 {
313 HciTruncatedPageCancelReturnParam 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->truncatedPageCancelComplete != NULL) {
320 callbacks->truncatedPageCancelComplete(&returnParam);
321 }
322 HCI_FOREACH_EVT_CALLBACKS_END;
323 }
324
HciEventOnSetConnectionlessSlaveBroadcastComplete(const void * param,uint8_t length)325 static void HciEventOnSetConnectionlessSlaveBroadcastComplete(const void *param, uint8_t length)
326 {
327 HciSetConnectionlessSlaveBroadcastReturnParam 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->setConnectionlessSlaveBroadcastComplete != NULL) {
334 callbacks->setConnectionlessSlaveBroadcastComplete(&returnParam);
335 }
336 HCI_FOREACH_EVT_CALLBACKS_END;
337 }
338
HciEventOnSetConnectionlessSlaveBroadcastReceiveComplete(const void * param,uint8_t length)339 static void HciEventOnSetConnectionlessSlaveBroadcastReceiveComplete(const void *param, uint8_t length)
340 {
341 HciSetConnectionlessSlaveBroadcastReceiveReturnParam 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->setConnectionlessSlaveBroadcastReceiveComplete != NULL) {
348 callbacks->setConnectionlessSlaveBroadcastReceiveComplete(&returnParam);
349 }
350 HCI_FOREACH_EVT_CALLBACKS_END;
351 }
352
353 static HciEventCommandCompleteFunc g_linkControlCommandCompleteMap[] = {
354 NULL, // 0x0000
355 NULL, // 0x0001
356 HciEventOnInquiryCancelComplete, // 0x0002
357 HciEventOnPeriodicInquiryModeComplete, // 0x0003
358 HciEventOnExitPeriodicInquiryModeComplete, // 0x0004
359 NULL, // 0x0005
360 NULL, // 0x0006
361 NULL, // 0x0007
362 HciEventOnCreateConnectionCancelComplete, // 0x0008
363 NULL, // 0x0009
364 NULL, // 0x000A
365 HciEventOnLinkKeyRequestReplyComplete, // 0x000B
366 HciEventOnLinkKeyRequestNegativeReplyComplete, // 0x000C
367 HciEventOnPINCodeRequestReplyCompete, // 0x000D
368 HciEventOnPINCodeRequestNegativeReplyComplete, // 0x000E
369 NULL, // 0x000F
370 NULL, // 0x0010
371 NULL, // 0x0011
372 NULL, // 0x0012
373 NULL, // 0x0013
374 NULL, // 0x0014
375 NULL, // 0x0015
376 NULL, // 0x0016
377 NULL, // 0x0017
378 NULL, // 0x0018
379 NULL, // 0x0019
380 HciEventOnRemoteNameRequestCancelComplete, // 0x001A
381 NULL, // 0x001B
382 NULL, // 0x001C
383 NULL, // 0x001D
384 NULL, // 0x001E
385 NULL, // 0x001F
386 HciEventOnReadLMPHandleComplete, // 0x0020
387 NULL, // 0x0021
388 NULL, // 0x0022
389 NULL, // 0x0023
390 NULL, // 0x0024
391 NULL, // 0x0025
392 NULL, // 0x0026
393 NULL, // 0x0027
394 NULL, // 0x0028
395 NULL, // 0x0029
396 NULL, // 0x002A
397 HciEventOnIOCapabilityRequestReplyComplete, // 0x002B
398 HciEventOnUserConfirmationRequestReplyComplete, // 0x002C
399 HciEventOnUserConfirmationRequestNegativeReplyComplete, // 0x002D
400 HciEventOnUserPasskeyRequestReplyComplete, // 0x002E
401 HciEventOnUserPasskeyRequestNegativeReplyComplete, // 0x002F
402 HciEventOnRemoteOOBDataRequestReplyComplete, // 0x0030
403 NULL, // 0x0031
404 NULL, // 0x0032
405 HciEventOnRemoteOOBDataRequestNegativeReplyComplete, // 0x0033
406 HciEventOnIOCapabilityRequestNegativeReplyComplete, // 0x0034
407 NULL, // 0x0035
408 NULL, // 0x0036
409 NULL, // 0x0037
410 NULL, // 0x0038
411 NULL, // 0x0039
412 NULL, // 0x003A
413 HciEventOnLogicalLinkCancelComplete, // 0x003B
414 NULL, // 0x003C
415 NULL, // 0x003D
416 NULL, // 0x003E
417 NULL, // 0x003F
418 HciEventOnTruncatedPageCancelComplete, // 0x0040
419 HciEventOnSetConnectionlessSlaveBroadcastComplete, // 0x0041
420 HciEventOnSetConnectionlessSlaveBroadcastReceiveComplete, // 0x0042
421 NULL, // 0x0043
422 NULL, // 0x0044
423 HciEventOnRemoteOOBExtendedDataRequestReplyComplete, // 0x0045
424 };
425
426 #define LINKCONTROL_OCF_MAX 0x0045
427
HciEventOnLinkControlCommandComplete(uint16_t opCode,const void * param,uint8_t length)428 void HciEventOnLinkControlCommandComplete(uint16_t opCode, const void *param, uint8_t length)
429 {
430 uint16_t ogf = GET_OCF(opCode);
431 if (ogf > LINKCONTROL_OCF_MAX) {
432 return;
433 }
434
435 HciEventCommandCompleteFunc func = g_linkControlCommandCompleteMap[ogf];
436 if (func != NULL) {
437 func(param, length);
438 }
439 }