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