1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /****************************************************************************** |
3 | * |
4 | * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. |
5 | * |
6 | ******************************************************************************/ |
7 | #include <drv_types.h> |
8 | #include <rtw_debug.h> |
9 | #include <hal_data.h> |
10 | |
11 | void rtw_hal_chip_configure(struct adapter *padapter) |
12 | { |
13 | if (padapter->HalFunc.intf_chip_configure) |
14 | padapter->HalFunc.intf_chip_configure(padapter); |
15 | } |
16 | |
17 | void rtw_hal_read_chip_info(struct adapter *padapter) |
18 | { |
19 | if (padapter->HalFunc.read_adapter_info) |
20 | padapter->HalFunc.read_adapter_info(padapter); |
21 | } |
22 | |
23 | void rtw_hal_read_chip_version(struct adapter *padapter) |
24 | { |
25 | if (padapter->HalFunc.read_chip_version) |
26 | padapter->HalFunc.read_chip_version(padapter); |
27 | } |
28 | |
29 | void rtw_hal_def_value_init(struct adapter *padapter) |
30 | { |
31 | if (is_primary_adapter(padapter)) |
32 | if (padapter->HalFunc.init_default_value) |
33 | padapter->HalFunc.init_default_value(padapter); |
34 | } |
35 | |
36 | void rtw_hal_free_data(struct adapter *padapter) |
37 | { |
38 | /* free HAL Data */ |
39 | rtw_hal_data_deinit(padapter); |
40 | |
41 | if (is_primary_adapter(padapter)) |
42 | if (padapter->HalFunc.free_hal_data) |
43 | padapter->HalFunc.free_hal_data(padapter); |
44 | } |
45 | |
46 | void rtw_hal_dm_init(struct adapter *padapter) |
47 | { |
48 | if (is_primary_adapter(padapter)) |
49 | if (padapter->HalFunc.dm_init) |
50 | padapter->HalFunc.dm_init(padapter); |
51 | } |
52 | |
53 | void rtw_hal_dm_deinit(struct adapter *padapter) |
54 | { |
55 | /* cancel dm timer */ |
56 | if (is_primary_adapter(padapter)) |
57 | if (padapter->HalFunc.dm_deinit) |
58 | padapter->HalFunc.dm_deinit(padapter); |
59 | } |
60 | |
61 | static void rtw_hal_init_opmode(struct adapter *padapter) |
62 | { |
63 | enum ndis_802_11_network_infrastructure networkType = Ndis802_11InfrastructureMax; |
64 | struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); |
65 | signed int fw_state; |
66 | |
67 | fw_state = get_fwstate(pmlmepriv); |
68 | |
69 | if (fw_state & WIFI_ADHOC_STATE) |
70 | networkType = Ndis802_11IBSS; |
71 | else if (fw_state & WIFI_STATION_STATE) |
72 | networkType = Ndis802_11Infrastructure; |
73 | else if (fw_state & WIFI_AP_STATE) |
74 | networkType = Ndis802_11APMode; |
75 | else |
76 | return; |
77 | |
78 | rtw_setopmode_cmd(padapter, networktype: networkType, enqueue: false); |
79 | } |
80 | |
81 | uint rtw_hal_init(struct adapter *padapter) |
82 | { |
83 | uint status; |
84 | struct dvobj_priv *dvobj = adapter_to_dvobj(padapter); |
85 | |
86 | status = padapter->HalFunc.hal_init(padapter); |
87 | |
88 | if (status == _SUCCESS) { |
89 | rtw_hal_init_opmode(padapter); |
90 | |
91 | dvobj->padapters->hw_init_completed = true; |
92 | |
93 | if (padapter->registrypriv.notch_filter == 1) |
94 | rtw_hal_notch_filter(adapter: padapter, enable: 1); |
95 | |
96 | rtw_hal_reset_security_engine(adapter: padapter); |
97 | |
98 | rtw_sec_restore_wep_key(adapter: dvobj->padapters); |
99 | |
100 | init_hw_mlme_ext(padapter); |
101 | |
102 | rtw_bb_rf_gain_offset(padapter); |
103 | } else { |
104 | dvobj->padapters->hw_init_completed = false; |
105 | } |
106 | |
107 | return status; |
108 | } |
109 | |
110 | uint rtw_hal_deinit(struct adapter *padapter) |
111 | { |
112 | uint status = _SUCCESS; |
113 | struct dvobj_priv *dvobj = adapter_to_dvobj(padapter); |
114 | |
115 | status = padapter->HalFunc.hal_deinit(padapter); |
116 | |
117 | if (status == _SUCCESS) { |
118 | padapter = dvobj->padapters; |
119 | padapter->hw_init_completed = false; |
120 | } |
121 | |
122 | return status; |
123 | } |
124 | |
125 | void rtw_hal_set_hwreg(struct adapter *padapter, u8 variable, u8 *val) |
126 | { |
127 | if (padapter->HalFunc.SetHwRegHandler) |
128 | padapter->HalFunc.SetHwRegHandler(padapter, variable, val); |
129 | } |
130 | |
131 | void rtw_hal_get_hwreg(struct adapter *padapter, u8 variable, u8 *val) |
132 | { |
133 | if (padapter->HalFunc.GetHwRegHandler) |
134 | padapter->HalFunc.GetHwRegHandler(padapter, variable, val); |
135 | } |
136 | |
137 | void rtw_hal_set_hwreg_with_buf(struct adapter *padapter, u8 variable, u8 *pbuf, int len) |
138 | { |
139 | if (padapter->HalFunc.SetHwRegHandlerWithBuf) |
140 | padapter->HalFunc.SetHwRegHandlerWithBuf(padapter, variable, pbuf, len); |
141 | } |
142 | |
143 | u8 rtw_hal_set_def_var(struct adapter *padapter, enum hal_def_variable eVariable, void *pValue) |
144 | { |
145 | if (padapter->HalFunc.SetHalDefVarHandler) |
146 | return padapter->HalFunc.SetHalDefVarHandler(padapter, eVariable, pValue); |
147 | return _FAIL; |
148 | } |
149 | |
150 | u8 rtw_hal_get_def_var(struct adapter *padapter, enum hal_def_variable eVariable, void *pValue) |
151 | { |
152 | if (padapter->HalFunc.GetHalDefVarHandler) |
153 | return padapter->HalFunc.GetHalDefVarHandler(padapter, eVariable, pValue); |
154 | return _FAIL; |
155 | } |
156 | |
157 | void rtw_hal_set_odm_var(struct adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, bool bSet) |
158 | { |
159 | if (padapter->HalFunc.SetHalODMVarHandler) |
160 | padapter->HalFunc.SetHalODMVarHandler(padapter, eVariable, pValue1, bSet); |
161 | } |
162 | |
163 | void rtw_hal_get_odm_var(struct adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, void *pValue2) |
164 | { |
165 | if (padapter->HalFunc.GetHalODMVarHandler) |
166 | padapter->HalFunc.GetHalODMVarHandler(padapter, eVariable, pValue1, pValue2); |
167 | } |
168 | |
169 | void rtw_hal_enable_interrupt(struct adapter *padapter) |
170 | { |
171 | if (padapter->HalFunc.enable_interrupt) |
172 | padapter->HalFunc.enable_interrupt(padapter); |
173 | } |
174 | |
175 | void rtw_hal_disable_interrupt(struct adapter *padapter) |
176 | { |
177 | if (padapter->HalFunc.disable_interrupt) |
178 | padapter->HalFunc.disable_interrupt(padapter); |
179 | } |
180 | |
181 | u8 rtw_hal_check_ips_status(struct adapter *padapter) |
182 | { |
183 | u8 val = false; |
184 | |
185 | if (padapter->HalFunc.check_ips_status) |
186 | val = padapter->HalFunc.check_ips_status(padapter); |
187 | |
188 | return val; |
189 | } |
190 | |
191 | s32 rtw_hal_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe) |
192 | { |
193 | if (padapter->HalFunc.hal_xmitframe_enqueue) |
194 | return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe); |
195 | |
196 | return false; |
197 | } |
198 | |
199 | s32 rtw_hal_xmit(struct adapter *padapter, struct xmit_frame *pxmitframe) |
200 | { |
201 | if (padapter->HalFunc.hal_xmit) |
202 | return padapter->HalFunc.hal_xmit(padapter, pxmitframe); |
203 | |
204 | return false; |
205 | } |
206 | |
207 | /* |
208 | * [IMPORTANT] This function would be run in interrupt context. |
209 | */ |
210 | s32 rtw_hal_mgnt_xmit(struct adapter *padapter, struct xmit_frame *pmgntframe) |
211 | { |
212 | s32 ret = _FAIL; |
213 | |
214 | update_mgntframe_attrib_addr(padapter, pmgntframe); |
215 | /* pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET; */ |
216 | /* pwlanhdr = (struct rtw_ieee80211_hdr *)pframe; */ |
217 | /* memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN); */ |
218 | |
219 | if (padapter->securitypriv.binstallBIPkey == true) { |
220 | if (is_multicast_ether_addr(addr: pmgntframe->attrib.ra)) { |
221 | pmgntframe->attrib.encrypt = _BIP_; |
222 | /* pmgntframe->attrib.bswenc = true; */ |
223 | } else { |
224 | pmgntframe->attrib.encrypt = _AES_; |
225 | pmgntframe->attrib.bswenc = true; |
226 | } |
227 | rtw_mgmt_xmitframe_coalesce(padapter, pkt: pmgntframe->pkt, pxmitframe: pmgntframe); |
228 | } |
229 | |
230 | if (padapter->HalFunc.mgnt_xmit) |
231 | ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe); |
232 | return ret; |
233 | } |
234 | |
235 | s32 rtw_hal_init_xmit_priv(struct adapter *padapter) |
236 | { |
237 | if (padapter->HalFunc.init_xmit_priv) |
238 | return padapter->HalFunc.init_xmit_priv(padapter); |
239 | return _FAIL; |
240 | } |
241 | |
242 | void rtw_hal_free_xmit_priv(struct adapter *padapter) |
243 | { |
244 | if (padapter->HalFunc.free_xmit_priv) |
245 | padapter->HalFunc.free_xmit_priv(padapter); |
246 | } |
247 | |
248 | s32 rtw_hal_init_recv_priv(struct adapter *padapter) |
249 | { |
250 | if (padapter->HalFunc.init_recv_priv) |
251 | return padapter->HalFunc.init_recv_priv(padapter); |
252 | |
253 | return _FAIL; |
254 | } |
255 | |
256 | void rtw_hal_free_recv_priv(struct adapter *padapter) |
257 | { |
258 | if (padapter->HalFunc.free_recv_priv) |
259 | padapter->HalFunc.free_recv_priv(padapter); |
260 | } |
261 | |
262 | void rtw_hal_update_ra_mask(struct sta_info *psta, u8 ) |
263 | { |
264 | struct adapter *padapter; |
265 | struct mlme_priv *pmlmepriv; |
266 | |
267 | if (!psta) |
268 | return; |
269 | |
270 | padapter = psta->padapter; |
271 | |
272 | pmlmepriv = &(padapter->mlmepriv); |
273 | |
274 | if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) |
275 | add_RATid(padapter, psta, rssi_level); |
276 | else { |
277 | if (padapter->HalFunc.UpdateRAMaskHandler) |
278 | padapter->HalFunc.UpdateRAMaskHandler(padapter, psta->mac_id, rssi_level); |
279 | } |
280 | } |
281 | |
282 | void rtw_hal_add_ra_tid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 ) |
283 | { |
284 | if (padapter->HalFunc.Add_RateATid) |
285 | padapter->HalFunc.Add_RateATid(padapter, bitmap, arg, rssi_level); |
286 | } |
287 | |
288 | /*Start specifical interface thread */ |
289 | void rtw_hal_start_thread(struct adapter *padapter) |
290 | { |
291 | if (padapter->HalFunc.run_thread) |
292 | padapter->HalFunc.run_thread(padapter); |
293 | } |
294 | /*Start specifical interface thread */ |
295 | void rtw_hal_stop_thread(struct adapter *padapter) |
296 | { |
297 | if (padapter->HalFunc.cancel_thread) |
298 | padapter->HalFunc.cancel_thread(padapter); |
299 | } |
300 | |
301 | u32 rtw_hal_read_bbreg(struct adapter *padapter, u32 RegAddr, u32 BitMask) |
302 | { |
303 | u32 data = 0; |
304 | |
305 | if (padapter->HalFunc.read_bbreg) |
306 | data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask); |
307 | return data; |
308 | } |
309 | void rtw_hal_write_bbreg(struct adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data) |
310 | { |
311 | if (padapter->HalFunc.write_bbreg) |
312 | padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data); |
313 | } |
314 | |
315 | u32 rtw_hal_read_rfreg(struct adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask) |
316 | { |
317 | u32 data = 0; |
318 | |
319 | if (padapter->HalFunc.read_rfreg) |
320 | data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask); |
321 | return data; |
322 | } |
323 | void rtw_hal_write_rfreg(struct adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data) |
324 | { |
325 | if (padapter->HalFunc.write_rfreg) |
326 | padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data); |
327 | } |
328 | |
329 | void rtw_hal_set_chan(struct adapter *padapter, u8 channel) |
330 | { |
331 | if (padapter->HalFunc.set_channel_handler) |
332 | padapter->HalFunc.set_channel_handler(padapter, channel); |
333 | } |
334 | |
335 | void rtw_hal_set_chnl_bw(struct adapter *padapter, u8 channel, |
336 | enum channel_width Bandwidth, u8 Offset40, u8 Offset80) |
337 | { |
338 | if (padapter->HalFunc.set_chnl_bw_handler) |
339 | padapter->HalFunc.set_chnl_bw_handler(padapter, channel, |
340 | Bandwidth, Offset40, |
341 | Offset80); |
342 | } |
343 | |
344 | void rtw_hal_dm_watchdog(struct adapter *padapter) |
345 | { |
346 | if (padapter->HalFunc.hal_dm_watchdog) |
347 | padapter->HalFunc.hal_dm_watchdog(padapter); |
348 | } |
349 | |
350 | void rtw_hal_dm_watchdog_in_lps(struct adapter *padapter) |
351 | { |
352 | if (adapter_to_pwrctl(padapter)->fw_current_in_ps_mode) { |
353 | if (padapter->HalFunc.hal_dm_watchdog_in_lps) |
354 | padapter->HalFunc.hal_dm_watchdog_in_lps(padapter); /* this function caller is in interrupt context */ |
355 | } |
356 | } |
357 | |
358 | void beacon_timing_control(struct adapter *padapter) |
359 | { |
360 | if (padapter->HalFunc.SetBeaconRelatedRegistersHandler) |
361 | padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter); |
362 | } |
363 | |
364 | |
365 | s32 rtw_hal_xmit_thread_handler(struct adapter *padapter) |
366 | { |
367 | if (padapter->HalFunc.xmit_thread_handler) |
368 | return padapter->HalFunc.xmit_thread_handler(padapter); |
369 | return _FAIL; |
370 | } |
371 | |
372 | void rtw_hal_notch_filter(struct adapter *adapter, bool enable) |
373 | { |
374 | if (adapter->HalFunc.hal_notch_filter) |
375 | adapter->HalFunc.hal_notch_filter(adapter, enable); |
376 | } |
377 | |
378 | void rtw_hal_reset_security_engine(struct adapter *adapter) |
379 | { |
380 | if (adapter->HalFunc.hal_reset_security_engine) |
381 | adapter->HalFunc.hal_reset_security_engine(adapter); |
382 | } |
383 | |
384 | bool rtw_hal_c2h_valid(struct adapter *adapter, u8 *buf) |
385 | { |
386 | return c2h_evt_valid((struct c2h_evt_hdr_88xx *)buf); |
387 | } |
388 | |
389 | s32 rtw_hal_c2h_handler(struct adapter *adapter, u8 *c2h_evt) |
390 | { |
391 | s32 ret = _FAIL; |
392 | |
393 | if (adapter->HalFunc.c2h_handler) |
394 | ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt); |
395 | return ret; |
396 | } |
397 | |
398 | c2h_id_filter rtw_hal_c2h_id_filter_ccx(struct adapter *adapter) |
399 | { |
400 | return adapter->HalFunc.c2h_id_filter_ccx; |
401 | } |
402 | |
403 | s32 rtw_hal_macid_sleep(struct adapter *padapter, u32 macid) |
404 | { |
405 | u8 support; |
406 | |
407 | support = false; |
408 | rtw_hal_get_def_var(padapter, eVariable: HAL_DEF_MACID_SLEEP, pValue: &support); |
409 | if (false == support) |
410 | return _FAIL; |
411 | |
412 | rtw_hal_set_hwreg(padapter, variable: HW_VAR_MACID_SLEEP, val: (u8 *)&macid); |
413 | |
414 | return _SUCCESS; |
415 | } |
416 | |
417 | s32 rtw_hal_macid_wakeup(struct adapter *padapter, u32 macid) |
418 | { |
419 | u8 support; |
420 | |
421 | support = false; |
422 | rtw_hal_get_def_var(padapter, eVariable: HAL_DEF_MACID_SLEEP, pValue: &support); |
423 | if (false == support) |
424 | return _FAIL; |
425 | |
426 | rtw_hal_set_hwreg(padapter, variable: HW_VAR_MACID_WAKEUP, val: (u8 *)&macid); |
427 | |
428 | return _SUCCESS; |
429 | } |
430 | |
431 | s32 rtw_hal_fill_h2c_cmd(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer) |
432 | { |
433 | s32 ret = _FAIL; |
434 | |
435 | if (padapter->HalFunc.fill_h2c_cmd) |
436 | ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer); |
437 | |
438 | return ret; |
439 | } |
440 | |