rtl8723bu/hal/hal_intf.c

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