1 /*
2 * Copyright (c) 2021-2023 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 "wifi_hal.h"
17 #include <stdbool.h>
18 #include "securec.h"
19 #include "unistd.h"
20 #include "hdf_log.h"
21 #include "wifi_hal_cmd.h"
22 #include "wifi_hal_common.h"
23 #include "wifi_hal_util.h"
24 #include "wifi_driver_client.h"
25
26 #ifdef __cplusplus
27 #if __cplusplus
28 extern "C" {
29 #endif
30 #endif
31
32 static bool g_wifiIsStarted = false;
33
StartInner(const struct IWiFi * iwifi)34 static int32_t StartInner(const struct IWiFi *iwifi)
35 {
36 int32_t ret;
37 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
38 if (iwifi == NULL) {
39 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
40 return HDF_ERR_INVALID_PARAM;
41 }
42 if (g_wifiIsStarted) {
43 HDF_LOGI("%s: wifi has started already, line: %d", __FUNCTION__, __LINE__);
44 return HDF_SUCCESS;
45 }
46 ret = WifiDriverClientInit();
47 if (ret != HDF_SUCCESS) {
48 HDF_LOGE("%s: WifiDriverClientInit failed, line: %d, error no: %d", __FUNCTION__, __LINE__, ret);
49 return ret;
50 }
51
52 ret = HalCmdGetAvailableNetwork();
53 if (ret != HDF_SUCCESS) {
54 HDF_LOGE("%s: HalCmdGetAvailableNetwork failed, line: %d, error no: %d", __FUNCTION__, __LINE__, ret);
55 WifiDriverClientDeinit();
56 return ret;
57 }
58 g_wifiIsStarted = true;
59 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
60 return ret;
61 }
62
StopInner(const struct IWiFi * iwifi)63 static int32_t StopInner(const struct IWiFi *iwifi)
64 {
65 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
66 if (iwifi == NULL) {
67 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
68 return HDF_ERR_INVALID_PARAM;
69 }
70 if (!g_wifiIsStarted) {
71 HDF_LOGI("%s: wifi has stopped already, line: %d", __FUNCTION__, __LINE__);
72 return HDF_SUCCESS;
73 }
74 WifiDriverClientDeinit();
75 ClearIWiFiList();
76 g_wifiIsStarted = false;
77 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
78 return HDF_SUCCESS;
79 }
80
GetSupportFeatureInner(uint8_t * supType,uint32_t size)81 static int32_t GetSupportFeatureInner(uint8_t *supType, uint32_t size)
82 {
83 if (supType == NULL || size <= PROTOCOL_80211_IFTYPE_NUM) {
84 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
85 return HDF_ERR_INVALID_PARAM;
86 }
87 return HalCmdGetSupportType(supType);
88 }
89
GetSupportComboInner(uint64_t * combo,uint32_t size)90 static int32_t GetSupportComboInner(uint64_t *combo, uint32_t size)
91 {
92 if (combo == NULL) {
93 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
94 return HDF_ERR_INVALID_PARAM;
95 }
96 return HalCmdGetSupportCombo(combo, size);
97 }
98
InitFeatureByType(int32_t type,struct IWiFiBaseFeature ** ifeature)99 static int32_t InitFeatureByType(int32_t type, struct IWiFiBaseFeature **ifeature)
100 {
101 int32_t ret;
102
103 switch (type) {
104 case PROTOCOL_80211_IFTYPE_AP:
105 *ifeature = (struct IWiFiBaseFeature *)malloc(sizeof(struct IWiFiAp));
106 if (*ifeature == NULL) {
107 HDF_LOGE("%s: malloc failed, line: %d", __FUNCTION__, __LINE__);
108 return HDF_FAILURE;
109 }
110 (void)memset_s(*ifeature, sizeof(struct IWiFiAp), 0, sizeof(struct IWiFiAp));
111 ret = InitApFeature((struct IWiFiAp **)ifeature);
112 break;
113 case PROTOCOL_80211_IFTYPE_STATION:
114 *ifeature = (struct IWiFiBaseFeature *)malloc(sizeof(struct IWiFiSta));
115 if (*ifeature == NULL) {
116 HDF_LOGE("%s: malloc failed, line: %d", __FUNCTION__, __LINE__);
117 return HDF_FAILURE;
118 }
119 (void)memset_s(*ifeature, sizeof(struct IWiFiSta), 0, sizeof(struct IWiFiSta));
120 ret = InitStaFeature((struct IWiFiSta **)ifeature);
121 break;
122 case PROTOCOL_80211_IFTYPE_P2P_DEVICE:
123 *ifeature = (struct IWiFiBaseFeature *)malloc(sizeof(struct IWiFiP2p));
124 if (*ifeature == NULL) {
125 HDF_LOGE("%s: malloc failed, line: %d", __FUNCTION__, __LINE__);
126 return HDF_FAILURE;
127 }
128 (void)memset_s(*ifeature, sizeof(struct IWiFiP2p), 0, sizeof(struct IWiFiP2p));
129 ret = InitP2pFeature((struct IWiFiP2p **)ifeature);
130 break;
131 default:
132 HDF_LOGE("%s: type not support, line: %d", __FUNCTION__, __LINE__);
133 return HDF_FAILURE;
134 }
135 if (ret != HDF_SUCCESS) {
136 free(*ifeature);
137 *ifeature = NULL;
138 }
139 return ret;
140 }
141
FindValidNetwork(int32_t type,struct IWiFiBaseFeature ** feature)142 static int32_t FindValidNetwork(int32_t type, struct IWiFiBaseFeature **feature)
143 {
144 struct DListHead *networkHead = GetNetworkHead();
145 struct IWiFiList *networkNode = NULL;
146
147 DLIST_FOR_EACH_ENTRY(networkNode, networkHead, struct IWiFiList, entry) {
148 if (networkNode == NULL) {
149 HDF_LOGE("%s: networkNode is NULL, line: %d", __FUNCTION__, __LINE__);
150 break;
151 }
152 if (networkNode->ifeature != NULL && networkNode->ifeature->type == type) {
153 HDF_LOGI("%s: feature is existed. type: %d", __FUNCTION__, type);
154 if (memcpy_s((*feature)->ifName, IFNAME_MAX_LEN, networkNode->ifName, strlen(networkNode->ifName)) != EOK) {
155 HDF_LOGE("%s: memcpy_s failed, line: %d", __FUNCTION__, __LINE__);
156 return HDF_FAILURE;
157 }
158 (*feature)->type = type;
159 return HDF_SUCCESS;
160 }
161 if (networkNode->ifeature == NULL && networkNode->supportMode[type] == 1) {
162 if (memcpy_s((*feature)->ifName, IFNAME_MAX_LEN, networkNode->ifName, strlen(networkNode->ifName)) != EOK) {
163 HDF_LOGE("%s: memcpy_s failed, line: %d", __FUNCTION__, __LINE__);
164 return HDF_FAILURE;
165 }
166 (*feature)->type = type;
167 networkNode->ifeature = *feature;
168 return HDF_SUCCESS;
169 }
170 }
171 HDF_LOGE("%s: cannot find available network, line: %d", __FUNCTION__, __LINE__);
172 return HDF_FAILURE;
173 }
174
CreateFeatureInner(int32_t type,struct IWiFiBaseFeature ** ifeature)175 static int32_t CreateFeatureInner(int32_t type, struct IWiFiBaseFeature **ifeature)
176 {
177 int32_t ret;
178
179 if (ifeature == NULL) {
180 HDF_LOGE("%s: ifeature is null, line: %d", __FUNCTION__, __LINE__);
181 return HDF_FAILURE;
182 }
183 ret = InitFeatureByType(type, ifeature);
184 if (ret != HDF_SUCCESS) {
185 HDF_LOGE("%s: init feature failed, line: %d, error no: %d", __FUNCTION__, __LINE__, ret);
186 return ret;
187 }
188
189 ret = FindValidNetwork(type, ifeature);
190 if (ret != HDF_SUCCESS) {
191 HDF_LOGE("%s: create feature failed, line: %d, error no: %d", __FUNCTION__, __LINE__, ret);
192 if (*ifeature != NULL) {
193 free(*ifeature);
194 *ifeature = NULL;
195 }
196 return ret;
197 }
198 return HDF_SUCCESS;
199 }
200
DestroyFeatureInner(struct IWiFiBaseFeature * ifeature)201 static int32_t DestroyFeatureInner(struct IWiFiBaseFeature *ifeature)
202 {
203 struct DListHead *networkHead = GetNetworkHead();
204 struct IWiFiList *networkNode = NULL;
205
206 if (ifeature == NULL) {
207 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
208 return HDF_ERR_INVALID_PARAM;
209 }
210
211 DLIST_FOR_EACH_ENTRY(networkNode, networkHead, struct IWiFiList, entry) {
212 if (strcmp(networkNode->ifName, ifeature->ifName) == HDF_SUCCESS) {
213 free(ifeature);
214 networkNode->ifeature = NULL;
215 return HDF_SUCCESS;
216 }
217 }
218 HDF_LOGE("%s: cannot find feature to destroy, line: %d", __FUNCTION__, __LINE__);
219 return HDF_FAILURE;
220 }
221
RegisterEventCallbackInner(OnReceiveFunc onRecFunc,const char * ifName)222 static int32_t RegisterEventCallbackInner(OnReceiveFunc onRecFunc, const char *ifName)
223 {
224 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
225 if (onRecFunc == NULL || ifName == NULL) {
226 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
227 return HDF_ERR_INVALID_PARAM;
228 }
229 if (WifiRegisterEventCallback(onRecFunc, WIFI_KERNEL_TO_HAL_CLIENT, ifName) != HDF_SUCCESS) {
230 HDF_LOGE("%s: callback function has been registered, line: %d", __FUNCTION__, __LINE__);
231 return HDF_FAILURE;
232 }
233 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
234 return HDF_SUCCESS;
235 }
236
UnregisterEventCallbackInner(OnReceiveFunc onRecFunc,const char * ifName)237 static int32_t UnregisterEventCallbackInner(OnReceiveFunc onRecFunc, const char *ifName)
238 {
239 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
240 if (onRecFunc == NULL || ifName == NULL) {
241 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
242 return HDF_ERR_INVALID_PARAM;
243 }
244 WifiUnregisterEventCallback(onRecFunc, WIFI_KERNEL_TO_HAL_CLIENT, ifName);
245 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
246 return HDF_SUCCESS;
247 }
248
RegisterHid2dCallbackInner(Hid2dCallback func,const char * ifName)249 static int32_t RegisterHid2dCallbackInner(Hid2dCallback func, const char *ifName)
250 {
251 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
252 int32_t ret;
253 if (func == NULL || ifName == NULL) {
254 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
255 return HDF_ERR_INVALID_PARAM;
256 }
257 ret = WifiRegisterHid2dCallback(func, ifName);
258 if (ret != HDF_SUCCESS) {
259 HDF_LOGE("%s: register hid2d callback fail!", __FUNCTION__);
260 }
261 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
262 return ret;
263 }
264
UnregisterHid2dCallbackInner(Hid2dCallback func,const char * ifName)265 static int32_t UnregisterHid2dCallbackInner(Hid2dCallback func, const char *ifName)
266 {
267 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
268 if (func == NULL || ifName == NULL) {
269 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
270 return HDF_ERR_INVALID_PARAM;
271 }
272 WifiUnregisterHid2dCallback(func, ifName);
273 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
274 return HDF_SUCCESS;
275 }
276
ResetDriverInner(uint8_t chipId,const char * ifName)277 static int32_t ResetDriverInner(uint8_t chipId, const char *ifName)
278 {
279 if (ifName == NULL || chipId >= MAX_WLAN_DEVICE) {
280 HDF_LOGE("%s: input parameter invalid, line: %d, chipId = %u", __FUNCTION__, __LINE__, chipId);
281 return HDF_ERR_INVALID_PARAM;
282 }
283 return HalCmdSetResetDriver(chipId, ifName);
284 }
285
GetNetDevInfoInner(struct NetDeviceInfoResult * netDeviceInfoResult)286 static int32_t GetNetDevInfoInner(struct NetDeviceInfoResult *netDeviceInfoResult)
287 {
288 if (netDeviceInfoResult == NULL) {
289 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
290 return HDF_ERR_INVALID_PARAM;
291 }
292 return GetNetDeviceInfo(netDeviceInfoResult);
293 }
294
GetPowerModeInner(const char * ifName,uint8_t * mode)295 static int32_t GetPowerModeInner(const char *ifName, uint8_t *mode)
296 {
297 if (ifName == NULL || mode == NULL) {
298 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
299 return HDF_ERR_INVALID_PARAM;
300 }
301
302 return GetCurrentPowerMode(ifName, mode);
303 }
304
SetPowerModeInner(const char * ifName,uint8_t mode)305 static int32_t SetPowerModeInner(const char *ifName, uint8_t mode)
306 {
307 if (ifName == NULL || mode >= WIFI_POWER_MODE_NUM) {
308 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
309 return HDF_ERR_INVALID_PARAM;
310 }
311 return SetPowerMode(ifName, mode);
312 }
313
StartChannelMeasInner(const char * ifName,const struct MeasParam * measParam)314 static int32_t StartChannelMeasInner(const char *ifName, const struct MeasParam *measParam)
315 {
316 if (ifName == NULL || measParam == NULL || measParam->channelId < 0) {
317 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
318 return HDF_ERR_INVALID_PARAM;
319 }
320 return StartChannelMeas(ifName, measParam);
321 }
322
GetChannelMeasResultInner(const char * ifName,struct MeasResult * measResult)323 static int32_t GetChannelMeasResultInner(const char *ifName, struct MeasResult *measResult)
324 {
325 if (ifName == NULL || measResult == NULL) {
326 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
327 return HDF_ERR_INVALID_PARAM;
328 }
329 return HDF_ERR_NOT_SUPPORT;
330 }
331
SetProjectionScreenParamInner(const char * ifName,const ProjectionScreenParam * param)332 static int32_t SetProjectionScreenParamInner(const char *ifName, const ProjectionScreenParam *param)
333 {
334 if (ifName == NULL || param == NULL) {
335 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
336 return HDF_ERR_INVALID_PARAM;
337 }
338 return SetProjectionScreenParam(ifName, param);
339 }
340
SendCmdIoctlInner(const char * ifName,int32_t cmdId,const int8_t * paramBuf,uint32_t paramBufLen)341 static int32_t SendCmdIoctlInner(const char *ifName, int32_t cmdId, const int8_t *paramBuf, uint32_t paramBufLen)
342 {
343 if (ifName == NULL || paramBuf == NULL) {
344 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
345 return HDF_ERR_INVALID_PARAM;
346 }
347 return SendCmdIoctl(ifName, cmdId, paramBuf, paramBufLen);
348 }
349
GetStationInfoInner(const char * ifName,StationInfo * info,const uint8_t * mac,uint32_t macLen)350 static int32_t GetStationInfoInner(const char *ifName, StationInfo *info, const uint8_t *mac, uint32_t macLen)
351 {
352 if (ifName == NULL || info == NULL || mac == NULL || macLen != ETH_ADDR_LEN) {
353 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
354 return HDF_ERR_INVALID_PARAM;
355 }
356 return GetStationInfo(ifName, info, mac, macLen);
357 }
358
SendActionFrameInner(const char * ifName,uint32_t freq,const uint8_t * frameData,uint32_t frameDataLen)359 static int32_t SendActionFrameInner(const char *ifName, uint32_t freq, const uint8_t *frameData, uint32_t frameDataLen)
360 {
361 if (ifName == NULL || freq == 0 || frameData == NULL || frameDataLen == 0) {
362 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
363 return HDF_ERR_INVALID_PARAM;
364 }
365 return WifiSendActionFrame(ifName, freq, frameData, frameDataLen);
366 }
367
RegisterActionFrameReceiverInner(const char * ifName,const uint8_t * match,uint32_t matchLen)368 static int32_t RegisterActionFrameReceiverInner(const char *ifName, const uint8_t *match, uint32_t matchLen)
369 {
370 if (ifName == NULL || match == NULL || matchLen == 0) {
371 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
372 return HDF_ERR_INVALID_PARAM;
373 }
374 return WifiRegisterActionFrameReceiver(ifName, match, matchLen);
375 }
376
SetPowerSaveModeInner(const char * ifName,int32_t frequency,int32_t mode)377 static int32_t SetPowerSaveModeInner(const char *ifName, int32_t frequency, int32_t mode)
378 {
379 if (ifName == NULL) {
380 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
381 return HDF_ERR_INVALID_PARAM;
382 }
383 return WifiSetPowerSaveMode(ifName, frequency, mode);
384 }
385
SetPowerSaveMode(const char * ifName,int32_t frequency,int32_t mode)386 static int32_t SetPowerSaveMode(const char *ifName, int32_t frequency, int32_t mode)
387 {
388 HalMutexLock();
389 int32_t ret = SetPowerSaveModeInner(ifName, frequency, mode);
390 HalMutexUnlock();
391 return ret;
392 }
393
SetDpiMarkRuleInner(int32_t uid,int32_t protocol,int32_t enable)394 static int32_t SetDpiMarkRuleInner(int32_t uid, int32_t protocol, int32_t enable)
395 {
396 return WifiSetDpiMarkRule(uid, protocol, enable);
397 }
398
SetDpiMarkRule(int32_t uid,int32_t protocol,int32_t enable)399 static int32_t SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable)
400 {
401 HalMutexLock();
402 int32_t ret = SetDpiMarkRuleInner(uid, protocol, enable);
403 HalMutexUnlock();
404 return ret;
405 }
406
Start(struct IWiFi * iwifi)407 static int32_t Start(struct IWiFi *iwifi)
408 {
409 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
410 HalMutexLock();
411 int32_t ret = StartInner(iwifi);
412 HalMutexUnlock();
413 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
414 return ret;
415 }
416
Stop(struct IWiFi * iwifi)417 static int32_t Stop(struct IWiFi *iwifi)
418 {
419 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
420 HalMutexLock();
421 int32_t ret = StopInner(iwifi);
422 HalMutexUnlock();
423 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
424 return ret;
425 }
426
GetSupportFeature(uint8_t * supType,uint32_t size)427 static int32_t GetSupportFeature(uint8_t *supType, uint32_t size)
428 {
429 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
430 HalMutexLock();
431 int32_t ret = GetSupportFeatureInner(supType, size);
432 HalMutexUnlock();
433 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
434 return ret;
435 }
436
GetSupportCombo(uint64_t * combo,uint32_t size)437 static int32_t GetSupportCombo(uint64_t *combo, uint32_t size)
438 {
439 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
440 HalMutexLock();
441 int32_t ret = GetSupportComboInner(combo, size);
442 HalMutexUnlock();
443 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
444 return ret;
445 }
446
CreateFeature(int32_t type,struct IWiFiBaseFeature ** ifeature)447 static int32_t CreateFeature(int32_t type, struct IWiFiBaseFeature **ifeature)
448 {
449 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
450 HalMutexLock();
451 int32_t ret = CreateFeatureInner(type, ifeature);
452 HalMutexUnlock();
453 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
454 return ret;
455 }
456
GetFeatureByIfName(const char * ifName,struct IWiFiBaseFeature ** ifeature)457 static int32_t GetFeatureByIfName(const char *ifName, struct IWiFiBaseFeature **ifeature)
458 {
459 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
460 HalMutexLock();
461 int32_t ret = HalCmdGetFeatureByIfName(ifName, ifeature);
462 HalMutexUnlock();
463 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
464 return ret;
465 }
466
DestroyFeature(struct IWiFiBaseFeature * ifeature)467 static int32_t DestroyFeature(struct IWiFiBaseFeature *ifeature)
468 {
469 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
470 HalMutexLock();
471 int32_t ret = DestroyFeatureInner(ifeature);
472 HalMutexUnlock();
473 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
474 return ret;
475 }
476
HalRegisterEventCallback(OnReceiveFunc onRecFunc,const char * ifName)477 static int32_t HalRegisterEventCallback(OnReceiveFunc onRecFunc, const char *ifName)
478 {
479 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
480 HalMutexLock();
481 int32_t ret = RegisterEventCallbackInner(onRecFunc, ifName);
482 HalMutexUnlock();
483 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
484 return ret;
485 }
486
HalUnregisterEventCallback(OnReceiveFunc onRecFunc,const char * ifName)487 static int32_t HalUnregisterEventCallback(OnReceiveFunc onRecFunc, const char *ifName)
488 {
489 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
490 HalMutexLock();
491 int32_t ret = UnregisterEventCallbackInner(onRecFunc, ifName);
492 HalMutexUnlock();
493 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
494 return ret;
495 }
496
HalRegisterHid2dCallback(Hid2dCallback func,const char * ifName)497 static int32_t HalRegisterHid2dCallback(Hid2dCallback func, const char *ifName)
498 {
499 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
500 HalMutexLock();
501 int32_t ret = RegisterHid2dCallbackInner(func, ifName);
502 HalMutexUnlock();
503 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
504 return ret;
505 }
506
HalUnregisterHid2dCallback(Hid2dCallback func,const char * ifName)507 static int32_t HalUnregisterHid2dCallback(Hid2dCallback func, const char *ifName)
508 {
509 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
510 HalMutexLock();
511 int32_t ret = UnregisterHid2dCallbackInner(func, ifName);
512 HalMutexUnlock();
513 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
514 return ret;
515 }
516
ResetDriver(const uint8_t chipId,const char * ifName)517 static int32_t ResetDriver(const uint8_t chipId, const char *ifName)
518 {
519 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
520 HalMutexLock();
521 int32_t ret = ResetDriverInner(chipId, ifName);
522 HalMutexUnlock();
523 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
524 return ret;
525 }
526
GetNetDevInfo(struct NetDeviceInfoResult * netDeviceInfoResult)527 static int32_t GetNetDevInfo(struct NetDeviceInfoResult *netDeviceInfoResult)
528 {
529 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
530 HalMutexLock();
531 int32_t ret = GetNetDevInfoInner(netDeviceInfoResult);
532 HalMutexUnlock();
533 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
534 return ret;
535 }
536
WifiGetPowerMode(const char * ifName,uint8_t * mode)537 static int32_t WifiGetPowerMode(const char *ifName, uint8_t *mode)
538 {
539 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
540 HalMutexLock();
541 int32_t ret = GetPowerModeInner(ifName, mode);
542 HalMutexUnlock();
543 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
544 return ret;
545 }
546
WifiSetPowerMode(const char * ifName,uint8_t mode)547 static int32_t WifiSetPowerMode(const char *ifName, uint8_t mode)
548 {
549 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
550 HalMutexLock();
551 int32_t ret = SetPowerModeInner(ifName, mode);
552 HalMutexUnlock();
553 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
554 return ret;
555 }
556
WifiStartChannelMeas(const char * ifName,const struct MeasParam * measParam)557 static int32_t WifiStartChannelMeas(const char *ifName, const struct MeasParam *measParam)
558 {
559 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
560 HalMutexLock();
561 int32_t ret = StartChannelMeasInner(ifName, measParam);
562 HalMutexUnlock();
563 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
564 return ret;
565 }
566
WifiGetChannelMeasResult(const char * ifName,struct MeasResult * measResult)567 static int32_t WifiGetChannelMeasResult(const char *ifName, struct MeasResult *measResult)
568 {
569 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
570 HalMutexLock();
571 int32_t ret = GetChannelMeasResultInner(ifName, measResult);
572 HalMutexUnlock();
573 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
574 return ret;
575 }
576
WifiSetProjectionScreenParam(const char * ifName,const ProjectionScreenParam * param)577 static int32_t WifiSetProjectionScreenParam(const char *ifName, const ProjectionScreenParam *param)
578 {
579 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
580 HalMutexLock();
581 int32_t ret = SetProjectionScreenParamInner(ifName, param);
582 HalMutexUnlock();
583 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
584 return ret;
585 }
586
WifiSendCmdIoctl(const char * ifName,int32_t cmdId,const int8_t * paramBuf,uint32_t paramBufLen)587 static int32_t WifiSendCmdIoctl(const char *ifName, int32_t cmdId, const int8_t *paramBuf, uint32_t paramBufLen)
588 {
589 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
590 HalMutexLock();
591 int32_t ret = SendCmdIoctlInner(ifName, cmdId, paramBuf, paramBufLen);
592 HalMutexUnlock();
593 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
594 return ret;
595 }
596
WifiGetStationInfo(const char * ifName,StationInfo * info,const uint8_t * mac,uint32_t macLen)597 static int32_t WifiGetStationInfo(const char *ifName, StationInfo *info, const uint8_t *mac, uint32_t macLen)
598 {
599 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
600 HalMutexLock();
601 int32_t ret = GetStationInfoInner(ifName, info, mac, macLen);
602 HalMutexUnlock();
603 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
604 return ret;
605 }
606
SendActionFrame(const char * ifName,uint32_t freq,const uint8_t * frameData,uint32_t frameDataLen)607 static int32_t SendActionFrame(const char *ifName, uint32_t freq, const uint8_t *frameData, uint32_t frameDataLen)
608 {
609 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
610 HalMutexLock();
611 int32_t ret = SendActionFrameInner(ifName, freq, frameData, frameDataLen);
612 HalMutexUnlock();
613 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
614 return ret;
615 }
616
RegisterActionFrameReceiver(const char * ifName,const uint8_t * match,uint32_t matchLen)617 static int32_t RegisterActionFrameReceiver(const char *ifName, const uint8_t *match, uint32_t matchLen)
618 {
619 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
620 HalMutexLock();
621 int32_t ret = RegisterActionFrameReceiverInner(ifName, match, matchLen);
622 HalMutexUnlock();
623 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
624 return ret;
625 }
626
WifiConstruct(struct IWiFi ** wifiInstance)627 int32_t WifiConstruct(struct IWiFi **wifiInstance)
628 {
629 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
630 static bool isInited = false;
631 static struct IWiFi singleWifiInstance;
632
633 if (!isInited) {
634 if (HalMutexInit() != HDF_SUCCESS) {
635 HDF_LOGE("%s: HalMutexInit failed, line: %d", __FUNCTION__, __LINE__);
636 return HDF_FAILURE;
637 }
638
639 singleWifiInstance.start = Start;
640 singleWifiInstance.stop = Stop;
641 singleWifiInstance.getSupportFeature = GetSupportFeature;
642 singleWifiInstance.getSupportCombo = GetSupportCombo;
643 singleWifiInstance.createFeature = CreateFeature;
644 singleWifiInstance.getFeatureByIfName = GetFeatureByIfName;
645 singleWifiInstance.destroyFeature = DestroyFeature;
646 singleWifiInstance.registerEventCallback = HalRegisterEventCallback;
647 singleWifiInstance.unregisterEventCallback = HalUnregisterEventCallback;
648 singleWifiInstance.resetDriver = ResetDriver;
649 singleWifiInstance.getNetDevInfo = GetNetDevInfo;
650 singleWifiInstance.getPowerMode = WifiGetPowerMode;
651 singleWifiInstance.setPowerMode = WifiSetPowerMode;
652 singleWifiInstance.startChannelMeas = WifiStartChannelMeas;
653 singleWifiInstance.getChannelMeasResult = WifiGetChannelMeasResult;
654 singleWifiInstance.setProjectionScreenParam = WifiSetProjectionScreenParam;
655 singleWifiInstance.sendCmdIoctl = WifiSendCmdIoctl;
656 singleWifiInstance.registerHid2dCallback = HalRegisterHid2dCallback;
657 singleWifiInstance.unregisterHid2dCallback = HalUnregisterHid2dCallback;
658 singleWifiInstance.getStationInfo = WifiGetStationInfo;
659 singleWifiInstance.sendActionFrame = SendActionFrame;
660 singleWifiInstance.registerActionFrameReceiver = RegisterActionFrameReceiver;
661 singleWifiInstance.setPowerSaveMode = SetPowerSaveMode;
662 singleWifiInstance.setDpiMarkRule = SetDpiMarkRule;
663 InitIWiFiList();
664 isInited = true;
665 }
666 (*wifiInstance) = &singleWifiInstance;
667 HDF_LOGI("hal exit %{public}s, isInited:%{public}d", __FUNCTION__, isInited);
668 return HDF_SUCCESS;
669 }
670
WifiDestruct(struct IWiFi ** wifiInstance)671 int32_t WifiDestruct(struct IWiFi **wifiInstance)
672 {
673 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
674 if (wifiInstance == NULL) {
675 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
676 return HDF_ERR_INVALID_PARAM;
677 }
678 *wifiInstance = NULL;
679 if (HalMutexDestroy() != HDF_SUCCESS) {
680 HDF_LOGE("%s: HalMutexDestroy failed, line: %d", __FUNCTION__, __LINE__);
681 return HDF_FAILURE;
682 }
683 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
684 return HDF_SUCCESS;
685 }
686
687 #ifdef __cplusplus
688 #if __cplusplus
689 }
690 #endif
691 #endif
692