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