1 /*
2 * Copyright (c) 2024 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_ap_iface.h"
17 #include <hdf_log.h>
18
19 namespace OHOS {
20 namespace HDI {
21 namespace Wlan {
22 namespace Chip {
23 namespace V1_0 {
WifiApIface(const std::string & ifname,const std::vector<std::string> & instances,const std::weak_ptr<WifiVendorHal> vendorHal,const std::weak_ptr<IfaceUtil> ifaceUtil)24 WifiApIface::WifiApIface(
25 const std::string& ifname, const std::vector<std::string>& instances,
26 const std::weak_ptr<WifiVendorHal> vendorHal,
27 const std::weak_ptr<IfaceUtil> ifaceUtil)
28 : ifname_(ifname),
29 instances_(instances),
30 vendorHal_(vendorHal),
31 ifaceUtil_(ifaceUtil),
32 isValid_(true) {}
33
Invalidate()34 void WifiApIface::Invalidate()
35 {
36 vendorHal_.reset();
37 isValid_ = false;
38 }
39
IsValid()40 bool WifiApIface::IsValid()
41 {
42 return isValid_;
43 }
44
GetName()45 std::string WifiApIface::GetName()
46 {
47 return ifname_;
48 }
49
RemoveInstance(std::string instance)50 void WifiApIface::RemoveInstance(std::string instance)
51 {
52 instances_.erase(std::remove(instances_.begin(), instances_.end(), instance), instances_.end());
53 }
54
GetIfaceType(IfaceType & type)55 int32_t WifiApIface::GetIfaceType(IfaceType& type)
56 {
57 type = IfaceType::AP;
58 return HDF_SUCCESS;
59 }
60
GetIfaceName(std::string & name)61 int32_t WifiApIface::GetIfaceName(std::string& name)
62 {
63 name = ifname_;
64 return HDF_SUCCESS;
65 }
66
GetSupportFreqs(int band,std::vector<uint32_t> & frequencies)67 int32_t WifiApIface::GetSupportFreqs(int band, std::vector<uint32_t>& frequencies)
68 {
69 WifiError status;
70 std::vector<uint32_t> validFrequencies;
71 std::tie(status, validFrequencies) = vendorHal_.lock()->GetValidFrequenciesForBand(
72 instances_.size() > 0 ? instances_[0] : ifname_, band);
73 frequencies = validFrequencies;
74 if (status == HAL_SUCCESS) {
75 return HDF_SUCCESS;
76 }
77 return HDF_FAILURE;
78 }
79
GetIfaceCap(uint32_t & capabilities)80 int32_t WifiApIface::GetIfaceCap(uint32_t& capabilities)
81 {
82 return HDF_ERR_NOT_SUPPORT;
83 }
84
SetMacAddress(const std::string & mac)85 int32_t WifiApIface::SetMacAddress(const std::string& mac)
86 {
87 bool status = ifaceUtil_.lock()->SetMacAddress(ifname_, mac);
88 if (!status) {
89 return HDF_FAILURE;
90 }
91 return HDF_SUCCESS;
92 }
93
SetCountryCode(const std::string & code)94 int32_t WifiApIface::SetCountryCode(const std::string& code)
95 {
96 WifiError status = vendorHal_.lock()->SetCountryCode(ifname_, code);
97 if (status != HAL_SUCCESS) {
98 return HDF_FAILURE;
99 }
100 return HDF_SUCCESS;
101 }
102
GetPowerMode(int32_t & powerMode)103 int32_t WifiApIface::GetPowerMode(int32_t& powerMode)
104 {
105 WifiError status;
106 int mode;
107
108 std::tie(status, mode) = vendorHal_.lock()->GetPowerMode(ifname_);
109 if (status == HAL_SUCCESS) {
110 powerMode = mode;
111 return HDF_SUCCESS;
112 }
113 return HDF_FAILURE;
114 }
115
SetPowerMode(int32_t powerMode)116 int32_t WifiApIface::SetPowerMode(int32_t powerMode)
117 {
118 WifiError status = vendorHal_.lock()->SetPowerMode(ifname_, powerMode);
119 if (status == HAL_SUCCESS) {
120 return HDF_SUCCESS;
121 }
122 return HDF_FAILURE;
123 }
124
RegisterChipIfaceCallBack(const sptr<IChipIfaceCallback> & chipIfaceCallback)125 int32_t WifiApIface::RegisterChipIfaceCallBack(const sptr<IChipIfaceCallback>& chipIfaceCallback)
126 {
127 return HDF_ERR_NOT_SUPPORT;
128 }
129
UnRegisterChipIfaceCallBack(const sptr<IChipIfaceCallback> & chipIfaceCallback)130 int32_t WifiApIface::UnRegisterChipIfaceCallBack(const sptr<IChipIfaceCallback>& chipIfaceCallback)
131 {
132 return HDF_ERR_NOT_SUPPORT;
133 }
134
StartScan(const ScanParams & scanParam)135 int32_t WifiApIface::StartScan(const ScanParams& scanParam)
136 {
137 return HDF_ERR_NOT_SUPPORT;
138 }
139
GetScanInfos(std::vector<ScanResultsInfo> & scanResultsInfo)140 int32_t WifiApIface::GetScanInfos(std::vector<ScanResultsInfo>& scanResultsInfo)
141 {
142 return HDF_ERR_NOT_SUPPORT;
143 }
144
StartPnoScan(const PnoScanParams & pnoParams)145 int32_t WifiApIface::StartPnoScan(const PnoScanParams& pnoParams)
146 {
147 return HDF_ERR_NOT_SUPPORT;
148 }
149
StopPnoScan()150 int32_t WifiApIface::StopPnoScan()
151 {
152 return HDF_ERR_NOT_SUPPORT;
153 }
154
GetSignalPollInfo(SignalPollResult & signalPollResult)155 int32_t WifiApIface::GetSignalPollInfo(SignalPollResult& signalPollResult)
156 {
157 return HDF_ERR_NOT_SUPPORT;
158 }
159
EnablePowerMode(int32_t mode)160 int32_t WifiApIface::EnablePowerMode(int32_t mode)
161 {
162 return HDF_ERR_NOT_SUPPORT;
163 }
164
SetDpiMarkRule(int32_t uid,int32_t protocol,int32_t enable)165 int32_t WifiApIface::SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable)
166 {
167 return HDF_ERR_NOT_SUPPORT;
168 }
169
SetTxPower(int32_t power)170 int32_t WifiApIface::SetTxPower(int32_t power)
171 {
172 {
173 WifiError status = vendorHal_.lock()->SetTxPower(ifname_, power);
174 return status;
175 }
176 }
177
SetIfaceState(bool state)178 int32_t WifiApIface::SetIfaceState(bool state)
179 {
180 if (ifaceUtil_.lock()->SetUpState(ifname_, state)) {
181 return HDF_SUCCESS;
182 }
183 return HDF_FAILURE;
184 }
185 }
186 }
187 }
188 }
189 }