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 *feature = networkNode->ifeature;
155 return HDF_SUCCESS;
156 }
157 if (networkNode->ifeature == NULL && networkNode->supportMode[type] == 1) {
158 if (memcpy_s((*feature)->ifName, IFNAME_MAX_LEN, networkNode->ifName, strlen(networkNode->ifName)) != EOK) {
159 HDF_LOGE("%s: memcpy_s failed, line: %d", __FUNCTION__, __LINE__);
160 return HDF_FAILURE;
161 }
162 (*feature)->type = type;
163 networkNode->ifeature = *feature;
164 return HDF_SUCCESS;
165 }
166 }
167 HDF_LOGE("%s: cannot find available network, line: %d", __FUNCTION__, __LINE__);
168 return HDF_FAILURE;
169 }
170
CreateFeatureInner(int32_t type,struct IWiFiBaseFeature ** ifeature)171 static int32_t CreateFeatureInner(int32_t type, struct IWiFiBaseFeature **ifeature)
172 {
173 int32_t ret;
174
175 if (ifeature == NULL) {
176 HDF_LOGE("%s: ifeature is null, line: %d", __FUNCTION__, __LINE__);
177 return HDF_FAILURE;
178 }
179 ret = InitFeatureByType(type, ifeature);
180 if (ret != HDF_SUCCESS) {
181 HDF_LOGE("%s: init feature failed, line: %d, error no: %d", __FUNCTION__, __LINE__, ret);
182 return ret;
183 }
184
185 ret = FindValidNetwork(type, ifeature);
186 if (ret != HDF_SUCCESS) {
187 HDF_LOGE("%s: create feature failed, line: %d, error no: %d", __FUNCTION__, __LINE__, ret);
188 if (*ifeature != NULL) {
189 free(*ifeature);
190 *ifeature = NULL;
191 }
192 return ret;
193 }
194 return HDF_SUCCESS;
195 }
196
DestroyFeatureInner(struct IWiFiBaseFeature * ifeature)197 static int32_t DestroyFeatureInner(struct IWiFiBaseFeature *ifeature)
198 {
199 struct DListHead *networkHead = GetNetworkHead();
200 struct IWiFiList *networkNode = NULL;
201
202 if (ifeature == NULL) {
203 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
204 return HDF_ERR_INVALID_PARAM;
205 }
206
207 DLIST_FOR_EACH_ENTRY(networkNode, networkHead, struct IWiFiList, entry) {
208 if (strcmp(networkNode->ifName, ifeature->ifName) == HDF_SUCCESS) {
209 free(ifeature);
210 networkNode->ifeature = NULL;
211 return HDF_SUCCESS;
212 }
213 }
214 HDF_LOGE("%s: cannot find feature to destroy, line: %d", __FUNCTION__, __LINE__);
215 return HDF_FAILURE;
216 }
217
RegisterEventCallbackInner(OnReceiveFunc onRecFunc,const char * ifName)218 static int32_t RegisterEventCallbackInner(OnReceiveFunc onRecFunc, const char *ifName)
219 {
220 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
221 if (onRecFunc == NULL || ifName == NULL) {
222 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
223 return HDF_ERR_INVALID_PARAM;
224 }
225 if (WifiRegisterEventCallback(onRecFunc, WIFI_KERNEL_TO_HAL_CLIENT, ifName) != HDF_SUCCESS) {
226 HDF_LOGE("%s: callback function has been registered, line: %d", __FUNCTION__, __LINE__);
227 return HDF_FAILURE;
228 }
229 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
230 return HDF_SUCCESS;
231 }
232
UnregisterEventCallbackInner(OnReceiveFunc onRecFunc,const char * ifName)233 static int32_t UnregisterEventCallbackInner(OnReceiveFunc onRecFunc, const char *ifName)
234 {
235 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
236 if (onRecFunc == NULL || ifName == NULL) {
237 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
238 return HDF_ERR_INVALID_PARAM;
239 }
240 WifiUnregisterEventCallback(onRecFunc, WIFI_KERNEL_TO_HAL_CLIENT, ifName);
241 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
242 return HDF_SUCCESS;
243 }
244
RegisterHid2dCallbackInner(Hid2dCallback func,const char * ifName)245 static int32_t RegisterHid2dCallbackInner(Hid2dCallback func, const char *ifName)
246 {
247 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
248 int32_t ret;
249 if (func == NULL || ifName == NULL) {
250 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
251 return HDF_ERR_INVALID_PARAM;
252 }
253 ret = WifiRegisterHid2dCallback(func, ifName);
254 if (ret != HDF_SUCCESS) {
255 HDF_LOGE("%s: register hid2d callback fail!", __FUNCTION__);
256 }
257 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
258 return ret;
259 }
260
UnregisterHid2dCallbackInner(Hid2dCallback func,const char * ifName)261 static int32_t UnregisterHid2dCallbackInner(Hid2dCallback func, const char *ifName)
262 {
263 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
264 if (func == NULL || ifName == NULL) {
265 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
266 return HDF_ERR_INVALID_PARAM;
267 }
268 WifiUnregisterHid2dCallback(func, ifName);
269 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
270 return HDF_SUCCESS;
271 }
272
ResetDriverInner(uint8_t chipId,const char * ifName)273 static int32_t ResetDriverInner(uint8_t chipId, const char *ifName)
274 {
275 if (ifName == NULL || chipId >= MAX_WLAN_DEVICE) {
276 HDF_LOGE("%s: input parameter invalid, line: %d, chipId = %d", __FUNCTION__, __LINE__, chipId);
277 return HDF_ERR_INVALID_PARAM;
278 }
279 return HalCmdSetResetDriver(chipId, ifName);
280 }
281
GetNetDevInfoInner(struct NetDeviceInfoResult * netDeviceInfoResult)282 static int32_t GetNetDevInfoInner(struct NetDeviceInfoResult *netDeviceInfoResult)
283 {
284 if (netDeviceInfoResult == NULL) {
285 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
286 return HDF_ERR_INVALID_PARAM;
287 }
288 return GetNetDeviceInfo(netDeviceInfoResult);
289 }
290
GetPowerModeInner(const char * ifName,uint8_t * mode)291 static int32_t GetPowerModeInner(const char *ifName, uint8_t *mode)
292 {
293 if (ifName == NULL || mode == NULL) {
294 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
295 return HDF_ERR_INVALID_PARAM;
296 }
297
298 return GetCurrentPowerMode(ifName, mode);
299 }
300
SetPowerModeInner(const char * ifName,uint8_t mode)301 static int32_t SetPowerModeInner(const char *ifName, uint8_t mode)
302 {
303 if (ifName == NULL || mode >= WIFI_POWER_MODE_NUM) {
304 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
305 return HDF_ERR_INVALID_PARAM;
306 }
307 return SetPowerMode(ifName, mode);
308 }
309
StartChannelMeasInner(const char * ifName,const struct MeasParam * measParam)310 static int32_t StartChannelMeasInner(const char *ifName, const struct MeasParam *measParam)
311 {
312 if (ifName == NULL || measParam == NULL) {
313 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
314 return HDF_ERR_INVALID_PARAM;
315 }
316 return StartChannelMeas(ifName, measParam);
317 }
318
GetChannelMeasResultInner(const char * ifName,struct MeasResult * measResult)319 static int32_t GetChannelMeasResultInner(const char *ifName, struct MeasResult *measResult)
320 {
321 if (ifName == NULL || measResult == NULL) {
322 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
323 return HDF_ERR_INVALID_PARAM;
324 }
325 return HDF_ERR_NOT_SUPPORT;
326 }
327
SetProjectionScreenParamInner(const char * ifName,const ProjectionScreenParam * param)328 static int32_t SetProjectionScreenParamInner(const char *ifName, const ProjectionScreenParam *param)
329 {
330 if (ifName == NULL || param == NULL) {
331 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
332 return HDF_ERR_INVALID_PARAM;
333 }
334 return SetProjectionScreenParam(ifName, param);
335 }
336
SendCmdIoctlInner(const char * ifName,int32_t cmdId,const int8_t * paramBuf,uint32_t paramBufLen)337 static int32_t SendCmdIoctlInner(const char *ifName, int32_t cmdId, const int8_t *paramBuf, uint32_t paramBufLen)
338 {
339 if (ifName == NULL || paramBuf == NULL) {
340 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
341 return HDF_ERR_INVALID_PARAM;
342 }
343 return SendCmdIoctl(ifName, cmdId, paramBuf, paramBufLen);
344 }
345
GetStationInfoInner(const char * ifName,StationInfo * info,const uint8_t * mac,uint32_t macLen)346 static int32_t GetStationInfoInner(const char *ifName, StationInfo *info, const uint8_t *mac, uint32_t macLen)
347 {
348 if (ifName == NULL || info == NULL || mac == NULL || macLen < ETH_ADDR_LEN) {
349 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
350 return HDF_ERR_INVALID_PARAM;
351 }
352 return GetStationInfo(ifName, info, mac, macLen);
353 }
354
SendActionFrameInner(const char * ifName,uint32_t freq,const uint8_t * frameData,uint32_t frameDataLen)355 static int32_t SendActionFrameInner(const char *ifName, uint32_t freq, const uint8_t *frameData, uint32_t frameDataLen)
356 {
357 if (ifName == NULL || freq == 0 || frameData == NULL || frameDataLen == 0) {
358 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
359 return HDF_ERR_INVALID_PARAM;
360 }
361 return WifiSendActionFrame(ifName, freq, frameData, frameDataLen);
362 }
363
RegisterActionFrameReceiverInner(const char * ifName,const uint8_t * match,uint32_t matchLen)364 static int32_t RegisterActionFrameReceiverInner(const char *ifName, const uint8_t *match, uint32_t matchLen)
365 {
366 if (ifName == NULL || match == NULL || matchLen == 0) {
367 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
368 return HDF_ERR_INVALID_PARAM;
369 }
370 return WifiRegisterActionFrameReceiver(ifName, match, matchLen);
371 }
372
Start(struct IWiFi * iwifi)373 static int32_t Start(struct IWiFi *iwifi)
374 {
375 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
376 HalMutexLock();
377 int32_t ret = StartInner(iwifi);
378 HalMutexUnlock();
379 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
380 return ret;
381 }
382
Stop(struct IWiFi * iwifi)383 static int32_t Stop(struct IWiFi *iwifi)
384 {
385 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
386 HalMutexLock();
387 int32_t ret = StopInner(iwifi);
388 HalMutexUnlock();
389 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
390 return ret;
391 }
392
GetSupportFeature(uint8_t * supType,uint32_t size)393 static int32_t GetSupportFeature(uint8_t *supType, uint32_t size)
394 {
395 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
396 HalMutexLock();
397 int32_t ret = GetSupportFeatureInner(supType, size);
398 HalMutexUnlock();
399 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
400 return ret;
401 }
402
GetSupportCombo(uint64_t * combo,uint32_t size)403 static int32_t GetSupportCombo(uint64_t *combo, uint32_t size)
404 {
405 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
406 HalMutexLock();
407 int32_t ret = GetSupportComboInner(combo, size);
408 HalMutexUnlock();
409 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
410 return ret;
411 }
412
CreateFeature(int32_t type,struct IWiFiBaseFeature ** ifeature)413 static int32_t CreateFeature(int32_t type, struct IWiFiBaseFeature **ifeature)
414 {
415 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
416 HalMutexLock();
417 int32_t ret = CreateFeatureInner(type, ifeature);
418 HalMutexUnlock();
419 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
420 return ret;
421 }
422
GetFeatureByIfName(const char * ifName,struct IWiFiBaseFeature ** ifeature)423 static int32_t GetFeatureByIfName(const char *ifName, struct IWiFiBaseFeature **ifeature)
424 {
425 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
426 HalMutexLock();
427 int32_t ret = HalCmdGetFeatureByIfName(ifName, ifeature);
428 HalMutexUnlock();
429 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
430 return ret;
431 }
432
DestroyFeature(struct IWiFiBaseFeature * ifeature)433 static int32_t DestroyFeature(struct IWiFiBaseFeature *ifeature)
434 {
435 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
436 HalMutexLock();
437 int32_t ret = DestroyFeatureInner(ifeature);
438 HalMutexUnlock();
439 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
440 return ret;
441 }
442
HalRegisterEventCallback(OnReceiveFunc onRecFunc,const char * ifName)443 static int32_t HalRegisterEventCallback(OnReceiveFunc onRecFunc, const char *ifName)
444 {
445 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
446 HalMutexLock();
447 int32_t ret = RegisterEventCallbackInner(onRecFunc, ifName);
448 HalMutexUnlock();
449 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
450 return ret;
451 }
452
HalUnregisterEventCallback(OnReceiveFunc onRecFunc,const char * ifName)453 static int32_t HalUnregisterEventCallback(OnReceiveFunc onRecFunc, const char *ifName)
454 {
455 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
456 HalMutexLock();
457 int32_t ret = UnregisterEventCallbackInner(onRecFunc, ifName);
458 HalMutexUnlock();
459 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
460 return ret;
461 }
462
HalRegisterHid2dCallback(Hid2dCallback func,const char * ifName)463 static int32_t HalRegisterHid2dCallback(Hid2dCallback func, const char *ifName)
464 {
465 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
466 HalMutexLock();
467 int32_t ret = RegisterHid2dCallbackInner(func, ifName);
468 HalMutexUnlock();
469 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
470 return ret;
471 }
472
HalUnregisterHid2dCallback(Hid2dCallback func,const char * ifName)473 static int32_t HalUnregisterHid2dCallback(Hid2dCallback func, const char *ifName)
474 {
475 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
476 HalMutexLock();
477 int32_t ret = UnregisterHid2dCallbackInner(func, ifName);
478 HalMutexUnlock();
479 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
480 return ret;
481 }
482
ResetDriver(const uint8_t chipId,const char * ifName)483 static int32_t ResetDriver(const uint8_t chipId, const char *ifName)
484 {
485 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
486 HalMutexLock();
487 int32_t ret = ResetDriverInner(chipId, ifName);
488 HalMutexUnlock();
489 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
490 return ret;
491 }
492
GetNetDevInfo(struct NetDeviceInfoResult * netDeviceInfoResult)493 static int32_t GetNetDevInfo(struct NetDeviceInfoResult *netDeviceInfoResult)
494 {
495 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
496 HalMutexLock();
497 int32_t ret = GetNetDevInfoInner(netDeviceInfoResult);
498 HalMutexUnlock();
499 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
500 return ret;
501 }
502
WifiGetPowerMode(const char * ifName,uint8_t * mode)503 static int32_t WifiGetPowerMode(const char *ifName, uint8_t *mode)
504 {
505 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
506 HalMutexLock();
507 int32_t ret = GetPowerModeInner(ifName, mode);
508 HalMutexUnlock();
509 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
510 return ret;
511 }
512
WifiSetPowerMode(const char * ifName,uint8_t mode)513 static int32_t WifiSetPowerMode(const char *ifName, uint8_t mode)
514 {
515 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
516 HalMutexLock();
517 int32_t ret = SetPowerModeInner(ifName, mode);
518 HalMutexUnlock();
519 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
520 return ret;
521 }
522
WifiStartChannelMeas(const char * ifName,const struct MeasParam * measParam)523 static int32_t WifiStartChannelMeas(const char *ifName, const struct MeasParam *measParam)
524 {
525 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
526 HalMutexLock();
527 int32_t ret = StartChannelMeasInner(ifName, measParam);
528 HalMutexUnlock();
529 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
530 return ret;
531 }
532
WifiGetChannelMeasResult(const char * ifName,struct MeasResult * measResult)533 static int32_t WifiGetChannelMeasResult(const char *ifName, struct MeasResult *measResult)
534 {
535 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
536 HalMutexLock();
537 int32_t ret = GetChannelMeasResultInner(ifName, measResult);
538 HalMutexUnlock();
539 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
540 return ret;
541 }
542
WifiSetProjectionScreenParam(const char * ifName,const ProjectionScreenParam * param)543 static int32_t WifiSetProjectionScreenParam(const char *ifName, const ProjectionScreenParam *param)
544 {
545 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
546 HalMutexLock();
547 int32_t ret = SetProjectionScreenParamInner(ifName, param);
548 HalMutexUnlock();
549 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
550 return ret;
551 }
552
WifiSendCmdIoctl(const char * ifName,int32_t cmdId,const int8_t * paramBuf,uint32_t paramBufLen)553 static int32_t WifiSendCmdIoctl(const char *ifName, int32_t cmdId, const int8_t *paramBuf, uint32_t paramBufLen)
554 {
555 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
556 HalMutexLock();
557 int32_t ret = SendCmdIoctlInner(ifName, cmdId, paramBuf, paramBufLen);
558 HalMutexUnlock();
559 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
560 return ret;
561 }
562
WifiGetStationInfo(const char * ifName,StationInfo * info,const uint8_t * mac,uint32_t macLen)563 static int32_t WifiGetStationInfo(const char *ifName, StationInfo *info, const uint8_t *mac, uint32_t macLen)
564 {
565 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
566 HalMutexLock();
567 int32_t ret = GetStationInfoInner(ifName, info, mac, macLen);
568 HalMutexUnlock();
569 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
570 return ret;
571 }
572
SendActionFrame(const char * ifName,uint32_t freq,const uint8_t * frameData,uint32_t frameDataLen)573 static int32_t SendActionFrame(const char *ifName, uint32_t freq, const uint8_t *frameData, uint32_t frameDataLen)
574 {
575 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
576 HalMutexLock();
577 int32_t ret = SendActionFrameInner(ifName, freq, frameData, frameDataLen);
578 HalMutexUnlock();
579 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
580 return ret;
581 }
582
RegisterActionFrameReceiver(const char * ifName,const uint8_t * match,uint32_t matchLen)583 static int32_t RegisterActionFrameReceiver(const char *ifName, const uint8_t *match, uint32_t matchLen)
584 {
585 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
586 HalMutexLock();
587 int32_t ret = RegisterActionFrameReceiverInner(ifName, match, matchLen);
588 HalMutexUnlock();
589 HDF_LOGI("hal exit %{public}s, ret:%{public}d", __FUNCTION__, ret);
590 return ret;
591 }
592
WifiConstruct(struct IWiFi ** wifiInstance)593 int32_t WifiConstruct(struct IWiFi **wifiInstance)
594 {
595 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
596 static bool isInited = false;
597 static struct IWiFi singleWifiInstance;
598
599 if (!isInited) {
600 if (HalMutexInit() != HDF_SUCCESS) {
601 HDF_LOGE("%s: HalMutexInit failed, line: %d", __FUNCTION__, __LINE__);
602 return HDF_FAILURE;
603 }
604
605 singleWifiInstance.start = Start;
606 singleWifiInstance.stop = Stop;
607 singleWifiInstance.getSupportFeature = GetSupportFeature;
608 singleWifiInstance.getSupportCombo = GetSupportCombo;
609 singleWifiInstance.createFeature = CreateFeature;
610 singleWifiInstance.getFeatureByIfName = GetFeatureByIfName;
611 singleWifiInstance.destroyFeature = DestroyFeature;
612 singleWifiInstance.registerEventCallback = HalRegisterEventCallback;
613 singleWifiInstance.unregisterEventCallback = HalUnregisterEventCallback;
614 singleWifiInstance.resetDriver = ResetDriver;
615 singleWifiInstance.getNetDevInfo = GetNetDevInfo;
616 singleWifiInstance.getPowerMode = WifiGetPowerMode;
617 singleWifiInstance.setPowerMode = WifiSetPowerMode;
618 singleWifiInstance.startChannelMeas = WifiStartChannelMeas;
619 singleWifiInstance.getChannelMeasResult = WifiGetChannelMeasResult;
620 singleWifiInstance.setProjectionScreenParam = WifiSetProjectionScreenParam;
621 singleWifiInstance.sendCmdIoctl = WifiSendCmdIoctl;
622 singleWifiInstance.registerHid2dCallback = HalRegisterHid2dCallback;
623 singleWifiInstance.unregisterHid2dCallback = HalUnregisterHid2dCallback;
624 singleWifiInstance.getStationInfo = WifiGetStationInfo;
625 singleWifiInstance.sendActionFrame = SendActionFrame;
626 singleWifiInstance.registerActionFrameReceiver = RegisterActionFrameReceiver;
627 InitIWiFiList();
628 isInited = true;
629 }
630 (*wifiInstance) = &singleWifiInstance;
631 HDF_LOGI("hal exit %{public}s, isInited:%{public}d", __FUNCTION__, isInited);
632 return HDF_SUCCESS;
633 }
634
WifiDestruct(struct IWiFi ** wifiInstance)635 int32_t WifiDestruct(struct IWiFi **wifiInstance)
636 {
637 HDF_LOGI("hal enter %{public}s", __FUNCTION__);
638 if (wifiInstance == NULL) {
639 HDF_LOGE("%s: input parameter invalid, line: %d", __FUNCTION__, __LINE__);
640 return HDF_ERR_INVALID_PARAM;
641 }
642 *wifiInstance = NULL;
643 if (HalMutexDestroy() != HDF_SUCCESS) {
644 HDF_LOGE("%s: HalMutexDestroy failed, line: %d", __FUNCTION__, __LINE__);
645 return HDF_FAILURE;
646 }
647 HDF_LOGI("hal exit %{public}s", __FUNCTION__);
648 return HDF_SUCCESS;
649 }
650
651 #ifdef __cplusplus
652 #if __cplusplus
653 }
654 #endif
655 #endif
656