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 "gap_internal.h"
17 #include "gap_task_internal.h"
18
19 #include <securec.h>
20
21 #include "allocator.h"
22 #include "log.h"
23 #include "thread.h"
24
25 #include "btm/btm_thread.h"
26
GapProcessHciEventInTask(TaskFunc run,const void * ctx,uint32_t ctxLen,TaskFunc free)27 static int GapProcessHciEventInTask(TaskFunc run, const void *ctx, uint32_t ctxLen, TaskFunc free)
28 {
29 void *hciParam = NULL;
30 if (ctx != NULL && ctxLen != 0) {
31 hciParam = MEM_MALLOC.alloc(ctxLen);
32 if (hciParam == NULL) {
33 return BT_NO_MEMORY;
34 }
35 (void)memcpy_s(hciParam, ctxLen, ctx, ctxLen);
36 }
37
38 return GapRunTaskUnBlockProcess(run, hciParam, free);
39 }
40
41 #ifdef GAP_BREDR_SUPPORT
42
GapRecvInquiryCancelComplete(const HciInquiryCancelReturnParam * param)43 static void GapRecvInquiryCancelComplete(const HciInquiryCancelReturnParam *param)
44 {
45 HILOGI("status: 0x%{public}02x", param->status);
46 int ret = GapProcessHciEventInTask((TaskFunc)GapInquiryCancelComplete, param, sizeof(*param), NULL);
47 if (ret != BT_SUCCESS) {
48 HILOGE("Task error: %{public}d.", ret);
49 }
50 }
51
GapRecvLinkKeyRequestReplyComplete(const HciLinkKeyRequestReplyReturnParam * param)52 static void GapRecvLinkKeyRequestReplyComplete(const HciLinkKeyRequestReplyReturnParam *param)
53 {
54 HILOGI("status: 0x%{public}02x", param->status);
55 int ret = GapProcessHciEventInTask((TaskFunc)GapLinkKeyRequestReplyComplete, param, sizeof(*param), NULL);
56 if (ret != BT_SUCCESS) {
57 HILOGE("Task error: %{public}d.", ret);
58 }
59 }
60
GapRecvLinkKeyRequestNegativeReplyComplete(const HciLinkKeyRequestNegativeReplyReturnParam * param)61 static void GapRecvLinkKeyRequestNegativeReplyComplete(const HciLinkKeyRequestNegativeReplyReturnParam *param)
62 {
63 HILOGI("status: 0x%{public}02x", param->status);
64 int ret = GapProcessHciEventInTask((TaskFunc)GapLinkKeyRequestNegativeReplyComplete, param, sizeof(*param), NULL);
65 if (ret != BT_SUCCESS) {
66 HILOGE("Task error: %{public}d.", ret);
67 }
68 }
69
GapRecvPINCodeRequestReplyComplete(const HciPinCodeRequestReplyReturnParam * param)70 static void GapRecvPINCodeRequestReplyComplete(const HciPinCodeRequestReplyReturnParam *param)
71 {
72 HILOGI("status: 0x%{public}02x", param->status);
73 int ret = GapProcessHciEventInTask((TaskFunc)GapPINCodeRequestReplyComplete, param, sizeof(*param), NULL);
74 if (ret != BT_SUCCESS) {
75 HILOGE("Task error: %{public}d.", ret);
76 }
77 }
78
GapRecvPINCodeRequestNegativeReplyComplete(const HciPinCodeRequestNegativeReplyReturnParam * param)79 static void GapRecvPINCodeRequestNegativeReplyComplete(const HciPinCodeRequestNegativeReplyReturnParam *param)
80 {
81 HILOGI("status: 0x%{public}02x", param->status);
82 int ret = GapProcessHciEventInTask((TaskFunc)GapPINCodeRequestNegativeReplyComplete, param, sizeof(*param), NULL);
83 if (ret != BT_SUCCESS) {
84 HILOGE("Task error: %{public}d.", ret);
85 }
86 }
87
GapRecvGetRemoteNameCancelComplete(const HciRemoteNameRequestCancelReturnParam * param)88 static void GapRecvGetRemoteNameCancelComplete(const HciRemoteNameRequestCancelReturnParam *param)
89 {
90 HILOGI("status: 0x%{public}02x", param->status);
91 int ret = GapProcessHciEventInTask((TaskFunc)GapGetRemoteNameCancelComplete, param, sizeof(*param), NULL);
92 if (ret != BT_SUCCESS) {
93 HILOGE("Task error: %{public}d.", ret);
94 }
95 }
96
GapRecvIOCapabilityRequestReplyComplete(const HciIOCapabilityRequestReplyReturnParam * param)97 static void GapRecvIOCapabilityRequestReplyComplete(const HciIOCapabilityRequestReplyReturnParam *param)
98 {
99 HILOGI("status: 0x%{public}02x", param->status);
100 int ret = GapProcessHciEventInTask((TaskFunc)GapIOCapabilityRequestReplyComplete, param, sizeof(*param), NULL);
101 if (ret != BT_SUCCESS) {
102 HILOGE("Task error: %{public}d.", ret);
103 }
104 }
105
GapRecvUserConfirmationRequestReplyComplete(const HciUserConfirmationRequestReplyReturnParam * param)106 static void GapRecvUserConfirmationRequestReplyComplete(const HciUserConfirmationRequestReplyReturnParam *param)
107 {
108 HILOGI("status: 0x%{public}02x", param->status);
109 int ret = GapProcessHciEventInTask((TaskFunc)GapUserConfirmationRequestReplyComplete, param, sizeof(*param), NULL);
110 if (ret != BT_SUCCESS) {
111 HILOGE("Task error: %{public}d.", ret);
112 }
113 }
114
GapRecvUserConfirmationRequestNegativeReplyComplete(const HciUserConfirmationRequestNegativeReplyReturnParam * param)115 static void GapRecvUserConfirmationRequestNegativeReplyComplete(
116 const HciUserConfirmationRequestNegativeReplyReturnParam *param)
117 {
118 HILOGI("status: 0x%{public}02x", param->status);
119 int ret = GapProcessHciEventInTask(
120 (TaskFunc)GapUserConfirmationRequestNegativeReplyComplete, param, sizeof(*param), NULL);
121 if (ret != BT_SUCCESS) {
122 HILOGE("Task error: %{public}d.", ret);
123 }
124 }
125
GapRecvUserPasskeyRequestReplyComplete(const HciUserPasskeyRequestReplyReturnParam * param)126 static void GapRecvUserPasskeyRequestReplyComplete(const HciUserPasskeyRequestReplyReturnParam *param)
127 {
128 HILOGI("status: 0x%{public}02x", param->status);
129 int ret = GapProcessHciEventInTask((TaskFunc)GapUserPasskeyRequestReplyComplete, param, sizeof(*param), NULL);
130 if (ret != BT_SUCCESS) {
131 HILOGE("Task error: %{public}d.", ret);
132 }
133 }
134
GapRecvUserPasskeyRequestNegativeReplyComplete(const HciUserPasskeyRequestNegativeReplyReturnParam * param)135 static void GapRecvUserPasskeyRequestNegativeReplyComplete(const HciUserPasskeyRequestNegativeReplyReturnParam *param)
136 {
137 HILOGI("status: 0x%{public}02x", param->status);
138 int ret =
139 GapProcessHciEventInTask((TaskFunc)GapUserPasskeyRequestNegativeReplyComplete, param, sizeof(*param), NULL);
140 if (ret != BT_SUCCESS) {
141 HILOGE("Task error: %{public}d.", ret);
142 }
143 }
144
GapRecvRemoteOOBDataRequestReplyComplete(const HciRemoteOobDataRequestReplyReturnParam * param)145 static void GapRecvRemoteOOBDataRequestReplyComplete(const HciRemoteOobDataRequestReplyReturnParam *param)
146 {
147 HILOGI("status: 0x%{public}02x", param->status);
148 int ret = GapProcessHciEventInTask((TaskFunc)GapRemoteOOBDataRequestReplyComplete, param, sizeof(*param), NULL);
149 if (ret != BT_SUCCESS) {
150 HILOGE("Task error: %{public}d.", ret);
151 }
152 }
153
GapRecvRemoteOOBDataRequestNegativeReplyComplete(const HciRemoteOobDataRequestNegativeReplyReturnParam * param)154 static void GapRecvRemoteOOBDataRequestNegativeReplyComplete(
155 const HciRemoteOobDataRequestNegativeReplyReturnParam *param)
156 {
157 HILOGI("status: 0x%{public}02x", param->status);
158 int ret =
159 GapProcessHciEventInTask((TaskFunc)GapRemoteOOBDataRequestNegativeReplyComplete, param, sizeof(*param), NULL);
160 if (ret != BT_SUCCESS) {
161 HILOGE("Task error: %{public}d.", ret);
162 }
163 }
164
GapRecvIOCapabilityRequestNegativeReplyComplete(const HciIoCapabilityRequestNegativeReplyReturnParam * param)165 static void GapRecvIOCapabilityRequestNegativeReplyComplete(const HciIoCapabilityRequestNegativeReplyReturnParam *param)
166 {
167 HILOGI("status: 0x%{public}02x", param->status);
168 int ret =
169 GapProcessHciEventInTask((TaskFunc)GapIOCapabilityRequestNegativeReplyComplete, param, sizeof(*param), NULL);
170 if (ret != BT_SUCCESS) {
171 HILOGE("Task error: %{public}d.", ret);
172 }
173 }
174
GapRecvRemoteOOBExtendedDataRequestReplyComplete(const HciRemoteOobExtendedDataRequestReplyReturnParam * param)175 static void GapRecvRemoteOOBExtendedDataRequestReplyComplete(
176 const HciRemoteOobExtendedDataRequestReplyReturnParam *param)
177 {
178 HILOGI("status: 0x%{public}02x", param->status);
179 int ret =
180 GapProcessHciEventInTask((TaskFunc)GapRemoteOOBExtendedDataRequestReplyComplete, param, sizeof(*param), NULL);
181 if (ret != BT_SUCCESS) {
182 HILOGE("Task error: %{public}d.", ret);
183 }
184 }
185
GapRecvWriteScanEnableComplete(const HciWriteScanEnableReturnParam * param)186 static void GapRecvWriteScanEnableComplete(const HciWriteScanEnableReturnParam *param)
187 {
188 HILOGI("status: 0x%{public}02x", param->status);
189 int ret = GapProcessHciEventInTask((TaskFunc)GapWriteScanEnableComplete, param, sizeof(*param), NULL);
190 if (ret != BT_SUCCESS) {
191 HILOGE("Task error: %{public}d.", ret);
192 }
193 }
194
GapRecvWritePageScanActivityComplete(const HciWritePageScanActivityReturnParam * param)195 static void GapRecvWritePageScanActivityComplete(const HciWritePageScanActivityReturnParam *param)
196 {
197 HILOGI("status: 0x%{public}02x", param->status);
198 int ret = GapProcessHciEventInTask((TaskFunc)GapWritePageScanActivityComplete, param, sizeof(*param), NULL);
199 if (ret != BT_SUCCESS) {
200 HILOGE("Task error: %{public}d.", ret);
201 }
202 }
203
GapRecvWriteInquiryScanActivityComplete(const HciWriteInquiryScanActivityReturnParam * param)204 static void GapRecvWriteInquiryScanActivityComplete(const HciWriteInquiryScanActivityReturnParam *param)
205 {
206 HILOGI("status: 0x%{public}02x", param->status);
207 int ret = GapProcessHciEventInTask((TaskFunc)GapWriteInquiryScanActivityComplete, param, sizeof(*param), NULL);
208 if (ret != BT_SUCCESS) {
209 HILOGE("Task error: %{public}d.", ret);
210 }
211 }
212
GapRecvWriteClassOfDeviceComplete(const HciWriteClassofDeviceReturnParam * param)213 static void GapRecvWriteClassOfDeviceComplete(const HciWriteClassofDeviceReturnParam *param)
214 {
215 HILOGI("status: 0x%{public}02x", param->status);
216 int ret = GapProcessHciEventInTask((TaskFunc)GapWriteClassOfDeviceComplete, param, sizeof(*param), NULL);
217 if (ret != BT_SUCCESS) {
218 HILOGE("Task error: %{public}d.", ret);
219 }
220 }
221
GapRecvWriteCurrentIACLAPComplete(const HciWriteCurrentIacLapReturnParam * param)222 static void GapRecvWriteCurrentIACLAPComplete(const HciWriteCurrentIacLapReturnParam *param)
223 {
224 HILOGI("status: 0x%{public}02x", param->status);
225 int ret = GapProcessHciEventInTask((TaskFunc)GapWriteCurrentIACLAPComplete, param, sizeof(*param), NULL);
226 if (ret != BT_SUCCESS) {
227 HILOGE("Task error: %{public}d.", ret);
228 }
229 }
230
GapRecvWriteInquiryScanTypeComplete(const HciWriteInquiryScanTypeReturnParam * param)231 static void GapRecvWriteInquiryScanTypeComplete(const HciWriteInquiryScanTypeReturnParam *param)
232 {
233 HILOGI("status: 0x%{public}02x", param->status);
234 int ret = GapProcessHciEventInTask((TaskFunc)GapWriteInquiryScanTypeComplete, param, sizeof(*param), NULL);
235 if (ret != BT_SUCCESS) {
236 HILOGE("Task error: %{public}d.", ret);
237 }
238 }
239
GapRecvWritePageScanTypeComplete(const HciWritePageScanTypeReturnParam * param)240 static void GapRecvWritePageScanTypeComplete(const HciWritePageScanTypeReturnParam *param)
241 {
242 HILOGI("status: 0x%{public}02x", param->status);
243 int ret = GapProcessHciEventInTask((TaskFunc)GapWritePageScanTypeComplete, param, sizeof(*param), NULL);
244 if (ret != BT_SUCCESS) {
245 HILOGE("Task error: %{public}d.", ret);
246 }
247 }
248
GapRecvSetExtendedInquiryResponseComplete(const HciWriteExtendedInquiryResponseReturnParam * param)249 static void GapRecvSetExtendedInquiryResponseComplete(const HciWriteExtendedInquiryResponseReturnParam *param)
250 {
251 HILOGI("status: 0x%{public}02x", param->status);
252 int ret = GapProcessHciEventInTask((TaskFunc)GapSetExtendedInquiryResponseComplete, param, sizeof(*param), NULL);
253 if (ret != BT_SUCCESS) {
254 HILOGE("Task error: %{public}d.", ret);
255 }
256 }
257
GapRecvWriteAuthenticatedPayloadTimeoutComplete(const HciWriteAuthenticatedPayloadTimeoutReturnParam * param)258 static void GapRecvWriteAuthenticatedPayloadTimeoutComplete(const HciWriteAuthenticatedPayloadTimeoutReturnParam *param)
259 {
260 HILOGI("status: 0x%{public}02x", param->status);
261 int ret =
262 GapProcessHciEventInTask((TaskFunc)GapWriteAuthenticatedPayloadTimeoutComplete, param, sizeof(*param), NULL);
263 if (ret != BT_SUCCESS) {
264 HILOGE("Task error: %{public}d.", ret);
265 }
266 }
267
GapRecvReadLocalOobDataComplete(const HciReadLocalOOBDataReturnParam * param)268 static void GapRecvReadLocalOobDataComplete(const HciReadLocalOOBDataReturnParam *param)
269 {
270 HILOGI("status: 0x%{public}02x", param->status);
271 int ret = GapProcessHciEventInTask((TaskFunc)GapReadLocalOobDataComplete, param, sizeof(*param), NULL);
272 if (ret != BT_SUCCESS) {
273 HILOGE("Task error: %{public}d.", ret);
274 }
275 }
276
GapRecvReadLocalOobExtendedDataComplete(const HciReadLocalOobExtendedDataReturnParam * param)277 static void GapRecvReadLocalOobExtendedDataComplete(const HciReadLocalOobExtendedDataReturnParam *param)
278 {
279 HILOGI("status: 0x%{public}02x", param->status);
280 int ret = GapProcessHciEventInTask((TaskFunc)GapReadLocalOobExtendedDataComplete, param, sizeof(*param), NULL);
281 if (ret != BT_SUCCESS) {
282 HILOGE("Task error: %{public}d.", ret);
283 }
284 }
285
GapRecvInquiryComplete(const HciInquiryCompleteEventParam * eventParam)286 static void GapRecvInquiryComplete(const HciInquiryCompleteEventParam *eventParam)
287 {
288 HILOGI("status: 0x%{public}02x", eventParam->status);
289 int ret = GapProcessHciEventInTask((TaskFunc)GapOnInquiryComplete, eventParam, sizeof(*eventParam), NULL);
290 if (ret != BT_SUCCESS) {
291 HILOGE("Task error: %{public}d.", ret);
292 }
293 }
294
GapFreeInquiryResult(void * ctx)295 static void GapFreeInquiryResult(void *ctx)
296 {
297 HciInquiryResultEventParam *hciParam = ctx;
298 MEM_MALLOC.free(hciParam->responses);
299 }
300
GapRecvInquiryResult(const HciInquiryResultEventParam * eventParam)301 static void GapRecvInquiryResult(const HciInquiryResultEventParam *eventParam)
302 {
303 HILOGI("num: %{public}hhu", eventParam->numResponses);
304 HciInquiryResultEventParam hciParam = *eventParam;
305 hciParam.responses = MEM_MALLOC.alloc(hciParam.numResponses * sizeof(HciInquiryResult));
306 if (hciParam.responses == NULL) {
307 HILOGE("Alloc error.");
308 return;
309 }
310
311 (void)memcpy_s(hciParam.responses,
312 hciParam.numResponses * sizeof(HciInquiryResult),
313 eventParam->responses,
314 hciParam.numResponses * sizeof(HciInquiryResult));
315
316 int ret = GapProcessHciEventInTask((TaskFunc)GapOnInquiryResult, &hciParam, sizeof(hciParam), GapFreeInquiryResult);
317 if (ret != BT_SUCCESS) {
318 HILOGE("Task error: %{public}d.", ret);
319 }
320 }
321
GapRecvAuthenticationComplete(const HciAuthenticationCompleteEventParam * eventParam)322 static void GapRecvAuthenticationComplete(const HciAuthenticationCompleteEventParam *eventParam)
323 {
324 HILOGI("handle: 0x%{public}04x, status: 0x%{public}02x", eventParam->connectionHandle, eventParam->status);
325 int ret = GapProcessHciEventInTask((TaskFunc)GapOnAuthenticationComplete, eventParam, sizeof(*eventParam), NULL);
326 if (ret != BT_SUCCESS) {
327 HILOGE("Task error: %{public}d.", ret);
328 }
329 }
330
GapRecvGetRemoteNameComplete(const HciRemoteNameRequestCompleteEventParam * eventParam)331 static void GapRecvGetRemoteNameComplete(const HciRemoteNameRequestCompleteEventParam *eventParam)
332 {
333 HILOGI("addr:" BT_ADDR_FMT "status: 0x%{public}02x",
334 BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw), eventParam->status);
335 int ret = GapProcessHciEventInTask((TaskFunc)GapOnGetRemoteNameComplete, eventParam, sizeof(*eventParam), NULL);
336 if (ret != BT_SUCCESS) {
337 HILOGE("Task error: %{public}d.", ret);
338 }
339 }
340
GapRecvEncryptionChangeEvent(const HciEncryptionChangeEventParam * eventParam)341 static void GapRecvEncryptionChangeEvent(const HciEncryptionChangeEventParam *eventParam)
342 {
343 HILOGI("handle: 0x%{public}04x, status: 0x%{public}02x, enable: %{public}hhu",
344 eventParam->connectionHandle,
345 eventParam->status,
346 eventParam->encryptionEnabled);
347 int ret = GapProcessHciEventInTask((TaskFunc)GapOnEncryptionChangeEvent, eventParam, sizeof(*eventParam), NULL);
348 if (ret != BT_SUCCESS) {
349 HILOGE("Task error: %{public}d.", ret);
350 }
351 }
352
GapRecvPINCodeRequestEvent(const HciPinCodeRequestEventParam * eventParam)353 static void GapRecvPINCodeRequestEvent(const HciPinCodeRequestEventParam *eventParam)
354 {
355 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
356 int ret = GapProcessHciEventInTask((TaskFunc)GapOnPINCodeRequestEvent, eventParam, sizeof(*eventParam), NULL);
357 if (ret != BT_SUCCESS) {
358 HILOGE("Task error: %{public}d.", ret);
359 }
360 }
361
GapRecvLinkKeyRequestEvent(const HciLinkKeyRequestEventParam * eventParam)362 static void GapRecvLinkKeyRequestEvent(const HciLinkKeyRequestEventParam *eventParam)
363 {
364 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
365 int ret = GapProcessHciEventInTask((TaskFunc)GapOnLinkKeyRequestEvent, eventParam, sizeof(*eventParam), NULL);
366 if (ret != BT_SUCCESS) {
367 HILOGE("Task error: %{public}d.", ret);
368 }
369 }
370
GapRecvLinkKeyNotificationEvent(const HciLinkKeyNotificationEventParam * eventParam)371 static void GapRecvLinkKeyNotificationEvent(const HciLinkKeyNotificationEventParam *eventParam)
372 {
373 HILOGI("addr:" BT_ADDR_FMT "type: %{public}d", BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw), eventParam->keyType);
374 int ret = GapProcessHciEventInTask((TaskFunc)GapOnLinkKeyNotificationEvent, eventParam, sizeof(*eventParam), NULL);
375 if (ret != BT_SUCCESS) {
376 HILOGE("Task error: %{public}d.", ret);
377 }
378 }
379
GapFreeInquiryResultRssi(void * ctx)380 static void GapFreeInquiryResultRssi(void *ctx)
381 {
382 HciInquiryResultWithRssiEventParam *hciParam = ctx;
383
384 MEM_MALLOC.free(hciParam->responses);
385 }
386
GapRecvInquiryResultRssi(const HciInquiryResultWithRssiEventParam * eventParam)387 static void GapRecvInquiryResultRssi(const HciInquiryResultWithRssiEventParam *eventParam)
388 {
389 HILOGI("num: %{public}hhu", eventParam->numResponses);
390 HciInquiryResultWithRssiEventParam hciParam = *eventParam;
391 hciParam.responses = MEM_MALLOC.alloc(hciParam.numResponses * sizeof(HciInquiryResultWithRssi));
392 if (hciParam.responses == NULL) {
393 HILOGE("Alloc error.");
394 return;
395 }
396
397 (void)memcpy_s(hciParam.responses,
398 hciParam.numResponses * sizeof(HciInquiryResultWithRssi),
399 eventParam->responses,
400 hciParam.numResponses * sizeof(HciInquiryResultWithRssi));
401
402 int ret = GapProcessHciEventInTask(
403 (TaskFunc)GapOnInquiryResultRssi, &hciParam, sizeof(hciParam), GapFreeInquiryResultRssi);
404 if (ret != BT_SUCCESS) {
405 HILOGE("Task error: %{public}d.", ret);
406 }
407 }
408
GapRecvEntendedInquiryResult(const HciExtendedInquiryResultEventParam * eventParam)409 static void GapRecvEntendedInquiryResult(const HciExtendedInquiryResultEventParam *eventParam)
410 {
411 HILOGI("num: %{public}hhu", eventParam->numResponses);
412 int ret = GapProcessHciEventInTask((TaskFunc)GapOnEntendedInquiryResult, eventParam, sizeof(*eventParam), NULL);
413 if (ret != BT_SUCCESS) {
414 HILOGE("Task error: %{public}d.", ret);
415 }
416 }
417
GapRecvEncryptionKeyRefreshComplete(const HciEncryptionKeyRefreshCompleteEventParam * eventParam)418 static void GapRecvEncryptionKeyRefreshComplete(const HciEncryptionKeyRefreshCompleteEventParam *eventParam)
419 {
420 HILOGI("handle: 0x%{public}04x, status: 0x%{public}02x", eventParam->connectionHandle, eventParam->status);
421 int ret =
422 GapProcessHciEventInTask((TaskFunc)GapOnEncryptionKeyRefreshComplete, eventParam, sizeof(*eventParam), NULL);
423 if (ret != BT_SUCCESS) {
424 HILOGE("Task error: %{public}d.", ret);
425 }
426 }
427
GapRecvIOCapabilityRequestEvent(const HciIoCapabilityRequestEventParam * eventParam)428 static void GapRecvIOCapabilityRequestEvent(const HciIoCapabilityRequestEventParam *eventParam)
429 {
430 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
431 int ret = GapProcessHciEventInTask((TaskFunc)GapOnIOCapabilityRequestEvent, eventParam, sizeof(*eventParam), NULL);
432 if (ret != BT_SUCCESS) {
433 HILOGE("Task error: %{public}d.", ret);
434 }
435 }
436
GapRecvIOCapabilityResponseEvent(const HciIoCapabilityResponseEventParam * eventParam)437 static void GapRecvIOCapabilityResponseEvent(const HciIoCapabilityResponseEventParam *eventParam)
438 {
439 HILOGI("addr:" BT_ADDR_FMT "IO: %{public}hhu, Authreq: %{public}hhu",
440 BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw),
441 eventParam->IOCapability,
442 eventParam->authenticationRequirements);
443 int ret = GapProcessHciEventInTask((TaskFunc)GapOnIOCapabilityResponseEvent, eventParam, sizeof(*eventParam), NULL);
444 if (ret != BT_SUCCESS) {
445 HILOGE("Task error: %{public}d.", ret);
446 }
447 }
448
GapRecvUserConfirmationRequestEvent(const HciUserConfirmationRequestEventParam * eventParam)449 static void GapRecvUserConfirmationRequestEvent(const HciUserConfirmationRequestEventParam *eventParam)
450 {
451 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
452 int ret =
453 GapProcessHciEventInTask((TaskFunc)GapOnUserConfirmationRequestEvent, eventParam, sizeof(*eventParam), NULL);
454 if (ret != BT_SUCCESS) {
455 HILOGE("Task error: %{public}d.", ret);
456 }
457 }
458
GapRecvUserPasskeyRequestEvent(const HciUserPasskeyRequestEventParam * eventParam)459 static void GapRecvUserPasskeyRequestEvent(const HciUserPasskeyRequestEventParam *eventParam)
460 {
461 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
462 int ret = GapProcessHciEventInTask((TaskFunc)GapOnUserPasskeyRequestEvent, eventParam, sizeof(*eventParam), NULL);
463 if (ret != BT_SUCCESS) {
464 HILOGE("Task error: %{public}d.", ret);
465 }
466 }
467
GapRecvRemoteOOBDataRequestEvent(const HciRemoteOobDataRequestEventParam * eventParam)468 static void GapRecvRemoteOOBDataRequestEvent(const HciRemoteOobDataRequestEventParam *eventParam)
469 {
470 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
471 int ret = GapProcessHciEventInTask((TaskFunc)GapOnRemoteOOBDataRequestEvent, eventParam, sizeof(*eventParam), NULL);
472 if (ret != BT_SUCCESS) {
473 HILOGE("Task error: %{public}d.", ret);
474 }
475 }
476
GapRecvSimplePairingComplete(const HciSimplePairingCompleteEventParam * eventParam)477 static void GapRecvSimplePairingComplete(const HciSimplePairingCompleteEventParam *eventParam)
478 {
479 HILOGI("addr:" BT_ADDR_FMT "status: 0x%{public}02x",
480 BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw),
481 eventParam->status);
482 int ret = GapProcessHciEventInTask((TaskFunc)GapOnSimplePairingComplete, eventParam, sizeof(*eventParam), NULL);
483 if (ret != BT_SUCCESS) {
484 HILOGE("Task error: %{public}d.", ret);
485 }
486 }
487
GapRecvUserPasskeyNotificationEvent(const HciUserPasskeyNotificationEventParam * eventParam)488 static void GapRecvUserPasskeyNotificationEvent(const HciUserPasskeyNotificationEventParam *eventParam)
489 {
490 HILOGI("addr:" BT_ADDR_FMT, BT_ADDR_FMT_OUTPUT(eventParam->bdAddr.raw));
491 int ret =
492 GapProcessHciEventInTask((TaskFunc)GapOnUserPasskeyNotificationEvent, eventParam, sizeof(*eventParam), NULL);
493 if (ret != BT_SUCCESS) {
494 HILOGE("Task error: %{public}d.", ret);
495 }
496 }
497
GapRecvAuthenticatedPayloadTimeoutExpiredEvent(const HciAuthenticatedPayloadTimeoutExpiredEventParam * eventParam)498 static void GapRecvAuthenticatedPayloadTimeoutExpiredEvent(
499 const HciAuthenticatedPayloadTimeoutExpiredEventParam *eventParam)
500 {
501 HILOGI("handle: 0x%{public}04x", eventParam->connectionHandle);
502 int ret = GapProcessHciEventInTask(
503 (TaskFunc)GapOnAuthenticatedPayloadTimeoutExpiredEvent, eventParam, sizeof(*eventParam), NULL);
504 if (ret != BT_SUCCESS) {
505 HILOGE("Task error: %{public}d.", ret);
506 }
507 }
508 #endif
509
510 #ifdef GAP_LE_SUPPORT
511
GapRecvLeAdvSetParamComplete(const HciLeSetAdvertisingParametersReturnParam * param)512 static void GapRecvLeAdvSetParamComplete(const HciLeSetAdvertisingParametersReturnParam *param)
513 {
514 HILOGI("status: 0x%{public}02x", param->status);
515 int ret = GapProcessHciEventInTask((TaskFunc)GapLeAdvSetParamComplete, param, sizeof(*param), NULL);
516 if (ret != BT_SUCCESS) {
517 HILOGE("Task error: %{public}d.", ret);
518 }
519 }
520
GapRecvLeAdvReadTxPowerComplete(const HciLeReadAdvertisingChannelTxPowerReturnParam * param)521 static void GapRecvLeAdvReadTxPowerComplete(const HciLeReadAdvertisingChannelTxPowerReturnParam *param)
522 {
523 HILOGI("status: 0x%{public}02x", param->status);
524 int ret = GapProcessHciEventInTask((TaskFunc)GapLeAdvReadTxPowerComplete, param, sizeof(*param), NULL);
525 if (ret != BT_SUCCESS) {
526 HILOGE("Task error: %{public}d.", ret);
527 }
528 }
529
GapRecvLeAdvSetDataComplete(const HciLeSetAdvertisingDataReturnParam * param)530 static void GapRecvLeAdvSetDataComplete(const HciLeSetAdvertisingDataReturnParam *param)
531 {
532 HILOGI("status: 0x%{public}02x", param->status);
533 int ret = GapProcessHciEventInTask((TaskFunc)GapLeAdvSetDataComplete, param, sizeof(*param), NULL);
534 if (ret != BT_SUCCESS) {
535 HILOGE("Task error: %{public}d.", ret);
536 }
537 }
538
GapRecvLeAdvSetScanRspDataComplete(const HciLeSetScanResponseDataReturnParam * param)539 static void GapRecvLeAdvSetScanRspDataComplete(const HciLeSetScanResponseDataReturnParam *param)
540 {
541 HILOGI("status: 0x%{public}02x", param->status);
542 int ret = GapProcessHciEventInTask((TaskFunc)GapLeAdvSetScanRspDataComplete, param, sizeof(*param), NULL);
543 if (ret != BT_SUCCESS) {
544 HILOGE("Task error: %{public}d.", ret);
545 }
546 }
547
GapRecvLeAdvSetEnableComplete(const HciLeSetAdvertisingEnableReturnParam * param)548 static void GapRecvLeAdvSetEnableComplete(const HciLeSetAdvertisingEnableReturnParam *param)
549 {
550 HILOGI("status: 0x%{public}02x", param->status);
551 int ret = GapProcessHciEventInTask((TaskFunc)GapLeAdvSetEnableComplete, param, sizeof(*param), NULL);
552 if (ret != BT_SUCCESS) {
553 HILOGE("Task error: %{public}d.", ret);
554 }
555 }
556
GapRecvLeScanSetParamComplete(const HciLeSetExtendedScanParametersReturnParam * param)557 static void GapRecvLeScanSetParamComplete(const HciLeSetExtendedScanParametersReturnParam *param)
558 {
559 HILOGI("status: 0x%{public}02x", param->status);
560 int ret = GapProcessHciEventInTask((TaskFunc)GapLeScanSetParamComplete, param, sizeof(*param), NULL);
561 if (ret != BT_SUCCESS) {
562 HILOGE("Task error: %{public}d.", ret);
563 }
564 }
565
GapRecvLeScanSetEnableComplete(const HciLeSetScanEnableReturnParam * param)566 static void GapRecvLeScanSetEnableComplete(const HciLeSetScanEnableReturnParam *param)
567 {
568 HILOGI("status: 0x%{public}02x", param->status);
569 int ret = GapProcessHciEventInTask((TaskFunc)GapLeScanSetEnableComplete, param, sizeof(*param), NULL);
570 if (ret != BT_SUCCESS) {
571 HILOGE("Task error: %{public}d.", ret);
572 }
573 }
574
GapRecvLeSetHostChannelClassificationComplete(const HciLeSetHostChannelClassificationReturnParam * param)575 static void GapRecvLeSetHostChannelClassificationComplete(const HciLeSetHostChannelClassificationReturnParam *param)
576 {
577 HILOGI("status: 0x%{public}02x", param->status);
578 int ret =
579 GapProcessHciEventInTask((TaskFunc)GapLeSetHostChannelClassificationComplete, param, sizeof(*param), NULL);
580 if (ret != BT_SUCCESS) {
581 HILOGE("Task error: %{public}d.", ret);
582 }
583 }
584
GapRecvLeReadChannelMapComplete(const HciLeReadChannelMapReturnParam * param)585 static void GapRecvLeReadChannelMapComplete(const HciLeReadChannelMapReturnParam *param)
586 {
587 HILOGI("status: 0x%{public}02x, handle: 0x%{public}04x", param->status, param->connectionHandle);
588 int ret = GapProcessHciEventInTask((TaskFunc)GapLeReadChannelMapComplete, param, sizeof(*param), NULL);
589 if (ret != BT_SUCCESS) {
590 HILOGE("Task error: %{public}d.", ret);
591 }
592 }
593
GapRecvLeRemoteConnectionParameterRequestReplyComplete(const HciLeRemoteConnectionParameterRequestReplyReturnParam * param)594 static void GapRecvLeRemoteConnectionParameterRequestReplyComplete(
595 const HciLeRemoteConnectionParameterRequestReplyReturnParam *param)
596 {
597 HILOGI("status: 0x%{public}02x, handle:0x%{public}04x", param->status, param->connectionHandle);
598 int ret = GapProcessHciEventInTask(
599 (TaskFunc)GapLeRemoteConnectionParameterRequestReplyComplete, param, sizeof(*param), NULL);
600 if (ret != BT_SUCCESS) {
601 HILOGE("Task error: %{public}d.", ret);
602 }
603 }
604
GapRecvLeRemoteConnectionParameterRequestNegativeReplyComplete(const HciLeRemoteConnectionParameterRequestNegativeReplyReturnParam * param)605 static void GapRecvLeRemoteConnectionParameterRequestNegativeReplyComplete(
606 const HciLeRemoteConnectionParameterRequestNegativeReplyReturnParam *param)
607 {
608 HILOGI("status: 0x%{public}02x, handle:0x%{public}04x", param->status, param->connectionHandle);
609 int ret = GapProcessHciEventInTask(
610 (TaskFunc)GapLeRemoteConnectionParameterRequestNegativeReplyComplete, param, sizeof(*param), NULL);
611 if (ret != BT_SUCCESS) {
612 HILOGE("Task error: %{public}d.", ret);
613 }
614 }
615
GapRecvLeSetAdvertisingSetRandomAddressComplete(const HciLeSetAdvertisingSetRandomAddressReturnParam * param)616 static void GapRecvLeSetAdvertisingSetRandomAddressComplete(const HciLeSetAdvertisingSetRandomAddressReturnParam *param)
617 {
618 HILOGI("status: 0x%{public}02x", param->status);
619 int ret =
620 GapProcessHciEventInTask((TaskFunc)GapLeSetAdvertisingSetRandomAddressComplete, param, sizeof(*param), NULL);
621 if (ret != BT_SUCCESS) {
622 HILOGE("Task error: %{public}d.", ret);
623 }
624 }
625
GapRecvLeSetExtendedAdvertisingParametersComplete(const HciLeSetExtendedAdvertisingParametersReturnParam * param)626 static void GapRecvLeSetExtendedAdvertisingParametersComplete(
627 const HciLeSetExtendedAdvertisingParametersReturnParam *param)
628 {
629 HILOGI("status: 0x%{public}02x", param->status);
630 int ret =
631 GapProcessHciEventInTask((TaskFunc)GapLeSetExtendedAdvertisingParametersComplete, param, sizeof(*param), NULL);
632 if (ret != BT_SUCCESS) {
633 HILOGE("Task error: %{public}d.", ret);
634 }
635 }
636
GapRecvLeSetExtendedAdvertisingDataComplete(const HciLeSetExtendedAdvertisingDataReturnParam * param)637 static void GapRecvLeSetExtendedAdvertisingDataComplete(const HciLeSetExtendedAdvertisingDataReturnParam *param)
638 {
639 HILOGI("status: 0x%{public}02x", param->status);
640 int ret = GapProcessHciEventInTask((TaskFunc)GapLeSetExtendedAdvertisingDataComplete, param, sizeof(*param), NULL);
641 if (ret != BT_SUCCESS) {
642 HILOGE("Task error: %{public}d.", ret);
643 }
644 }
645
GapRecvLeSetExtendedScanResponseDataComplete(const HciLeSetExtendedScanResponseDataReturnParam * param)646 static void GapRecvLeSetExtendedScanResponseDataComplete(const HciLeSetExtendedScanResponseDataReturnParam *param)
647 {
648 HILOGI("status: 0x%{public}02x", param->status);
649 int ret = GapProcessHciEventInTask((TaskFunc)GapLeSetExtendedScanResponseDataComplete, param, sizeof(*param), NULL);
650 if (ret != BT_SUCCESS) {
651 HILOGE("Task error: %{public}d.", ret);
652 }
653 }
654
GapRecvLeSetExtendedAdvertisingEnableComplete(const HciLeSetExtendedAdvertisingEnableReturnParam * param)655 static void GapRecvLeSetExtendedAdvertisingEnableComplete(const HciLeSetExtendedAdvertisingEnableReturnParam *param)
656 {
657 HILOGI("status: 0x%{public}02x", param->status);
658 int ret =
659 GapProcessHciEventInTask((TaskFunc)GapLeSetExtendedAdvertisingEnableComplete, param, sizeof(*param), NULL);
660 if (ret != BT_SUCCESS) {
661 HILOGE("Task error: %{public}d.", ret);
662 }
663 }
664
GapRecvLeReadMaximumAdvertisingDataLengthComplete(const HciLeReadMaximumAdvertisingDataLengthReturnParam * param)665 static void GapRecvLeReadMaximumAdvertisingDataLengthComplete(
666 const HciLeReadMaximumAdvertisingDataLengthReturnParam *param)
667 {
668 HILOGI("status: 0x%{public}02x, len: %{public}hu", param->status, param->maximumAdvertisingDataLength);
669 int ret =
670 GapProcessHciEventInTask((TaskFunc)GapLeReadMaximumAdvertisingDataLengthComplete, param, sizeof(*param), NULL);
671 if (ret != BT_SUCCESS) {
672 HILOGE("Task error: %{public}d.", ret);
673 }
674 }
675
GapRecvLeReadNumberofSupportedAdvertisingSetsComplete(const HciLeReadNumberofSupportedAdvertisingSetsReturnParam * param)676 static void GapRecvLeReadNumberofSupportedAdvertisingSetsComplete(
677 const HciLeReadNumberofSupportedAdvertisingSetsReturnParam *param)
678 {
679 HILOGI("status: 0x%{public}02x, num: %{public}hhu", param->status, param->numSupportedAdvertisingSets);
680 int ret = GapProcessHciEventInTask(
681 (TaskFunc)GapLeReadNumberofSupportedAdvertisingSetsComplete, param, sizeof(*param), NULL);
682 if (ret != BT_SUCCESS) {
683 HILOGE("Task error: %{public}d.", ret);
684 }
685 }
686
GapRecvLeRemoveAdvertisingSetComplete(const HciLeRemoveAdvertisingSetReturnParam * param)687 static void GapRecvLeRemoveAdvertisingSetComplete(const HciLeRemoveAdvertisingSetReturnParam *param)
688 {
689 HILOGI("status: 0x%{public}02x", param->status);
690 int ret = GapProcessHciEventInTask((TaskFunc)GapLeRemoveAdvertisingSetComplete, param, sizeof(*param), NULL);
691 if (ret != BT_SUCCESS) {
692 HILOGE("Task error: %{public}d.", ret);
693 }
694 }
695
GapRecvLeClearAdvertisingSetsComplete(const HciLeClearAdvertisingSetsReturnParam * param)696 static void GapRecvLeClearAdvertisingSetsComplete(const HciLeClearAdvertisingSetsReturnParam *param)
697 {
698 HILOGI("status: 0x%{public}02x", param->status);
699 int ret = GapProcessHciEventInTask((TaskFunc)GapLeClearAdvertisingSetsComplete, param, sizeof(*param), NULL);
700 if (ret != BT_SUCCESS) {
701 HILOGE("Task error: %{public}d.", ret);
702 }
703 }
704
GapRecvLeSetExtendedScanParametersComplete(const HciLeSetExtendedScanParametersReturnParam * param)705 static void GapRecvLeSetExtendedScanParametersComplete(const HciLeSetExtendedScanParametersReturnParam *param)
706 {
707 HILOGI("status: 0x%{public}02x", param->status);
708 int ret = GapProcessHciEventInTask((TaskFunc)GapLeSetExtendedScanParametersComplete, param, sizeof(*param), NULL);
709 if (ret != BT_SUCCESS) {
710 HILOGE("Task error: %{public}d.", ret);
711 }
712 }
713
GapRecvLeSetExtendedScanEnableComplete(const HciLeSetExtendedScanEnableReturnParam * param)714 static void GapRecvLeSetExtendedScanEnableComplete(const HciLeSetExtendedScanEnableReturnParam *param)
715 {
716 HILOGI("status: 0x%{public}02x", param->status);
717 int ret = GapProcessHciEventInTask((TaskFunc)GapLeSetExtendedScanEnableComplete, param, sizeof(*param), NULL);
718 if (ret != BT_SUCCESS) {
719 HILOGE("Task error: %{public}d.", ret);
720 }
721 }
722
GapFreeLeAdvertisingReportEvent(void * ctx)723 static void GapFreeLeAdvertisingReportEvent(void *ctx)
724 {
725 HILOGI("enter");
726 HciLeAdvertisingReportEventParam *hciParam = ctx;
727
728 for (int i = 0; i < hciParam->numReports; i++) {
729 MEM_MALLOC.free(hciParam->reports[i].data);
730 }
731 MEM_MALLOC.free(hciParam->reports);
732 }
733
GapRecvLeAdvertisingReportEvent(const HciLeAdvertisingReportEventParam * eventParam)734 static void GapRecvLeAdvertisingReportEvent(const HciLeAdvertisingReportEventParam *eventParam)
735 {
736 HILOGI("num: %{public}hhu", eventParam->numReports);
737 HciLeAdvertisingReportEventParam hciParam = *eventParam;
738 int index;
739 hciParam.reports = MEM_MALLOC.alloc(hciParam.numReports * sizeof(HciLeAdvertisingReport));
740 if (hciParam.reports == NULL) {
741 HILOGE("Alloc report error.");
742 return;
743 }
744
745 (void)memcpy_s(hciParam.reports,
746 hciParam.numReports * sizeof(HciLeAdvertisingReport),
747 eventParam->reports,
748 hciParam.numReports * sizeof(HciLeAdvertisingReport));
749 for (index = 0; index < hciParam.numReports; index++) {
750 hciParam.reports[index].data = MEM_MALLOC.alloc(hciParam.reports[index].lengthData);
751 if (hciParam.reports[index].data == NULL) {
752 HILOGE("Alloc report data error.");
753 break;
754 }
755 (void)memcpy_s(hciParam.reports[index].data,
756 hciParam.reports[index].lengthData,
757 eventParam->reports[index].data,
758 eventParam->reports[index].lengthData);
759 }
760
761 if (index < hciParam.numReports) {
762 while (index-- > 0) {
763 MEM_MALLOC.free(hciParam.reports[index].data);
764 }
765 MEM_MALLOC.free(hciParam.reports);
766 return;
767 }
768
769 int ret = GapProcessHciEventInTask(
770 (TaskFunc)GapOnLeAdvertisingReportEvent, &hciParam, sizeof(hciParam), GapFreeLeAdvertisingReportEvent);
771 if (ret != BT_SUCCESS) {
772 HILOGE("Task error: %{public}d.", ret);
773 }
774 }
775
GapRecvLeConnectionUpdateCompleteEvent(const HciLeConnectionUpdateCompleteEventParam * eventParam)776 static void GapRecvLeConnectionUpdateCompleteEvent(const HciLeConnectionUpdateCompleteEventParam *eventParam)
777 {
778 HILOGI("status: 0x%{public}02x, handle: 0x%{public}04x", eventParam->status, eventParam->connectionHandle);
779 int ret =
780 GapProcessHciEventInTask((TaskFunc)GapOnLeConnectionUpdateCompleteEvent, eventParam, sizeof(*eventParam), NULL);
781 if (ret != BT_SUCCESS) {
782 HILOGE("Task error: %{public}d.", ret);
783 }
784 }
785
GapRecvLeRemoteConnectionParameterRequestEvent(const HciLeRemoteConnectionParameterRequestEventParam * eventParam)786 static void GapRecvLeRemoteConnectionParameterRequestEvent(
787 const HciLeRemoteConnectionParameterRequestEventParam *eventParam)
788 {
789 HILOGI("handle: 0x%{public}04x", eventParam->connectionHandle);
790 int ret = GapProcessHciEventInTask(
791 (TaskFunc)GapOnLeRemoteConnectionParameterRequestEvent, eventParam, sizeof(*eventParam), NULL);
792 if (ret != BT_SUCCESS) {
793 HILOGE("Task error: %{public}d.", ret);
794 }
795 }
796
GapRecvLeDirectedAdvertisingReport(const HciLeDirectedAdvertisingReportEventParam * eventParam)797 static void GapRecvLeDirectedAdvertisingReport(const HciLeDirectedAdvertisingReportEventParam *eventParam)
798 {
799 HILOGI("enter");
800 HciLeDirectedAdvertisingReportEventParam hciParam = *eventParam;
801 hciParam.reports = MEM_MALLOC.alloc(hciParam.numReports * sizeof(HciLeDirectedAdvertisingReport));
802 if (hciParam.reports == NULL) {
803 HILOGE("Alloc report error.");
804 return;
805 }
806
807 (void)memcpy_s(hciParam.reports,
808 hciParam.numReports * sizeof(HciLeDirectedAdvertisingReport),
809 eventParam->reports,
810 hciParam.numReports * sizeof(HciLeDirectedAdvertisingReport));
811 int ret = GapProcessHciEventInTask((TaskFunc)GapOnLeDirectedAdvertisingReport, &hciParam, sizeof(hciParam), NULL);
812 if (ret != BT_SUCCESS) {
813 HILOGE("Task error: %{public}d.", ret);
814 }
815 }
816
GapFreeLeExtendedAdvertisingReportEvent(void * ctx)817 static void GapFreeLeExtendedAdvertisingReportEvent(void *ctx)
818 {
819 HciLeExtendedAdvertisingReportEventParam *hciParam = ctx;
820
821 for (int i = 0; i < hciParam->numReports; i++) {
822 MEM_MALLOC.free(hciParam->reports[i].data);
823 }
824 MEM_MALLOC.free(hciParam->reports);
825 }
826
GapRecvLeExtendedAdvertisingReportEvent(const HciLeExtendedAdvertisingReportEventParam * eventParam)827 static void GapRecvLeExtendedAdvertisingReportEvent(const HciLeExtendedAdvertisingReportEventParam *eventParam)
828 {
829 HILOGI("num: %{public}hhu", eventParam->numReports);
830 HciLeExtendedAdvertisingReportEventParam hciParam = *eventParam;
831 int i;
832 hciParam.reports = MEM_MALLOC.alloc(hciParam.numReports * sizeof(HciLeExtendedAdvertisingReport));
833 if (hciParam.reports == NULL) {
834 HILOGE("Alloc report error.");
835 return;
836 }
837
838 (void)memcpy_s(hciParam.reports,
839 hciParam.numReports * sizeof(HciLeExtendedAdvertisingReport),
840 eventParam->reports,
841 hciParam.numReports * sizeof(HciLeExtendedAdvertisingReport));
842 for (i = 0; i < hciParam.numReports; i++) {
843 hciParam.reports[i].data = MEM_MALLOC.alloc(hciParam.reports[i].dataLength);
844 if (hciParam.reports[i].data == NULL) {
845 HILOGE("Alloc report data error.");
846 break;
847 }
848 (void)memcpy_s(hciParam.reports[i].data,
849 hciParam.reports[i].dataLength,
850 eventParam->reports[i].data,
851 eventParam->reports[i].dataLength);
852 }
853
854 if (i < hciParam.numReports) {
855 while (i-- > 0) {
856 MEM_MALLOC.free(hciParam.reports[i].data);
857 }
858 MEM_MALLOC.free(hciParam.reports);
859 return;
860 }
861
862 int ret = GapProcessHciEventInTask((TaskFunc)GapOnLeExtendedAdvertisingReportEvent,
863 &hciParam,
864 sizeof(hciParam),
865 GapFreeLeExtendedAdvertisingReportEvent);
866 if (ret != BT_SUCCESS) {
867 HILOGE("Task error: %{public}d.", ret);
868 }
869 }
870
GapRecvLeScanTimeoutEvent(void)871 static void GapRecvLeScanTimeoutEvent(void)
872 {
873 HILOGI("enter");
874 int ret = GapProcessHciEventInTask((TaskFunc)GapOnLeScanTimeoutEvent, NULL, 0, NULL);
875 if (ret != BT_SUCCESS) {
876 HILOGE("Task error: %{public}d.", ret);
877 }
878 }
879
GapRecvLeAdvertisingSetTerminated(const HciLeAdvertisingSetTerminatedEventParam * eventParam)880 static void GapRecvLeAdvertisingSetTerminated(const HciLeAdvertisingSetTerminatedEventParam *eventParam)
881 {
882 HILOGI("advHandle: %{public}hhu, status: 0x%{public}02x", eventParam->advertisingHandle, eventParam->status);
883 int ret =
884 GapProcessHciEventInTask((TaskFunc)GapOnLeAdvertisingSetTerminated, eventParam, sizeof(*eventParam), NULL);
885 if (ret != BT_SUCCESS) {
886 HILOGE("Task error: %{public}d.", ret);
887 }
888 }
889
GapRecvLeScanRequestReceivedEvent(const HciLeScanRequestReceivedEventParam * eventParam)890 static void GapRecvLeScanRequestReceivedEvent(const HciLeScanRequestReceivedEventParam *eventParam)
891 {
892 HILOGI("addr:" BT_ADDR_FMT "advHandle: %{public}hhu",
893 BT_ADDR_FMT_OUTPUT(eventParam->scannerAddress.raw),
894 eventParam->advertisingHandle);
895 int ret =
896 GapProcessHciEventInTask((TaskFunc)GapOnLeScanRequestReceivedEvent, eventParam, sizeof(*eventParam), NULL);
897 if (ret != BT_SUCCESS) {
898 HILOGE("Task error: %{public}d.", ret);
899 }
900 }
901
902 #endif
903
904 static HciEventCallbacks g_hciEventCallbacks = {
905 #ifdef GAP_BREDR_SUPPORT
906 .inquiryCancelComplete = GapRecvInquiryCancelComplete,
907 .linkKeyRequestReplyComplete = GapRecvLinkKeyRequestReplyComplete,
908 .linkKeyRequestNegativeReplyComplete = GapRecvLinkKeyRequestNegativeReplyComplete,
909 .pinCodeRequestReplyComplete = GapRecvPINCodeRequestReplyComplete,
910 .pinCodeRequestNegativeReplyComplete = GapRecvPINCodeRequestNegativeReplyComplete,
911 .remoteNameRequestCancelComplete = GapRecvGetRemoteNameCancelComplete,
912 .ioCapabilityRequestReplyComplete = GapRecvIOCapabilityRequestReplyComplete,
913 .userConfirmationRequestReplyComplete = GapRecvUserConfirmationRequestReplyComplete,
914 .userConfirmationRequestNegativeReplyComplete = GapRecvUserConfirmationRequestNegativeReplyComplete,
915 .userPasskeyRequestReplyComplete = GapRecvUserPasskeyRequestReplyComplete,
916 .userPasskeyRequestNegativeReplyComplete = GapRecvUserPasskeyRequestNegativeReplyComplete,
917 .remoteOOBDataRequestReplyComplete = GapRecvRemoteOOBDataRequestReplyComplete,
918 .remoteOOBDataRequestNegativeReplyComplete = GapRecvRemoteOOBDataRequestNegativeReplyComplete,
919 .iOCapabilityRequestNegativeReplyComplete = GapRecvIOCapabilityRequestNegativeReplyComplete,
920 .remoteOOBExtendedDataRequestReplyComplete = GapRecvRemoteOOBExtendedDataRequestReplyComplete,
921
922 .writeScanEnableComplete = GapRecvWriteScanEnableComplete,
923 .writePageScanActivityComplete = GapRecvWritePageScanActivityComplete,
924 .writeInquiryScanActivityComplete = GapRecvWriteInquiryScanActivityComplete,
925 .writeClassofDeviceComplete = GapRecvWriteClassOfDeviceComplete,
926 .writeCurrentIacLapComplete = GapRecvWriteCurrentIACLAPComplete,
927 .writeInquiryScanTypeComplete = GapRecvWriteInquiryScanTypeComplete,
928 .writePageScanTypeComplete = GapRecvWritePageScanTypeComplete,
929 .writeExtendedInquiryResponseComplete = GapRecvSetExtendedInquiryResponseComplete,
930 .writeAuthenticatedPayloadTimeoutComplete = GapRecvWriteAuthenticatedPayloadTimeoutComplete,
931 .readLocalOOBDataComplete = GapRecvReadLocalOobDataComplete,
932 .readLocalOOBExtendedDataComplete = GapRecvReadLocalOobExtendedDataComplete,
933
934 .inquiryComplete = GapRecvInquiryComplete,
935 .inquiryResult = GapRecvInquiryResult,
936 .authenticationComplete = GapRecvAuthenticationComplete,
937 .remoteNameRequestComplete = GapRecvGetRemoteNameComplete,
938 .encryptionChange = GapRecvEncryptionChangeEvent,
939 .pinCodeRequest = GapRecvPINCodeRequestEvent,
940 .linkKeyRequest = GapRecvLinkKeyRequestEvent,
941 .linkKeyNotification = GapRecvLinkKeyNotificationEvent,
942 .inquiryResultWithRSSI = GapRecvInquiryResultRssi,
943 .extendedInquiryResult = GapRecvEntendedInquiryResult,
944 .encryptionKeyRefreshComplete = GapRecvEncryptionKeyRefreshComplete,
945 .ioCapabilityRequest = GapRecvIOCapabilityRequestEvent,
946 .ioCapabilityResponse = GapRecvIOCapabilityResponseEvent,
947 .userConfirmationRequest = GapRecvUserConfirmationRequestEvent,
948 .userPasskeyRequest = GapRecvUserPasskeyRequestEvent,
949 .remoteOOBDataRequest = GapRecvRemoteOOBDataRequestEvent,
950 .simplePairingComplete = GapRecvSimplePairingComplete,
951 .userPasskeyNotification = GapRecvUserPasskeyNotificationEvent,
952 .authenticatedPayloadTimeoutExpired = GapRecvAuthenticatedPayloadTimeoutExpiredEvent,
953 #endif
954
955 #ifdef GAP_LE_SUPPORT
956 .leSetAdvertisingParametersComplete = GapRecvLeAdvSetParamComplete,
957 .leReadAdvertisingChannelTxPowerComplete = GapRecvLeAdvReadTxPowerComplete,
958 .leSetAdvertisingDataComplete = GapRecvLeAdvSetDataComplete,
959 .leSetScanResponseDataComplete = GapRecvLeAdvSetScanRspDataComplete,
960 .leSetAdvertisingEnableComplete = GapRecvLeAdvSetEnableComplete,
961 .leSetScanParametersComplete = GapRecvLeScanSetParamComplete,
962 .leSetScanEnableComplete = GapRecvLeScanSetEnableComplete,
963 .leSetHostChannelClassificationComplete = GapRecvLeSetHostChannelClassificationComplete,
964 .leReadChannelMapComplete = GapRecvLeReadChannelMapComplete,
965 .leRemoteConnectionParameterRequestReplyComplete = GapRecvLeRemoteConnectionParameterRequestReplyComplete,
966 .leRemoteConnectionParameterRequestNegativeReplyComplete =
967 GapRecvLeRemoteConnectionParameterRequestNegativeReplyComplete,
968 .leSetAdvertisingSetRandomAddressComplete = GapRecvLeSetAdvertisingSetRandomAddressComplete,
969 .leSetExtendedAdvertisingParametersComplete = GapRecvLeSetExtendedAdvertisingParametersComplete,
970 .leSetExtendedAdvertisingDataComplete = GapRecvLeSetExtendedAdvertisingDataComplete,
971 .leSetExtendedScanResponseDataComplete = GapRecvLeSetExtendedScanResponseDataComplete,
972 .leSetExtendedAdvertisingEnableComplete = GapRecvLeSetExtendedAdvertisingEnableComplete,
973 .leReadMaximumAdvertisingDataLengthComplete = GapRecvLeReadMaximumAdvertisingDataLengthComplete,
974 .leReadNumberofSupportedAdvertisingSetsComplete = GapRecvLeReadNumberofSupportedAdvertisingSetsComplete,
975 .leRemoveAdvertisingSetComplete = GapRecvLeRemoveAdvertisingSetComplete,
976 .leClearAdvertisingSetsComplete = GapRecvLeClearAdvertisingSetsComplete,
977 .leSetExtendedScanParametersComplete = GapRecvLeSetExtendedScanParametersComplete,
978 .leSetExtendedScanEnableComplete = GapRecvLeSetExtendedScanEnableComplete,
979
980 .leAdvertisingReport = GapRecvLeAdvertisingReportEvent,
981 .leConnectionUpdateComplete = GapRecvLeConnectionUpdateCompleteEvent,
982 .leRemoteConnectionParameterRequest = GapRecvLeRemoteConnectionParameterRequestEvent,
983 .leDirectedAdvertisingReport = GapRecvLeDirectedAdvertisingReport,
984 .leExtendedAdvertisingReport = GapRecvLeExtendedAdvertisingReportEvent,
985 .leScanTimeoutComplete = GapRecvLeScanTimeoutEvent,
986 .leAdvertisingSetTerminated = GapRecvLeAdvertisingSetTerminated,
987 .leScanRequestReceived = GapRecvLeScanRequestReceivedEvent,
988 #endif
989 };
990
GapRegisterHciEventCallbacks(void)991 void GapRegisterHciEventCallbacks(void)
992 {
993 HILOGI("enter");
994 HCI_RegisterEventCallbacks(&g_hciEventCallbacks);
995 }
996
GapDeregisterHciEventCallbacks(void)997 void GapDeregisterHciEventCallbacks(void)
998 {
999 HILOGI("enter");
1000 HCI_DeregisterEventCallbacks(&g_hciEventCallbacks);
1001 }
1002