1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20
21 #define _HAL_INTF_C_
22
23 #include <drv_types.h>
24 #include <hal_data.h>
25
26 const u32 _chip_type_to_odm_ic_type[] = {
27 0,
28 ODM_RTL8188E,
29 ODM_RTL8192E,
30 ODM_RTL8812,
31 ODM_RTL8821,
32 ODM_RTL8723B,
33 ODM_RTL8814A,
34 ODM_RTL8703B,
35 ODM_RTL8188F,
36 0,
37 };
38
rtw_hal_chip_configure(_adapter * padapter)39 void rtw_hal_chip_configure(_adapter *padapter)
40 {
41 padapter->HalFunc.intf_chip_configure(padapter);
42 }
43
rtw_hal_read_chip_info(_adapter * padapter)44 void rtw_hal_read_chip_info(_adapter *padapter)
45 {
46 u8 hci_type = rtw_get_intf_type(padapter);
47 u32 start = rtw_get_current_time();
48
49 /* before access eFuse, make sure card enable has been called */
50 if ((hci_type == RTW_SDIO || hci_type == RTW_GSPI)
51 && !rtw_is_hw_init_completed(padapter))
52 rtw_hal_power_on(padapter);
53
54 padapter->HalFunc.read_adapter_info(padapter);
55
56 if ((hci_type == RTW_SDIO || hci_type == RTW_GSPI)
57 && !rtw_is_hw_init_completed(padapter))
58 rtw_hal_power_off(padapter);
59
60 DBG_871X("%s in %d ms\n", __func__, rtw_get_passing_time_ms(start));
61 }
62
rtw_hal_read_chip_version(_adapter * padapter)63 void rtw_hal_read_chip_version(_adapter *padapter)
64 {
65 padapter->HalFunc.read_chip_version(padapter);
66 rtw_odm_init_ic_type(padapter);
67 }
68
rtw_hal_def_value_init(_adapter * padapter)69 void rtw_hal_def_value_init(_adapter *padapter)
70 {
71 if (is_primary_adapter(padapter)) {
72 padapter->HalFunc.init_default_value(padapter);
73
74 rtw_init_hal_com_default_value(padapter);
75
76 {
77 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
78 struct hal_spec_t *hal_spec = GET_HAL_SPEC(padapter);
79
80 /* hal_spec is ready here */
81 dvobj->macid_ctl.num = rtw_min(hal_spec->macid_num, MACID_NUM_SW_LIMIT);
82
83 dvobj->cam_ctl.sec_cap = hal_spec->sec_cap;
84 dvobj->cam_ctl.num = rtw_min(hal_spec->sec_cam_ent_num, SEC_CAM_ENT_NUM_SW_LIMIT);
85 }
86 }
87 }
88
rtw_hal_data_init(_adapter * padapter)89 u8 rtw_hal_data_init(_adapter *padapter)
90 {
91 if (is_primary_adapter(padapter)) {
92 padapter->hal_data_sz = sizeof(HAL_DATA_TYPE);
93 padapter->HalData = rtw_zvmalloc(padapter->hal_data_sz);
94 if(padapter->HalData == NULL){
95 DBG_8192C("cant not alloc memory for HAL DATA \n");
96 return _FAIL;
97 }
98 }
99 return _SUCCESS;
100 }
101
rtw_hal_data_deinit(_adapter * padapter)102 void rtw_hal_data_deinit(_adapter *padapter)
103 {
104 if (is_primary_adapter(padapter)) {
105 if (padapter->HalData)
106 {
107 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
108 phy_free_filebuf(padapter);
109 #endif
110 rtw_vmfree(padapter->HalData, padapter->hal_data_sz);
111 padapter->HalData = NULL;
112 padapter->hal_data_sz = 0;
113 }
114 }
115 }
116
rtw_hal_free_data(_adapter * padapter)117 void rtw_hal_free_data(_adapter *padapter)
118 {
119 //free HAL Data
120 rtw_hal_data_deinit(padapter);
121 }
rtw_hal_dm_init(_adapter * padapter)122 void rtw_hal_dm_init(_adapter *padapter)
123 {
124 if (is_primary_adapter(padapter)) {
125 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
126
127 padapter->HalFunc.dm_init(padapter);
128
129 _rtw_spinlock_init(&pHalData->IQKSpinLock);
130
131 phy_load_tx_power_ext_info(padapter, 1, 1);
132 }
133 }
rtw_hal_dm_deinit(_adapter * padapter)134 void rtw_hal_dm_deinit(_adapter *padapter)
135 {
136 if (is_primary_adapter(padapter)) {
137 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
138
139 padapter->HalFunc.dm_deinit(padapter);
140
141 _rtw_spinlock_free(&pHalData->IQKSpinLock);
142 }
143 }
rtw_hal_sw_led_init(_adapter * padapter)144 void rtw_hal_sw_led_init(_adapter *padapter)
145 {
146 if(padapter->HalFunc.InitSwLeds)
147 padapter->HalFunc.InitSwLeds(padapter);
148 }
149
rtw_hal_sw_led_deinit(_adapter * padapter)150 void rtw_hal_sw_led_deinit(_adapter *padapter)
151 {
152 if(padapter->HalFunc.DeInitSwLeds)
153 padapter->HalFunc.DeInitSwLeds(padapter);
154 }
155
rtw_hal_power_on(_adapter * padapter)156 u32 rtw_hal_power_on(_adapter *padapter)
157 {
158 return padapter->HalFunc.hal_power_on(padapter);
159 }
rtw_hal_power_off(_adapter * padapter)160 void rtw_hal_power_off(_adapter *padapter)
161 {
162 struct macid_ctl_t *macid_ctl = &padapter->dvobj->macid_ctl;
163
164 _rtw_memset(macid_ctl->h2c_msr, 0, MACID_NUM_SW_LIMIT);
165
166 padapter->HalFunc.hal_power_off(padapter);
167 }
168
169
rtw_hal_init_opmode(_adapter * padapter)170 void rtw_hal_init_opmode(_adapter *padapter)
171 {
172 NDIS_802_11_NETWORK_INFRASTRUCTURE networkType = Ndis802_11InfrastructureMax;
173 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
174 sint fw_state;
175
176 fw_state = get_fwstate(pmlmepriv);
177
178 if (fw_state & WIFI_ADHOC_STATE)
179 networkType = Ndis802_11IBSS;
180 else if (fw_state & WIFI_STATION_STATE)
181 networkType = Ndis802_11Infrastructure;
182 else if (fw_state & WIFI_AP_STATE)
183 networkType = Ndis802_11APMode;
184 else
185 return;
186
187 rtw_setopmode_cmd(padapter, networkType, _FALSE);
188 }
189
rtw_hal_init(_adapter * padapter)190 uint rtw_hal_init(_adapter *padapter)
191 {
192 uint status = _SUCCESS;
193 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
194 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
195 int i;
196
197 status = padapter->HalFunc.hal_init(padapter);
198
199 if (status == _SUCCESS) {
200 pHalData->hw_init_completed = _TRUE;
201
202 if (padapter->registrypriv.notch_filter == 1)
203 rtw_hal_notch_filter(padapter, 1);
204
205 for (i = 0; i<dvobj->iface_nums; i++)
206 rtw_sec_restore_wep_key(dvobj->padapters[i]);
207
208 rtw_led_control(padapter, LED_CTL_POWER_ON);
209
210 init_hw_mlme_ext(padapter);
211
212 rtw_hal_init_opmode(padapter);
213
214 #ifdef CONFIG_RF_GAIN_OFFSET
215 rtw_bb_rf_gain_offset(padapter);
216 #endif //CONFIG_RF_GAIN_OFFSET
217
218 } else {
219 pHalData->hw_init_completed = _FALSE;
220 DBG_871X("rtw_hal_init: hal__init fail\n");
221 }
222
223 RT_TRACE(_module_hal_init_c_,_drv_err_,("-rtl871x_hal_init:status=0x%x\n",status));
224
225 return status;
226
227 }
228
rtw_hal_deinit(_adapter * padapter)229 uint rtw_hal_deinit(_adapter *padapter)
230 {
231 uint status = _SUCCESS;
232 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
233 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
234 int i;
235 _func_enter_;
236
237 status = padapter->HalFunc.hal_deinit(padapter);
238
239 if(status == _SUCCESS){
240 rtw_led_control(padapter, LED_CTL_POWER_OFF);
241 pHalData->hw_init_completed = _FALSE;
242 }
243 else
244 {
245 DBG_871X("\n rtw_hal_deinit: hal_init fail\n");
246 }
247
248 _func_exit_;
249
250 return status;
251 }
252
rtw_hal_set_hwreg(_adapter * padapter,u8 variable,u8 * val)253 void rtw_hal_set_hwreg(_adapter *padapter, u8 variable, u8 *val)
254 {
255 padapter->HalFunc.SetHwRegHandler(padapter, variable, val);
256 }
257
rtw_hal_get_hwreg(_adapter * padapter,u8 variable,u8 * val)258 void rtw_hal_get_hwreg(_adapter *padapter, u8 variable, u8 *val)
259 {
260 padapter->HalFunc.GetHwRegHandler(padapter, variable, val);
261 }
262
263 #ifdef CONFIG_C2H_PACKET_EN
rtw_hal_set_hwreg_with_buf(_adapter * padapter,u8 variable,u8 * pbuf,int len)264 void rtw_hal_set_hwreg_with_buf(_adapter *padapter, u8 variable, u8 *pbuf, int len)
265 {
266 if (padapter->HalFunc.SetHwRegHandlerWithBuf)
267 padapter->HalFunc.SetHwRegHandlerWithBuf(padapter, variable, pbuf, len);
268 }
269 #endif
270
rtw_hal_set_def_var(_adapter * padapter,HAL_DEF_VARIABLE eVariable,PVOID pValue)271 u8 rtw_hal_set_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
272 {
273 return padapter->HalFunc.SetHalDefVarHandler(padapter,eVariable,pValue);
274 }
rtw_hal_get_def_var(_adapter * padapter,HAL_DEF_VARIABLE eVariable,PVOID pValue)275 u8 rtw_hal_get_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
276 {
277 return padapter->HalFunc.GetHalDefVarHandler(padapter,eVariable,pValue);
278 }
279
rtw_hal_set_odm_var(_adapter * padapter,HAL_ODM_VARIABLE eVariable,PVOID pValue1,BOOLEAN bSet)280 void rtw_hal_set_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet)
281 {
282 padapter->HalFunc.SetHalODMVarHandler(padapter,eVariable,pValue1,bSet);
283 }
rtw_hal_get_odm_var(_adapter * padapter,HAL_ODM_VARIABLE eVariable,PVOID pValue1,PVOID pValue2)284 void rtw_hal_get_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,PVOID pValue2)
285 {
286 padapter->HalFunc.GetHalODMVarHandler(padapter,eVariable,pValue1,pValue2);
287 }
288
289 /* FOR SDIO & PCIE */
rtw_hal_enable_interrupt(_adapter * padapter)290 void rtw_hal_enable_interrupt(_adapter *padapter)
291 {
292 #if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
293 padapter->HalFunc.enable_interrupt(padapter);
294 #endif //#if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
295 }
296
297 /* FOR SDIO & PCIE */
rtw_hal_disable_interrupt(_adapter * padapter)298 void rtw_hal_disable_interrupt(_adapter *padapter)
299 {
300 #if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
301 padapter->HalFunc.disable_interrupt(padapter);
302 #endif //#if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
303 }
304
305
rtw_hal_check_ips_status(_adapter * padapter)306 u8 rtw_hal_check_ips_status(_adapter *padapter)
307 {
308 u8 val = _FALSE;
309 if (padapter->HalFunc.check_ips_status)
310 val = padapter->HalFunc.check_ips_status(padapter);
311 else
312 DBG_871X("%s: HalFunc.check_ips_status is NULL!\n", __FUNCTION__);
313
314 return val;
315 }
316
rtw_hal_fw_dl(_adapter * padapter,u8 wowlan)317 s32 rtw_hal_fw_dl(_adapter *padapter, u8 wowlan)
318 {
319 return padapter->HalFunc.fw_dl(padapter, wowlan);
320 }
321
322 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
rtw_hal_clear_interrupt(_adapter * padapter)323 void rtw_hal_clear_interrupt(_adapter *padapter)
324 {
325 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
326 padapter->HalFunc.clear_interrupt(padapter);
327 #endif
328 }
329 #endif
330
331 #if defined(CONFIG_USB_HCI) || defined (CONFIG_PCI_HCI)
rtw_hal_inirp_init(_adapter * padapter)332 u32 rtw_hal_inirp_init(_adapter *padapter)
333 {
334 if (is_primary_adapter(padapter))
335 return padapter->HalFunc.inirp_init(padapter);
336 return _SUCCESS;
337 }
rtw_hal_inirp_deinit(_adapter * padapter)338 u32 rtw_hal_inirp_deinit(_adapter *padapter)
339 {
340
341 if (is_primary_adapter(padapter))
342 return padapter->HalFunc.inirp_deinit(padapter);
343
344 return _SUCCESS;
345 }
346 #endif //#if defined(CONFIG_USB_HCI) || defined (CONFIG_PCI_HCI)
347
348 #if defined(CONFIG_PCI_HCI)
rtw_hal_irp_reset(_adapter * padapter)349 void rtw_hal_irp_reset(_adapter *padapter)
350 {
351 padapter->HalFunc.irp_reset(GET_PRIMARY_ADAPTER(padapter));
352 }
353 #endif //#if defined(CONFIG_PCI_HCI)
354
355 /* for USB Auto-suspend */
rtw_hal_intf_ps_func(_adapter * padapter,HAL_INTF_PS_FUNC efunc_id,u8 * val)356 u8 rtw_hal_intf_ps_func(_adapter *padapter,HAL_INTF_PS_FUNC efunc_id, u8* val)
357 {
358 if(padapter->HalFunc.interface_ps_func)
359 return padapter->HalFunc.interface_ps_func(padapter,efunc_id,val);
360 return _FAIL;
361 }
362
rtw_hal_xmitframe_enqueue(_adapter * padapter,struct xmit_frame * pxmitframe)363 s32 rtw_hal_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
364 {
365 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
366 }
367
rtw_hal_xmit(_adapter * padapter,struct xmit_frame * pxmitframe)368 s32 rtw_hal_xmit(_adapter *padapter, struct xmit_frame *pxmitframe)
369 {
370 return padapter->HalFunc.hal_xmit(padapter, pxmitframe);
371 }
372
373 /*
374 * [IMPORTANT] This function would be run in interrupt context.
375 */
rtw_hal_mgnt_xmit(_adapter * padapter,struct xmit_frame * pmgntframe)376 s32 rtw_hal_mgnt_xmit(_adapter *padapter, struct xmit_frame *pmgntframe)
377 {
378 s32 ret = _FAIL;
379 u8 *pframe, subtype;
380 struct rtw_ieee80211_hdr *pwlanhdr;
381 struct sta_info *psta;
382 struct sta_priv *pstapriv = &padapter->stapriv;
383
384 update_mgntframe_attrib_addr(padapter, pmgntframe);
385 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
386 subtype = GetFrameSubType(pframe); /* bit(7)~bit(2) */
387
388 //pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
389 //_rtw_memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN);
390
391 #ifdef CONFIG_IEEE80211W
392 if (padapter->securitypriv.binstallBIPkey == _TRUE && (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC ||
393 subtype == WIFI_ACTION))
394 {
395 if (IS_MCAST(pmgntframe->attrib.ra) && pmgntframe->attrib.key_type != IEEE80211W_NO_KEY) {
396 pmgntframe->attrib.encrypt = _BIP_;
397 /* pmgntframe->attrib.bswenc = _TRUE; */
398 } else if (pmgntframe->attrib.key_type != IEEE80211W_NO_KEY) {
399 psta = rtw_get_stainfo(pstapriv, pmgntframe->attrib.ra);
400 if (psta && psta->bpairwise_key_installed == _TRUE) {
401 pmgntframe->attrib.encrypt = _AES_;
402 pmgntframe->attrib.bswenc = _TRUE;
403 } else {
404 DBG_871X("%s, %d, bpairwise_key_installed is FALSE\n", __func__, __LINE__);
405 goto no_mgmt_coalesce;
406 }
407 }
408 DBG_871X("encrypt=%d, bswenc=%d\n", pmgntframe->attrib.encrypt, pmgntframe->attrib.bswenc);
409 rtw_mgmt_xmitframe_coalesce(padapter, pmgntframe->pkt, pmgntframe);
410 }
411 #endif //CONFIG_IEEE80211W
412 no_mgmt_coalesce:
413 ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe);
414 return ret;
415 }
416
rtw_hal_init_xmit_priv(_adapter * padapter)417 s32 rtw_hal_init_xmit_priv(_adapter *padapter)
418 {
419 return padapter->HalFunc.init_xmit_priv(padapter);
420 }
rtw_hal_free_xmit_priv(_adapter * padapter)421 void rtw_hal_free_xmit_priv(_adapter *padapter)
422 {
423 padapter->HalFunc.free_xmit_priv(padapter);
424 }
425
rtw_hal_init_recv_priv(_adapter * padapter)426 s32 rtw_hal_init_recv_priv(_adapter *padapter)
427 {
428 return padapter->HalFunc.init_recv_priv(padapter);
429 }
rtw_hal_free_recv_priv(_adapter * padapter)430 void rtw_hal_free_recv_priv(_adapter *padapter)
431 {
432 padapter->HalFunc.free_recv_priv(padapter);
433 }
434
rtw_hal_update_ra_mask(struct sta_info * psta,u8 rssi_level)435 void rtw_hal_update_ra_mask(struct sta_info *psta, u8 rssi_level)
436 {
437 _adapter *padapter;
438 struct mlme_priv *pmlmepriv;
439
440 if(!psta)
441 return;
442
443 padapter = psta->padapter;
444
445 pmlmepriv = &(padapter->mlmepriv);
446
447 if(check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
448 {
449 add_RATid(padapter, psta, rssi_level);
450 }
451 else
452 {
453 padapter->HalFunc.UpdateRAMaskHandler(padapter, psta->mac_id, rssi_level);
454 }
455 }
456
rtw_hal_add_ra_tid(_adapter * padapter,u64 bitmap,u8 * arg,u8 rssi_level)457 void rtw_hal_add_ra_tid(_adapter *padapter, u64 bitmap, u8 *arg, u8 rssi_level)
458 {
459 padapter->HalFunc.Add_RateATid(padapter, bitmap, arg, rssi_level);
460 }
461
462 /* Start specifical interface thread */
rtw_hal_start_thread(_adapter * padapter)463 void rtw_hal_start_thread(_adapter *padapter)
464 {
465 #if defined(CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
466 #ifndef CONFIG_SDIO_TX_TASKLET
467 padapter->HalFunc.run_thread(padapter);
468 #endif
469 #endif
470 }
471 /* Start specifical interface thread */
rtw_hal_stop_thread(_adapter * padapter)472 void rtw_hal_stop_thread(_adapter *padapter)
473 {
474 #if defined(CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
475 #ifndef CONFIG_SDIO_TX_TASKLET
476
477 padapter->HalFunc.cancel_thread(padapter);
478
479 #endif
480 #endif
481 }
482
rtw_hal_read_bbreg(_adapter * padapter,u32 RegAddr,u32 BitMask)483 u32 rtw_hal_read_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask)
484 {
485 u32 data = 0;
486 if(padapter->HalFunc.read_bbreg)
487 data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask);
488 return data;
489 }
rtw_hal_write_bbreg(_adapter * padapter,u32 RegAddr,u32 BitMask,u32 Data)490 void rtw_hal_write_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
491 {
492 if(padapter->HalFunc.write_bbreg)
493 padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data);
494 }
495
rtw_hal_read_rfreg(_adapter * padapter,u32 eRFPath,u32 RegAddr,u32 BitMask)496 u32 rtw_hal_read_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
497 {
498 u32 data = 0;
499
500 if (padapter->HalFunc.read_rfreg) {
501 data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
502
503 if (match_rf_read_sniff_ranges(eRFPath, RegAddr, BitMask)) {
504 DBG_871X("DBG_IO rtw_hal_read_rfreg(%u, 0x%04x, 0x%08x) read:0x%08x(0x%08x)\n"
505 , eRFPath, RegAddr, BitMask, (data << PHY_CalculateBitShift(BitMask)), data);
506 }
507 }
508
509 return data;
510 }
511
rtw_hal_write_rfreg(_adapter * padapter,u32 eRFPath,u32 RegAddr,u32 BitMask,u32 Data)512 void rtw_hal_write_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
513 {
514 if (padapter->HalFunc.write_rfreg) {
515
516 if (match_rf_write_sniff_ranges(eRFPath, RegAddr, BitMask)) {
517 DBG_871X("DBG_IO rtw_hal_write_rfreg(%u, 0x%04x, 0x%08x) write:0x%08x(0x%08x)\n"
518 , eRFPath, RegAddr, BitMask, (Data << PHY_CalculateBitShift(BitMask)), Data);
519 }
520
521 padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
522
523 #ifdef CONFIG_PCI_HCI
524 if (!IS_HARDWARE_TYPE_JAGUAR_AND_JAGUAR2(padapter)) /*For N-Series IC, suggest by Jenyu*/
525 rtw_udelay_os(2);
526 #endif
527 }
528 }
529
530 #if defined(CONFIG_PCI_HCI)
rtw_hal_interrupt_handler(_adapter * padapter)531 s32 rtw_hal_interrupt_handler(_adapter *padapter)
532 {
533 s32 ret = _FAIL;
534 ret = padapter->HalFunc.interrupt_handler(padapter);
535 return ret;
536 }
537 #endif
538 #if defined(CONFIG_USB_HCI) && defined(CONFIG_SUPPORT_USB_INT)
rtw_hal_interrupt_handler(_adapter * padapter,u16 pkt_len,u8 * pbuf)539 void rtw_hal_interrupt_handler(_adapter *padapter, u16 pkt_len, u8 *pbuf)
540 {
541 padapter->HalFunc.interrupt_handler(padapter, pkt_len, pbuf);
542 }
543 #endif
544
rtw_hal_set_bwmode(_adapter * padapter,CHANNEL_WIDTH Bandwidth,u8 Offset)545 void rtw_hal_set_bwmode(_adapter *padapter, CHANNEL_WIDTH Bandwidth, u8 Offset)
546 {
547 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
548 PDM_ODM_T pDM_Odm = &(pHalData->odmpriv);
549
550 ODM_AcquireSpinLock( pDM_Odm, RT_IQK_SPINLOCK);
551 if(pDM_Odm->RFCalibrateInfo.bIQKInProgress == _TRUE)
552 DBG_871X_LEVEL(_drv_err_, "%s, %d, IQK may race condition\n", __func__,__LINE__);
553 ODM_ReleaseSpinLock( pDM_Odm, RT_IQK_SPINLOCK);
554 padapter->HalFunc.set_bwmode_handler(padapter, Bandwidth, Offset);
555
556 }
557
rtw_hal_set_chan(_adapter * padapter,u8 channel)558 void rtw_hal_set_chan(_adapter *padapter, u8 channel)
559 {
560 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
561 PDM_ODM_T pDM_Odm = &(pHalData->odmpriv);
562
563 ODM_AcquireSpinLock( pDM_Odm, RT_IQK_SPINLOCK);
564 if(pDM_Odm->RFCalibrateInfo.bIQKInProgress == _TRUE)
565 DBG_871X_LEVEL(_drv_err_, "%s, %d, IQK may race condition\n", __func__,__LINE__);
566 ODM_ReleaseSpinLock( pDM_Odm, RT_IQK_SPINLOCK);
567 padapter->HalFunc.set_channel_handler(padapter, channel);
568 }
569
rtw_hal_set_chnl_bw(_adapter * padapter,u8 channel,CHANNEL_WIDTH Bandwidth,u8 Offset40,u8 Offset80)570 void rtw_hal_set_chnl_bw(_adapter *padapter, u8 channel, CHANNEL_WIDTH Bandwidth, u8 Offset40, u8 Offset80)
571 {
572 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
573 PDM_ODM_T pDM_Odm = &(pHalData->odmpriv);
574
575 ODM_AcquireSpinLock( pDM_Odm, RT_IQK_SPINLOCK);
576 if(pDM_Odm->RFCalibrateInfo.bIQKInProgress == _TRUE)
577 DBG_871X_LEVEL(_drv_err_, "%s, %d, IQK may race condition\n", __func__,__LINE__);
578 ODM_ReleaseSpinLock( pDM_Odm, RT_IQK_SPINLOCK);
579 padapter->HalFunc.set_chnl_bw_handler(padapter, channel, Bandwidth, Offset40, Offset80);
580 }
581
rtw_hal_set_tx_power_level(_adapter * padapter,u8 channel)582 void rtw_hal_set_tx_power_level(_adapter *padapter, u8 channel)
583 {
584 if(padapter->HalFunc.set_tx_power_level_handler)
585 padapter->HalFunc.set_tx_power_level_handler(padapter, channel);
586 }
587
rtw_hal_get_tx_power_level(_adapter * padapter,s32 * powerlevel)588 void rtw_hal_get_tx_power_level(_adapter *padapter, s32 *powerlevel)
589 {
590 if(padapter->HalFunc.get_tx_power_level_handler)
591 padapter->HalFunc.get_tx_power_level_handler(padapter, powerlevel);
592 }
593
rtw_hal_dm_watchdog(_adapter * padapter)594 void rtw_hal_dm_watchdog(_adapter *padapter)
595 {
596 if (!is_primary_adapter(padapter))
597 return;
598
599 padapter->HalFunc.hal_dm_watchdog(padapter);
600
601 }
602
603 #ifdef CONFIG_LPS_LCLK_WD_TIMER
rtw_hal_dm_watchdog_in_lps(_adapter * padapter)604 void rtw_hal_dm_watchdog_in_lps(_adapter *padapter)
605 {
606 #if defined(CONFIG_CONCURRENT_MODE)
607 if (padapter->iface_type != IFACE_PORT0)
608 return;
609 #endif
610
611 if (adapter_to_pwrctl(padapter)->bFwCurrentInPSMode ==_TRUE ) {
612 padapter->HalFunc.hal_dm_watchdog_in_lps(padapter);//this fuction caller is in interrupt context
613 }
614 }
615 #endif
616
rtw_hal_bcn_related_reg_setting(_adapter * padapter)617 void rtw_hal_bcn_related_reg_setting(_adapter *padapter)
618 {
619 padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter);
620 }
621
622 #ifdef CONFIG_HOSTAPD_MLME
rtw_hal_hostap_mgnt_xmit_entry(_adapter * padapter,_pkt * pkt)623 s32 rtw_hal_hostap_mgnt_xmit_entry(_adapter *padapter, _pkt *pkt)
624 {
625 if(padapter->HalFunc.hostap_mgnt_xmit_entry)
626 return padapter->HalFunc.hostap_mgnt_xmit_entry(padapter, pkt);
627 return _FAIL;
628 }
629 #endif //CONFIG_HOSTAPD_MLME
630
631 #ifdef DBG_CONFIG_ERROR_DETECT
rtw_hal_sreset_init(_adapter * padapter)632 void rtw_hal_sreset_init(_adapter *padapter)
633 {
634 padapter->HalFunc.sreset_init_value(padapter);
635 }
rtw_hal_sreset_reset(_adapter * padapter)636 void rtw_hal_sreset_reset(_adapter *padapter)
637 {
638 padapter = GET_PRIMARY_ADAPTER(padapter);
639 padapter->HalFunc.silentreset(padapter);
640 }
641
rtw_hal_sreset_reset_value(_adapter * padapter)642 void rtw_hal_sreset_reset_value(_adapter *padapter)
643 {
644 padapter->HalFunc.sreset_reset_value(padapter);
645 }
646
rtw_hal_sreset_xmit_status_check(_adapter * padapter)647 void rtw_hal_sreset_xmit_status_check(_adapter *padapter)
648 {
649 if (!is_primary_adapter(padapter))
650 return;
651
652 padapter->HalFunc.sreset_xmit_status_check(padapter);
653 }
rtw_hal_sreset_linked_status_check(_adapter * padapter)654 void rtw_hal_sreset_linked_status_check(_adapter *padapter)
655 {
656 if (!is_primary_adapter(padapter))
657 return;
658 padapter->HalFunc.sreset_linked_status_check(padapter);
659 }
rtw_hal_sreset_get_wifi_status(_adapter * padapter)660 u8 rtw_hal_sreset_get_wifi_status(_adapter *padapter)
661 {
662 return padapter->HalFunc.sreset_get_wifi_status(padapter);
663 }
664
rtw_hal_sreset_inprogress(_adapter * padapter)665 bool rtw_hal_sreset_inprogress(_adapter *padapter)
666 {
667 padapter = GET_PRIMARY_ADAPTER(padapter);
668 return padapter->HalFunc.sreset_inprogress(padapter);
669 }
670 #endif //DBG_CONFIG_ERROR_DETECT
671
672 #ifdef CONFIG_IOL
rtw_hal_iol_cmd(ADAPTER * adapter,struct xmit_frame * xmit_frame,u32 max_wating_ms,u32 bndy_cnt)673 int rtw_hal_iol_cmd(ADAPTER *adapter, struct xmit_frame *xmit_frame, u32 max_wating_ms, u32 bndy_cnt)
674 {
675 if(adapter->HalFunc.IOL_exec_cmds_sync)
676 return adapter->HalFunc.IOL_exec_cmds_sync(adapter, xmit_frame, max_wating_ms,bndy_cnt);
677 return _FAIL;
678 }
679 #endif
680
681 #ifdef CONFIG_XMIT_THREAD_MODE
rtw_hal_xmit_thread_handler(_adapter * padapter)682 s32 rtw_hal_xmit_thread_handler(_adapter *padapter)
683 {
684 return padapter->HalFunc.xmit_thread_handler(padapter);
685 }
686 #endif
687
rtw_hal_notch_filter(_adapter * adapter,bool enable)688 void rtw_hal_notch_filter(_adapter *adapter, bool enable)
689 {
690 if(adapter->HalFunc.hal_notch_filter)
691 adapter->HalFunc.hal_notch_filter(adapter,enable);
692 }
693
rtw_hal_c2h_valid(_adapter * adapter,u8 * buf)694 bool rtw_hal_c2h_valid(_adapter *adapter, u8 *buf)
695 {
696 HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
697 HAL_VERSION *hal_ver = &HalData->VersionID;
698 bool ret = _FAIL;
699
700 if (IS_8188E(*hal_ver)) {
701 ret = c2h_evt_valid((struct c2h_evt_hdr *)buf);
702 } else if(IS_8192E(*hal_ver) || IS_8812_SERIES(*hal_ver) || IS_8821_SERIES(*hal_ver) || IS_8723B_SERIES(*hal_ver)) {
703 ret = c2h_evt_valid((struct c2h_evt_hdr_88xx*)buf);
704 } else {
705 rtw_warn_on(1);
706 }
707
708 return ret;
709 }
710
rtw_hal_c2h_evt_read(_adapter * adapter,u8 * buf)711 s32 rtw_hal_c2h_evt_read(_adapter *adapter, u8 *buf)
712 {
713 HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
714 HAL_VERSION *hal_ver = &HalData->VersionID;
715 s32 ret = _FAIL;
716
717 if (IS_8188E(*hal_ver)) {
718 ret = c2h_evt_read(adapter, buf);
719 } else if(IS_8192E(*hal_ver) || IS_8812_SERIES(*hal_ver) || IS_8821_SERIES(*hal_ver) || IS_8723B_SERIES(*hal_ver)) {
720 ret = c2h_evt_read_88xx(adapter, buf);
721 } else {
722 rtw_warn_on(1);
723 }
724
725 return ret;
726 }
727
rtw_hal_c2h_handler(_adapter * adapter,u8 * c2h_evt)728 s32 rtw_hal_c2h_handler(_adapter *adapter, u8 *c2h_evt)
729 {
730 s32 ret = _FAIL;
731 if (adapter->HalFunc.c2h_handler)
732 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
733 return ret;
734 }
735
rtw_hal_c2h_id_filter_ccx(_adapter * adapter)736 c2h_id_filter rtw_hal_c2h_id_filter_ccx(_adapter *adapter)
737 {
738 return adapter->HalFunc.c2h_id_filter_ccx;
739 }
740
rtw_hal_is_disable_sw_channel_plan(PADAPTER padapter)741 s32 rtw_hal_is_disable_sw_channel_plan(PADAPTER padapter)
742 {
743 return GET_HAL_DATA(padapter)->bDisableSWChannelPlan;
744 }
745
rtw_hal_macid_sleep(PADAPTER padapter,u8 macid)746 s32 rtw_hal_macid_sleep(PADAPTER padapter, u8 macid)
747 {
748 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
749 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
750 u8 support;
751
752 support = _FALSE;
753 rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
754 if (_FALSE == support)
755 return _FAIL;
756
757 if (macid >= macid_ctl->num) {
758 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT": Invalid macid(%u)\n",
759 FUNC_ADPT_ARG(padapter), macid);
760 return _FAIL;
761 }
762
763 rtw_hal_set_hwreg(padapter, HW_VAR_MACID_SLEEP, &macid);
764
765 return _SUCCESS;
766 }
767
rtw_hal_macid_wakeup(PADAPTER padapter,u8 macid)768 s32 rtw_hal_macid_wakeup(PADAPTER padapter, u8 macid)
769 {
770 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
771 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
772 u8 support;
773
774 support = _FALSE;
775 rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
776 if (_FALSE == support)
777 return _FAIL;
778
779 if (macid >= macid_ctl->num) {
780 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT": Invalid macid(%u)\n",
781 FUNC_ADPT_ARG(padapter), macid);
782 return _FAIL;
783 }
784
785 rtw_hal_set_hwreg(padapter, HW_VAR_MACID_WAKEUP, &macid);
786
787 return _SUCCESS;
788 }
789
rtw_hal_fill_h2c_cmd(PADAPTER padapter,u8 ElementID,u32 CmdLen,u8 * pCmdBuffer)790 s32 rtw_hal_fill_h2c_cmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
791 {
792 _adapter *pri_adapter = GET_PRIMARY_ADAPTER(padapter);
793
794 if (pri_adapter->bFWReady == _TRUE)
795 return padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
796 else if (padapter->registrypriv.mp_mode == 0)
797 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" FW doesn't exit when no MP mode, by pass H2C id:0x%02x\n"
798 , FUNC_ADPT_ARG(padapter), ElementID);
799 return _FAIL;
800 }
801
rtw_hal_fill_fake_txdesc(_adapter * padapter,u8 * pDesc,u32 BufferLen,u8 IsPsPoll,u8 IsBTQosNull,u8 bDataFrame)802 void rtw_hal_fill_fake_txdesc(_adapter* padapter, u8* pDesc, u32 BufferLen,
803 u8 IsPsPoll, u8 IsBTQosNull, u8 bDataFrame)
804 {
805 padapter->HalFunc.fill_fake_txdesc(padapter, pDesc, BufferLen,IsPsPoll, IsBTQosNull, bDataFrame);
806
807 }
rtw_hal_get_txbuff_rsvd_page_num(_adapter * adapter,bool wowlan)808 u8 rtw_hal_get_txbuff_rsvd_page_num(_adapter *adapter, bool wowlan)
809 {
810 return adapter->HalFunc.hal_get_tx_buff_rsvd_page_num(adapter, wowlan);
811 }
812
813 #ifdef CONFIG_GPIO_API
rtw_hal_update_hisr_hsisr_ind(_adapter * padapter,u32 flag)814 void rtw_hal_update_hisr_hsisr_ind(_adapter *padapter, u32 flag)
815 {
816 if (padapter->HalFunc.update_hisr_hsisr_ind)
817 padapter->HalFunc.update_hisr_hsisr_ind(padapter, flag);
818 }
819
rtw_hal_gpio_func_check(_adapter * padapter,u8 gpio_num)820 int rtw_hal_gpio_func_check(_adapter *padapter, u8 gpio_num)
821 {
822 int ret = _SUCCESS;
823
824 if (padapter->HalFunc.hal_gpio_func_check)
825 ret= padapter->HalFunc.hal_gpio_func_check(padapter, gpio_num);
826
827 return ret;
828 }
829
rtw_hal_gpio_multi_func_reset(_adapter * padapter,u8 gpio_num)830 void rtw_hal_gpio_multi_func_reset(_adapter *padapter, u8 gpio_num)
831 {
832 if (padapter->HalFunc.hal_gpio_multi_func_reset)
833 padapter->HalFunc.hal_gpio_multi_func_reset(padapter, gpio_num);
834 }
835 #endif
836
rtw_hal_fw_correct_bcn(_adapter * padapter)837 void rtw_hal_fw_correct_bcn(_adapter *padapter)
838 {
839 if (padapter->HalFunc.fw_correct_bcn)
840 padapter->HalFunc.fw_correct_bcn(padapter);
841 }
842
843 #define rtw_hal_error_msg(ops_fun) \
844 DBG_871X_LEVEL(_drv_always_, "### %s - Error : Please hook HalFunc.%s ###\n",__FUNCTION__,ops_fun)
845
rtw_hal_ops_check(_adapter * padapter)846 u8 rtw_hal_ops_check(_adapter *padapter)
847 {
848 u8 ret = _SUCCESS;
849 #if 1
850 /*** initialize section ***/
851 if (NULL == padapter->HalFunc.read_chip_version) {
852 rtw_hal_error_msg("read_chip_version");
853 ret = _FAIL;
854 }
855 if (NULL == padapter->HalFunc.init_default_value) {
856 rtw_hal_error_msg("init_default_value");
857 ret = _FAIL;
858 }
859 if (NULL == padapter->HalFunc.intf_chip_configure) {
860 rtw_hal_error_msg("intf_chip_configure");
861 ret = _FAIL;
862 }
863 if (NULL == padapter->HalFunc.read_adapter_info) {
864 rtw_hal_error_msg("read_adapter_info");
865 ret = _FAIL;
866 }
867
868 if (NULL == padapter->HalFunc.hal_power_on) {
869 rtw_hal_error_msg("hal_power_on");
870 ret = _FAIL;
871 }
872 if (NULL == padapter->HalFunc.hal_power_off) {
873 rtw_hal_error_msg("hal_power_off");
874 ret = _FAIL;
875 }
876
877 if (NULL == padapter->HalFunc.hal_init) {
878 rtw_hal_error_msg("hal_init");
879 ret = _FAIL;
880 }
881 if (NULL == padapter->HalFunc.hal_deinit) {
882 rtw_hal_error_msg("hal_deinit");
883 ret = _FAIL;
884 }
885
886 /*** xmit section ***/
887 if (NULL == padapter->HalFunc.init_xmit_priv) {
888 rtw_hal_error_msg("init_xmit_priv");
889 ret = _FAIL;
890 }
891 if (NULL == padapter->HalFunc.free_xmit_priv) {
892 rtw_hal_error_msg("free_xmit_priv");
893 ret = _FAIL;
894 }
895 if (NULL == padapter->HalFunc.hal_xmit) {
896 rtw_hal_error_msg("hal_xmit");
897 ret = _FAIL;
898 }
899 if (NULL == padapter->HalFunc.mgnt_xmit) {
900 rtw_hal_error_msg("mgnt_xmit");
901 ret = _FAIL;
902 }
903 #ifdef CONFIG_XMIT_THREAD_MODE
904 if (NULL == padapter->HalFunc.xmit_thread_handler) {
905 rtw_hal_error_msg("xmit_thread_handler");
906 ret = _FAIL;
907 }
908 #endif
909 if (NULL == padapter->HalFunc.hal_xmitframe_enqueue) {
910 rtw_hal_error_msg("hal_xmitframe_enqueue");
911 ret = _FAIL;
912 }
913 #if defined(CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
914 #ifndef CONFIG_SDIO_TX_TASKLET
915 if (NULL == padapter->HalFunc.run_thread) {
916 rtw_hal_error_msg("run_thread");
917 ret = _FAIL;
918 }
919 if (NULL == padapter->HalFunc.cancel_thread) {
920 rtw_hal_error_msg("cancel_thread");
921 ret = _FAIL;
922 }
923 #endif
924 #endif
925
926 /*** recv section ***/
927 if (NULL == padapter->HalFunc.init_recv_priv) {
928 rtw_hal_error_msg("init_recv_priv");
929 ret = _FAIL;
930 }
931 if (NULL == padapter->HalFunc.free_recv_priv) {
932 rtw_hal_error_msg("free_recv_priv");
933 ret = _FAIL;
934 }
935 #if defined(CONFIG_USB_HCI) || defined (CONFIG_PCI_HCI)
936 if (NULL == padapter->HalFunc.inirp_init) {
937 rtw_hal_error_msg("inirp_init");
938 ret = _FAIL;
939 }
940 if (NULL == padapter->HalFunc.inirp_deinit) {
941 rtw_hal_error_msg("inirp_deinit");
942 ret = _FAIL;
943 }
944 #endif //#if defined(CONFIG_USB_HCI) || defined (CONFIG_PCI_HCI)
945
946
947 /*** interrupt hdl section ***/
948 #if defined(CONFIG_PCI_HCI)
949 if (NULL == padapter->HalFunc.irp_reset) {
950 rtw_hal_error_msg("irp_reset");
951 ret = _FAIL;
952 }
953 #endif/*#if defined(CONFIG_PCI_HCI)*/
954 #if (defined(CONFIG_PCI_HCI)) || (defined(CONFIG_USB_HCI) && defined(CONFIG_SUPPORT_USB_INT))
955 if (NULL == padapter->HalFunc.interrupt_handler) {
956 rtw_hal_error_msg("interrupt_handler");
957 ret = _FAIL;
958 }
959 #endif /*#if (defined(CONFIG_PCI_HCI)) || (defined(CONFIG_USB_HCI) && defined(CONFIG_SUPPORT_USB_INT))*/
960
961 #if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
962 if (NULL == padapter->HalFunc.enable_interrupt) {
963 rtw_hal_error_msg("enable_interrupt");
964 ret = _FAIL;
965 }
966 if (NULL == padapter->HalFunc.disable_interrupt) {
967 rtw_hal_error_msg("disable_interrupt");
968 ret = _FAIL;
969 }
970 #endif //defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
971
972
973 /*** DM section ***/
974 if (NULL == padapter->HalFunc.dm_init) {
975 rtw_hal_error_msg("dm_init");
976 ret = _FAIL;
977 }
978 if (NULL == padapter->HalFunc.dm_deinit) {
979 rtw_hal_error_msg("dm_deinit");
980 ret = _FAIL;
981 }
982 if (NULL == padapter->HalFunc.hal_dm_watchdog) {
983 rtw_hal_error_msg("hal_dm_watchdog");
984 ret = _FAIL;
985 }
986 #ifdef CONFIG_LPS_LCLK_WD_TIMER
987 if (NULL == padapter->HalFunc.hal_dm_watchdog_in_lps) {
988 rtw_hal_error_msg("hal_dm_watchdog_in_lps");
989 ret = _FAIL;
990 }
991 #endif
992
993 /*** xxx section ***/
994 if (NULL == padapter->HalFunc.set_bwmode_handler) {
995 rtw_hal_error_msg("set_bwmode_handler");
996 ret = _FAIL;
997 }
998
999 if (NULL == padapter->HalFunc.set_channel_handler) {
1000 rtw_hal_error_msg("set_channel_handler");
1001 ret = _FAIL;
1002 }
1003
1004 if (NULL == padapter->HalFunc.set_chnl_bw_handler) {
1005 rtw_hal_error_msg("set_chnl_bw_handler");
1006 ret = _FAIL;
1007 }
1008
1009 if (NULL == padapter->HalFunc.SetHwRegHandler) {
1010 rtw_hal_error_msg("SetHwRegHandler");
1011 ret = _FAIL;
1012 }
1013 if (NULL == padapter->HalFunc.GetHwRegHandler) {
1014 rtw_hal_error_msg("GetHwRegHandler");
1015 ret = _FAIL;
1016 }
1017 if (NULL == padapter->HalFunc.GetHalDefVarHandler) {
1018 rtw_hal_error_msg("GetHalDefVarHandler");
1019 ret = _FAIL;
1020 }
1021 if (NULL == padapter->HalFunc.SetHalDefVarHandler) {
1022 rtw_hal_error_msg("SetHalDefVarHandler");
1023 ret = _FAIL;
1024 }
1025 if (NULL == padapter->HalFunc.GetHalODMVarHandler) {
1026 rtw_hal_error_msg("GetHalODMVarHandler");
1027 ret = _FAIL;
1028 }
1029 if (NULL == padapter->HalFunc.SetHalODMVarHandler) {
1030 rtw_hal_error_msg("SetHalODMVarHandler");
1031 ret = _FAIL;
1032 }
1033 if (NULL == padapter->HalFunc.UpdateRAMaskHandler) {
1034 rtw_hal_error_msg("UpdateRAMaskHandler");
1035 ret = _FAIL;
1036 }
1037
1038 if (NULL == padapter->HalFunc.SetBeaconRelatedRegistersHandler) {
1039 rtw_hal_error_msg("SetBeaconRelatedRegistersHandler");
1040 ret = _FAIL;
1041 }
1042
1043 if (NULL == padapter->HalFunc.Add_RateATid) {
1044 rtw_hal_error_msg("Add_RateATid");
1045 ret = _FAIL;
1046 }
1047
1048 if (NULL == padapter->HalFunc.fill_h2c_cmd) {
1049 rtw_hal_error_msg("fill_h2c_cmd");
1050 ret = _FAIL;
1051 }
1052 #if defined(CONFIG_LPS) || defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
1053 if (NULL == padapter->HalFunc.fill_fake_txdesc) {
1054 rtw_hal_error_msg("fill_fake_txdesc");
1055 ret = _FAIL;
1056 }
1057 #endif
1058 if (NULL == padapter->HalFunc.hal_get_tx_buff_rsvd_page_num) {
1059 rtw_hal_error_msg("hal_get_tx_buff_rsvd_page_num");
1060 ret = _FAIL;
1061 }
1062
1063 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
1064 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
1065 if (NULL == padapter->HalFunc.clear_interrupt) {
1066 rtw_hal_error_msg("clear_interrupt");
1067 ret = _FAIL;
1068 }
1069 #endif
1070 #endif /* CONFIG_WOWLAN */
1071
1072 if (NULL == padapter->HalFunc.fw_dl) {
1073 rtw_hal_error_msg("fw_dl");
1074 ret = _FAIL;
1075 }
1076
1077 if ((IS_HARDWARE_TYPE_8814A(padapter)
1078 || IS_HARDWARE_TYPE_8822BU(padapter) || IS_HARDWARE_TYPE_8822BS(padapter))
1079 && NULL == padapter->HalFunc.fw_correct_bcn) {
1080 rtw_hal_error_msg("fw_correct_bcn");
1081 ret = _FAIL;
1082 }
1083
1084
1085 /*** SReset section ***/
1086 #ifdef DBG_CONFIG_ERROR_DETECT
1087 if (NULL == padapter->HalFunc.sreset_init_value) {
1088 rtw_hal_error_msg("sreset_init_value");
1089 ret = _FAIL;
1090 }
1091 if (NULL == padapter->HalFunc.sreset_reset_value) {
1092 rtw_hal_error_msg("sreset_reset_value");
1093 ret = _FAIL;
1094 }
1095 if (NULL == padapter->HalFunc.silentreset) {
1096 rtw_hal_error_msg("silentreset");
1097 ret = _FAIL;
1098 }
1099 if (NULL == padapter->HalFunc.sreset_xmit_status_check) {
1100 rtw_hal_error_msg("sreset_xmit_status_check");
1101 ret = _FAIL;
1102 }
1103 if (NULL == padapter->HalFunc.sreset_linked_status_check) {
1104 rtw_hal_error_msg("sreset_linked_status_check");
1105 ret = _FAIL;
1106 }
1107 if (NULL == padapter->HalFunc.sreset_get_wifi_status) {
1108 rtw_hal_error_msg("sreset_get_wifi_status");
1109 ret = _FAIL;
1110 }
1111 if (NULL == padapter->HalFunc.sreset_inprogress) {
1112 rtw_hal_error_msg("sreset_inprogress");
1113 ret = _FAIL;
1114 }
1115 #endif //#ifdef DBG_CONFIG_ERROR_DETECT
1116
1117 #endif
1118 return ret;
1119 }
1120
1121