1
2
3
4#define _HAL_INTF_C_
5#include "../include/osdep_service.h"
6#include "../include/drv_types.h"
7#include "../include/hal_intf.h"
8
9void rtw_hal_chip_configure(struct adapter *adapt)
10{
11 if (adapt->HalFunc.intf_chip_configure)
12 adapt->HalFunc.intf_chip_configure(adapt);
13}
14
15void rtw_hal_read_chip_info(struct adapter *adapt)
16{
17 if (adapt->HalFunc.read_adapter_info)
18 adapt->HalFunc.read_adapter_info(adapt);
19}
20
21void rtw_hal_read_chip_version(struct adapter *adapt)
22{
23 if (adapt->HalFunc.read_chip_version)
24 adapt->HalFunc.read_chip_version(adapt);
25}
26
27void rtw_hal_def_value_init(struct adapter *adapt)
28{
29 if (adapt->HalFunc.init_default_value)
30 adapt->HalFunc.init_default_value(adapt);
31}
32
33void rtw_hal_free_data(struct adapter *adapt)
34{
35 if (adapt->HalFunc.free_hal_data)
36 adapt->HalFunc.free_hal_data(adapt);
37}
38
39void rtw_hal_dm_init(struct adapter *adapt)
40{
41 if (adapt->HalFunc.dm_init)
42 adapt->HalFunc.dm_init(adapt);
43}
44
45void rtw_hal_dm_deinit(struct adapter *adapt)
46{
47
48 if (adapt->HalFunc.dm_deinit)
49 adapt->HalFunc.dm_deinit(adapt);
50}
51
52void rtw_hal_sw_led_init(struct adapter *adapt)
53{
54 if (adapt->HalFunc.InitSwLeds)
55 adapt->HalFunc.InitSwLeds(adapt);
56}
57
58void rtw_hal_sw_led_deinit(struct adapter *adapt)
59{
60 if (adapt->HalFunc.DeInitSwLeds)
61 adapt->HalFunc.DeInitSwLeds(adapt);
62}
63
64u32 rtw_hal_power_on(struct adapter *adapt)
65{
66 if (adapt->HalFunc.hal_power_on)
67 return adapt->HalFunc.hal_power_on(adapt);
68 return _FAIL;
69}
70
71uint rtw_hal_init(struct adapter *adapt)
72{
73 uint status = _SUCCESS;
74
75 adapt->hw_init_completed = false;
76
77 status = adapt->HalFunc.hal_init(adapt);
78
79 if (status == _SUCCESS) {
80 adapt->hw_init_completed = true;
81
82 if (adapt->registrypriv.notch_filter == 1)
83 rtw_hal_notch_filter(adapt, 1);
84
85 rtw_hal_reset_security_engine(adapt);
86 } else {
87 adapt->hw_init_completed = false;
88 DBG_88E("rtw_hal_init: hal__init fail\n");
89 }
90
91 return status;
92}
93
94uint rtw_hal_deinit(struct adapter *adapt)
95{
96 uint status = _SUCCESS;
97
98 status = adapt->HalFunc.hal_deinit(adapt);
99
100 if (status == _SUCCESS)
101 adapt->hw_init_completed = false;
102 else
103 DBG_88E("\n rtw_hal_deinit: hal_init fail\n");
104
105 return status;
106}
107
108void rtw_hal_set_hwreg(struct adapter *adapt, u8 variable, u8 *val)
109{
110 if (adapt->HalFunc.SetHwRegHandler)
111 adapt->HalFunc.SetHwRegHandler(adapt, variable, val);
112}
113
114void rtw_hal_get_hwreg(struct adapter *adapt, u8 variable, u8 *val)
115{
116 if (adapt->HalFunc.GetHwRegHandler)
117 adapt->HalFunc.GetHwRegHandler(adapt, variable, val);
118}
119
120u8 rtw_hal_set_def_var(struct adapter *adapt, enum hal_def_variable var,
121 void *val)
122{
123 if (adapt->HalFunc.SetHalDefVarHandler)
124 return adapt->HalFunc.SetHalDefVarHandler(adapt, var, val);
125 return _FAIL;
126}
127
128u8 rtw_hal_get_def_var(struct adapter *adapt,
129 enum hal_def_variable var, void *val)
130{
131 if (adapt->HalFunc.GetHalDefVarHandler)
132 return adapt->HalFunc.GetHalDefVarHandler(adapt, var, val);
133 return _FAIL;
134}
135
136void rtw_hal_set_odm_var(struct adapter *adapt,
137 enum hal_odm_variable var, void *val1,
138 bool set)
139{
140 if (adapt->HalFunc.SetHalODMVarHandler)
141 adapt->HalFunc.SetHalODMVarHandler(adapt, var,
142 val1, set);
143}
144
145void rtw_hal_get_odm_var(struct adapter *adapt,
146 enum hal_odm_variable var, void *val1,
147 bool set)
148{
149 if (adapt->HalFunc.GetHalODMVarHandler)
150 adapt->HalFunc.GetHalODMVarHandler(adapt, var,
151 val1, set);
152}
153
154void rtw_hal_enable_interrupt(struct adapter *adapt)
155{
156 if (adapt->HalFunc.enable_interrupt)
157 adapt->HalFunc.enable_interrupt(adapt);
158 else
159 DBG_88E("%s: HalFunc.enable_interrupt is NULL!\n", __func__);
160}
161
162void rtw_hal_disable_interrupt(struct adapter *adapt)
163{
164 if (adapt->HalFunc.disable_interrupt)
165 adapt->HalFunc.disable_interrupt(adapt);
166 else
167 DBG_88E("%s: HalFunc.disable_interrupt is NULL!\n", __func__);
168}
169
170u32 rtw_hal_inirp_init(struct adapter *adapt)
171{
172 u32 rst = _FAIL;
173
174 if (adapt->HalFunc.inirp_init)
175 rst = adapt->HalFunc.inirp_init(adapt);
176 else
177 DBG_88E(" %s HalFunc.inirp_init is NULL!!!\n", __func__);
178 return rst;
179}
180
181u32 rtw_hal_inirp_deinit(struct adapter *adapt)
182{
183 if (adapt->HalFunc.inirp_deinit)
184 return adapt->HalFunc.inirp_deinit(adapt);
185
186 return _FAIL;
187}
188
189u8 rtw_hal_intf_ps_func(struct adapter *adapt,
190 enum hal_intf_ps_func efunc_id, u8 *val)
191{
192 if (adapt->HalFunc.interface_ps_func)
193 return adapt->HalFunc.interface_ps_func(adapt, efunc_id,
194 val);
195 return _FAIL;
196}
197
198s32 rtw_hal_xmitframe_enqueue(struct adapter *padapter,
199 struct xmit_frame *pxmitframe)
200{
201 if (padapter->HalFunc.hal_xmitframe_enqueue)
202 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
203 return false;
204}
205
206s32 rtw_hal_xmit(struct adapter *adapt, struct xmit_frame *pxmitframe)
207{
208 if (adapt->HalFunc.hal_xmit)
209 return adapt->HalFunc.hal_xmit(adapt, pxmitframe);
210
211 return false;
212}
213
214s32 rtw_hal_mgnt_xmit(struct adapter *adapt, struct xmit_frame *pmgntframe)
215{
216 s32 ret = _FAIL;
217 if (adapt->HalFunc.mgnt_xmit)
218 ret = adapt->HalFunc.mgnt_xmit(adapt, pmgntframe);
219 return ret;
220}
221
222s32 rtw_hal_init_xmit_priv(struct adapter *adapt)
223{
224 if (adapt->HalFunc.init_xmit_priv)
225 return adapt->HalFunc.init_xmit_priv(adapt);
226 return _FAIL;
227}
228
229s32 rtw_hal_init_recv_priv(struct adapter *adapt)
230{
231 if (adapt->HalFunc.init_recv_priv)
232 return adapt->HalFunc.init_recv_priv(adapt);
233
234 return _FAIL;
235}
236
237void rtw_hal_free_recv_priv(struct adapter *adapt)
238{
239 if (adapt->HalFunc.free_recv_priv)
240 adapt->HalFunc.free_recv_priv(adapt);
241}
242
243void rtw_hal_update_ra_mask(struct adapter *adapt, u32 mac_id, u8 rssi_level)
244{
245 struct mlme_priv *pmlmepriv = &adapt->mlmepriv;
246
247 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
248#ifdef CONFIG_88EU_AP_MODE
249 struct sta_info *psta = NULL;
250 struct sta_priv *pstapriv = &adapt->stapriv;
251 if (mac_id >= 2)
252 psta = pstapriv->sta_aid[(mac_id - 1) - 1];
253 if (psta)
254 add_RATid(adapt, psta, 0);
255#endif
256 } else {
257 if (adapt->HalFunc.UpdateRAMaskHandler)
258 adapt->HalFunc.UpdateRAMaskHandler(adapt, mac_id,
259 rssi_level);
260 }
261}
262
263void rtw_hal_add_ra_tid(struct adapter *adapt, u32 bitmap, u8 arg,
264 u8 rssi_level)
265{
266 if (adapt->HalFunc.Add_RateATid)
267 adapt->HalFunc.Add_RateATid(adapt, bitmap, arg,
268 rssi_level);
269}
270
271
272void rtw_hal_start_thread(struct adapter *adapt)
273{
274 if (adapt->HalFunc.run_thread)
275 adapt->HalFunc.run_thread(adapt);
276}
277
278
279void rtw_hal_stop_thread(struct adapter *adapt)
280{
281 if (adapt->HalFunc.cancel_thread)
282 adapt->HalFunc.cancel_thread(adapt);
283}
284
285u32 rtw_hal_read_bbreg(struct adapter *adapt, u32 regaddr, u32 bitmask)
286{
287 u32 data = 0;
288
289 if (adapt->HalFunc.read_bbreg)
290 data = adapt->HalFunc.read_bbreg(adapt, regaddr, bitmask);
291 return data;
292}
293
294void rtw_hal_write_bbreg(struct adapter *adapt, u32 regaddr, u32 bitmask,
295 u32 data)
296{
297 if (adapt->HalFunc.write_bbreg)
298 adapt->HalFunc.write_bbreg(adapt, regaddr, bitmask, data);
299}
300
301u32 rtw_hal_read_rfreg(struct adapter *adapt, enum rf_radio_path rfpath,
302 u32 regaddr, u32 bitmask)
303{
304 u32 data = 0;
305
306 if (adapt->HalFunc.read_rfreg)
307 data = adapt->HalFunc.read_rfreg(adapt, rfpath, regaddr,
308 bitmask);
309 return data;
310}
311
312void rtw_hal_write_rfreg(struct adapter *adapt, enum rf_radio_path rfpath,
313 u32 regaddr, u32 bitmask, u32 data)
314{
315 if (adapt->HalFunc.write_rfreg)
316 adapt->HalFunc.write_rfreg(adapt, rfpath, regaddr,
317 bitmask, data);
318}
319
320s32 rtw_hal_interrupt_handler(struct adapter *adapt)
321{
322 if (adapt->HalFunc.interrupt_handler)
323 return adapt->HalFunc.interrupt_handler(adapt);
324 return _FAIL;
325}
326
327void rtw_hal_set_bwmode(struct adapter *adapt,
328 enum ht_channel_width bandwidth, u8 offset)
329{
330 if (adapt->HalFunc.set_bwmode_handler)
331 adapt->HalFunc.set_bwmode_handler(adapt, bandwidth,
332 offset);
333}
334
335void rtw_hal_set_chan(struct adapter *adapt, u8 channel)
336{
337 if (adapt->HalFunc.set_channel_handler)
338 adapt->HalFunc.set_channel_handler(adapt, channel);
339}
340
341void rtw_hal_dm_watchdog(struct adapter *adapt)
342{
343 if (adapt->HalFunc.hal_dm_watchdog)
344 adapt->HalFunc.hal_dm_watchdog(adapt);
345}
346
347void rtw_hal_bcn_related_reg_setting(struct adapter *adapt)
348{
349 if (adapt->HalFunc.SetBeaconRelatedRegistersHandler)
350 adapt->HalFunc.SetBeaconRelatedRegistersHandler(adapt);
351}
352
353u8 rtw_hal_antdiv_before_linked(struct adapter *adapt)
354{
355 if (adapt->HalFunc.AntDivBeforeLinkHandler)
356 return adapt->HalFunc.AntDivBeforeLinkHandler(adapt);
357 return false;
358}
359
360void rtw_hal_antdiv_rssi_compared(struct adapter *adapt,
361 struct wlan_bssid_ex *dst,
362 struct wlan_bssid_ex *src)
363{
364 if (adapt->HalFunc.AntDivCompareHandler)
365 adapt->HalFunc.AntDivCompareHandler(adapt, dst, src);
366}
367
368void rtw_hal_sreset_init(struct adapter *adapt)
369{
370 if (adapt->HalFunc.sreset_init_value)
371 adapt->HalFunc.sreset_init_value(adapt);
372}
373
374void rtw_hal_sreset_reset(struct adapter *adapt)
375{
376 if (adapt->HalFunc.silentreset)
377 adapt->HalFunc.silentreset(adapt);
378}
379
380void rtw_hal_sreset_reset_value(struct adapter *adapt)
381{
382 if (adapt->HalFunc.sreset_reset_value)
383 adapt->HalFunc.sreset_reset_value(adapt);
384}
385
386void rtw_hal_sreset_xmit_status_check(struct adapter *adapt)
387{
388 if (adapt->HalFunc.sreset_xmit_status_check)
389 adapt->HalFunc.sreset_xmit_status_check(adapt);
390}
391
392void rtw_hal_sreset_linked_status_check(struct adapter *adapt)
393{
394 if (adapt->HalFunc.sreset_linked_status_check)
395 adapt->HalFunc.sreset_linked_status_check(adapt);
396}
397
398u8 rtw_hal_sreset_get_wifi_status(struct adapter *adapt)
399{
400 u8 status = 0;
401
402 if (adapt->HalFunc.sreset_get_wifi_status)
403 status = adapt->HalFunc.sreset_get_wifi_status(adapt);
404 return status;
405}
406
407int rtw_hal_iol_cmd(struct adapter *adapter, struct xmit_frame *xmit_frame,
408 u32 max_wating_ms, u32 bndy_cnt)
409{
410 if (adapter->HalFunc.IOL_exec_cmds_sync)
411 return adapter->HalFunc.IOL_exec_cmds_sync(adapter, xmit_frame,
412 max_wating_ms,
413 bndy_cnt);
414 return _FAIL;
415}
416
417void rtw_hal_notch_filter(struct adapter *adapter, bool enable)
418{
419 if (adapter->HalFunc.hal_notch_filter)
420 adapter->HalFunc.hal_notch_filter(adapter, enable);
421}
422
423void rtw_hal_reset_security_engine(struct adapter *adapter)
424{
425 if (adapter->HalFunc.hal_reset_security_engine)
426 adapter->HalFunc.hal_reset_security_engine(adapter);
427}
428
429s32 rtw_hal_c2h_handler(struct adapter *adapter, struct c2h_evt_hdr *c2h_evt)
430{
431 s32 ret = _FAIL;
432
433 if (adapter->HalFunc.c2h_handler)
434 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
435 return ret;
436}
437
438c2h_id_filter rtw_hal_c2h_id_filter_ccx(struct adapter *adapter)
439{
440 return adapter->HalFunc.c2h_id_filter_ccx;
441}
442
