drivers/net/wireless/rockchip_wlan/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 void rtw_hal_chip_configure(_adapter *padapter)
  27 {
  28         if(padapter->HalFunc.intf_chip_configure)
  29                 padapter->HalFunc.intf_chip_configure(padapter);
  30 }
  31
  32 void rtw_hal_read_chip_info(_adapter *padapter)
  33 {
  34         if(padapter->HalFunc.read_adapter_info)
  35                 padapter->HalFunc.read_adapter_info(padapter);
  36 }
  37
  38 void rtw_hal_read_chip_version(_adapter *padapter)
  39 {
  40         if(padapter->HalFunc.read_chip_version)
  41                 padapter->HalFunc.read_chip_version(padapter);
  42 }
  43
  44 void rtw_hal_def_value_init(_adapter *padapter)
  45 {
  46         if (is_primary_adapter(padapter))
  47                 if(padapter->HalFunc.init_default_value)
  48                         padapter->HalFunc.init_default_value(padapter);
  49 }
  50 void    rtw_hal_free_data(_adapter *padapter)
  51 {
  52         if (is_primary_adapter(padapter))
  53                 if(padapter->HalFunc.free_hal_data)
  54                         padapter->HalFunc.free_hal_data(padapter);
  55 }
  56 void    rtw_hal_dm_init(_adapter *padapter)
  57 {
  58         if (is_primary_adapter(padapter))
  59                 if(padapter->HalFunc.dm_init)
  60                         padapter->HalFunc.dm_init(padapter);
  61 }
  62 void rtw_hal_dm_deinit(_adapter *padapter)
  63 {
  64         // cancel dm  timer
  65         if (is_primary_adapter(padapter))
  66                 if(padapter->HalFunc.dm_deinit)
  67                         padapter->HalFunc.dm_deinit(padapter);
  68 }
  69 void    rtw_hal_sw_led_init(_adapter *padapter)
  70 {
  71         if(padapter->HalFunc.InitSwLeds)
  72                 padapter->HalFunc.InitSwLeds(padapter);
  73 }
  74
  75 void rtw_hal_sw_led_deinit(_adapter *padapter)
  76 {
  77         if(padapter->HalFunc.DeInitSwLeds)
  78                 padapter->HalFunc.DeInitSwLeds(padapter);
  79 }
  80
  81 u32 rtw_hal_power_on(_adapter *padapter)
  82 {
  83         if(padapter->HalFunc.hal_power_on)
  84                 return padapter->HalFunc.hal_power_on(padapter);
  85         return _FAIL;
  86 }
  87 void rtw_hal_power_off(_adapter *padapter)
  88 {
  89         if(padapter->HalFunc.hal_power_off)
  90                 padapter->HalFunc.hal_power_off(padapter);
  91 }
  92
  93 void rtw_hal_init_opmode(_adapter *padapter)
  94 {
  95         NDIS_802_11_NETWORK_INFRASTRUCTURE networkType = Ndis802_11InfrastructureMax;
  96         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
  97         sint fw_state;
  98
  99         fw_state = get_fwstate(pmlmepriv);
 100
 101         if (fw_state & WIFI_ADHOC_STATE)
 102                 networkType = Ndis802_11IBSS;
 103         else if (fw_state & WIFI_STATION_STATE)
 104                 networkType = Ndis802_11Infrastructure;
 105         else if (fw_state & WIFI_AP_STATE)
 106                 networkType = Ndis802_11APMode;
 107         else
 108                 return;
 109
 110         rtw_setopmode_cmd(padapter, networkType, _FALSE);
 111 }
 112
 113 uint     rtw_hal_init(_adapter *padapter)
 114 {
 115         uint    status = _SUCCESS;
 116         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 117         int i;
 118
 119 #ifdef CONFIG_DUALMAC_CONCURRENT
 120         if(padapter->hw_init_completed == _TRUE)
 121         {
 122                 DBG_871X("rtw_hal_init: hw_init_completed == _TRUE\n");
 123                 return status;
 124         }
 125
 126         // before init mac0, driver must init mac1 first to avoid usb rx error.
 127         if((padapter->pbuddy_adapter != NULL) && (padapter->DualMacConcurrent == _TRUE)
 128                 && (padapter->adapter_type == PRIMARY_ADAPTER))
 129         {
 130                 if(padapter->pbuddy_adapter->hw_init_completed == _TRUE)
 131                 {
 132                         DBG_871X("rtw_hal_init: pbuddy_adapter hw_init_completed == _TRUE\n");
 133                 }
 134                 else
 135                 {
 136                         status =        padapter->HalFunc.hal_init(padapter->pbuddy_adapter);
 137                         if(status == _SUCCESS){
 138                                 padapter->pbuddy_adapter->hw_init_completed = _TRUE;
 139                         }
 140                         else{
 141                                 padapter->pbuddy_adapter->hw_init_completed = _FALSE;
 142                                 RT_TRACE(_module_hal_init_c_,_drv_err_,("rtw_hal_init: hal__init fail(pbuddy_adapter)\n"));
 143                                 DBG_871X("rtw_hal_init: hal__init fail(pbuddy_adapter)\n");
 144                                 return status;
 145                         }
 146                 }
 147         }
 148 #endif
 149
 150         status = padapter->HalFunc.hal_init(padapter);
 151
 152         if(status == _SUCCESS){
 153
 154                 rtw_hal_init_opmode(padapter);
 155
 156                 for (i = 0; i<dvobj->iface_nums; i++) {
 157                         padapter = dvobj->padapters[i];
 158                         padapter->hw_init_completed = _TRUE;
 159                 }
 160
 161                 if (padapter->registrypriv.notch_filter == 1)
 162                         rtw_hal_notch_filter(padapter, 1);
 163
 164                 rtw_hal_reset_security_engine(padapter);
 165                 rtw_sec_restore_wep_key(padapter);
 166
 167                 rtw_led_control(padapter, LED_CTL_POWER_ON);
 168
 169                 init_hw_mlme_ext(padapter);
 170         }
 171         else{
 172                 for (i = 0; i<dvobj->iface_nums; i++) {
 173                         padapter = dvobj->padapters[i];
 174                         padapter->hw_init_completed = _FALSE;
 175                 }
 176                 DBG_871X("rtw_hal_init: hal__init fail\n");
 177         }
 178
 179         RT_TRACE(_module_hal_init_c_,_drv_err_,("-rtl871x_hal_init:status=0x%x\n",status));
 180
 181         return status;
 182
 183 }
 184
 185 uint rtw_hal_deinit(_adapter *padapter)
 186 {
 187         uint    status = _SUCCESS;
 188         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 189         int i;
 190 _func_enter_;
 191
 192         status = padapter->HalFunc.hal_deinit(padapter);
 193
 194         if(status == _SUCCESS){
 195                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
 196                 for (i = 0; i<dvobj->iface_nums; i++) {
 197                         padapter = dvobj->padapters[i];
 198                         padapter->hw_init_completed = _FALSE;
 199                 }
 200         }
 201         else
 202         {
 203                 DBG_871X("\n rtw_hal_deinit: hal_init fail\n");
 204         }
 205
 206 _func_exit_;
 207
 208         return status;
 209 }
 210
 211 void rtw_hal_set_hwreg(_adapter *padapter, u8 variable, u8 *val)
 212 {
 213         if (padapter->HalFunc.SetHwRegHandler)
 214                 padapter->HalFunc.SetHwRegHandler(padapter, variable, val);
 215 }
 216
 217 void rtw_hal_get_hwreg(_adapter *padapter, u8 variable, u8 *val)
 218 {
 219         if (padapter->HalFunc.GetHwRegHandler)
 220                 padapter->HalFunc.GetHwRegHandler(padapter, variable, val);
 221 }
 222
 223 #ifdef CONFIG_C2H_PACKET_EN
 224 void rtw_hal_set_hwreg_with_buf(_adapter *padapter, u8 variable, u8 *pbuf, int len)
 225 {
 226         if (padapter->HalFunc.SetHwRegHandlerWithBuf)
 227                 padapter->HalFunc.SetHwRegHandlerWithBuf(padapter, variable, pbuf, len);
 228 }
 229 #endif
 230
 231 u8 rtw_hal_set_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
 232 {
 233         if(padapter->HalFunc.SetHalDefVarHandler)
 234                 return padapter->HalFunc.SetHalDefVarHandler(padapter,eVariable,pValue);
 235         return _FAIL;
 236 }
 237 u8 rtw_hal_get_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
 238 {
 239         if(padapter->HalFunc.GetHalDefVarHandler)
 240                 return padapter->HalFunc.GetHalDefVarHandler(padapter,eVariable,pValue);
 241         return _FAIL;
 242 }
 243
 244 void rtw_hal_set_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet)
 245 {
 246         if(padapter->HalFunc.SetHalODMVarHandler)
 247                 padapter->HalFunc.SetHalODMVarHandler(padapter,eVariable,pValue1,bSet);
 248 }
 249 void    rtw_hal_get_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet)
 250 {
 251         if(padapter->HalFunc.GetHalODMVarHandler)
 252                 padapter->HalFunc.GetHalODMVarHandler(padapter,eVariable,pValue1,bSet);
 253 }
 254
 255 void rtw_hal_enable_interrupt(_adapter *padapter)
 256 {
 257         if (padapter->HalFunc.enable_interrupt)
 258                 padapter->HalFunc.enable_interrupt(padapter);
 259         else
 260                 DBG_871X("%s: HalFunc.enable_interrupt is NULL!\n", __FUNCTION__);
 261
 262 }
 263 void rtw_hal_disable_interrupt(_adapter *padapter)
 264 {
 265         if (padapter->HalFunc.disable_interrupt)
 266                 padapter->HalFunc.disable_interrupt(padapter);
 267         else
 268                 DBG_871X("%s: HalFunc.disable_interrupt is NULL!\n", __FUNCTION__);
 269
 270 }
 271
 272 u8 rtw_hal_check_ips_status(_adapter *padapter)
 273 {
 274         u8 val = _FALSE;
 275         if (padapter->HalFunc.check_ips_status)
 276                 val = padapter->HalFunc.check_ips_status(padapter);
 277         else
 278                 DBG_871X("%s: HalFunc.check_ips_status is NULL!\n", __FUNCTION__);
 279
 280         return val;
 281 }
 282
 283 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
 284 void rtw_hal_clear_interrupt(_adapter *padapter)
 285 {
 286     if (padapter->HalFunc.clear_interrupt)
 287         padapter->HalFunc.clear_interrupt(padapter);
 288     else
 289         DBG_871X("%s: HalFunc.clear_interrupt is NULL!\n", __FUNCTION__);
 290
 291 }
 292 #endif
 293
 294 u32     rtw_hal_inirp_init(_adapter *padapter)
 295 {
 296         u32 rst = _FAIL;
 297         if(padapter->HalFunc.inirp_init)
 298                 rst = padapter->HalFunc.inirp_init(padapter);
 299         else
 300                 DBG_871X(" %s HalFunc.inirp_init is NULL!!!\n",__FUNCTION__);
 301         return rst;
 302 }
 303
 304 u32     rtw_hal_inirp_deinit(_adapter *padapter)
 305 {
 306
 307         if(padapter->HalFunc.inirp_deinit)
 308                 return padapter->HalFunc.inirp_deinit(padapter);
 309
 310         return _FAIL;
 311
 312 }
 313
 314 void    rtw_hal_irp_reset(_adapter *padapter)
 315 {
 316         if(padapter->HalFunc.irp_reset)
 317                 padapter->HalFunc.irp_reset(padapter);
 318         else
 319                 DBG_871X("%s: HalFunc.rtw_hal_irp_reset is NULL!\n", __FUNCTION__);
 320 }
 321
 322 u8      rtw_hal_intf_ps_func(_adapter *padapter,HAL_INTF_PS_FUNC efunc_id, u8* val)
 323 {
 324         if(padapter->HalFunc.interface_ps_func)
 325                 return padapter->HalFunc.interface_ps_func(padapter,efunc_id,val);
 326         return _FAIL;
 327 }
 328
 329 s32     rtw_hal_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
 330 {
 331         if(padapter->HalFunc.hal_xmitframe_enqueue)
 332                 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
 333
 334         return _FALSE;
 335 }
 336
 337 s32     rtw_hal_xmit(_adapter *padapter, struct xmit_frame *pxmitframe)
 338 {
 339         if(padapter->HalFunc.hal_xmit)
 340                 return padapter->HalFunc.hal_xmit(padapter, pxmitframe);
 341
 342         return _FALSE;
 343 }
 344
 345 /*
 346  * [IMPORTANT] This function would be run in interrupt context.
 347  */
 348 s32     rtw_hal_mgnt_xmit(_adapter *padapter, struct xmit_frame *pmgntframe)
 349 {
 350         s32 ret = _FAIL;
 351         unsigned char   *pframe;
 352         struct rtw_ieee80211_hdr        *pwlanhdr;
 353         update_mgntframe_attrib_addr(padapter, pmgntframe);
 354         //pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
 355         //pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 356         //_rtw_memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN);
 357
 358 #ifdef CONFIG_IEEE80211W
 359         if(padapter->securitypriv.binstallBIPkey == _TRUE)
 360         {
 361                 if(IS_MCAST(pmgntframe->attrib.ra))
 362                 {
 363                         pmgntframe->attrib.encrypt = _BIP_;
 364                         //pmgntframe->attrib.bswenc = _TRUE;
 365                 }
 366                 else
 367                 {
 368                         pmgntframe->attrib.encrypt = _AES_;
 369                         pmgntframe->attrib.bswenc = _TRUE;
 370                 }
 371                 rtw_mgmt_xmitframe_coalesce(padapter, pmgntframe->pkt, pmgntframe);
 372         }
 373 #endif //CONFIG_IEEE80211W
 374
 375         if(padapter->HalFunc.mgnt_xmit)
 376                 ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe);
 377         return ret;
 378 }
 379
 380 s32     rtw_hal_init_xmit_priv(_adapter *padapter)
 381 {
 382         if(padapter->HalFunc.init_xmit_priv != NULL)
 383                 return padapter->HalFunc.init_xmit_priv(padapter);
 384         return _FAIL;
 385 }
 386 void    rtw_hal_free_xmit_priv(_adapter *padapter)
 387 {
 388         if(padapter->HalFunc.free_xmit_priv != NULL)
 389                 padapter->HalFunc.free_xmit_priv(padapter);
 390 }
 391
 392 s32     rtw_hal_init_recv_priv(_adapter *padapter)
 393 {
 394         if(padapter->HalFunc.init_recv_priv)
 395                 return padapter->HalFunc.init_recv_priv(padapter);
 396
 397         return _FAIL;
 398 }
 399 void    rtw_hal_free_recv_priv(_adapter *padapter)
 400 {
 401
 402         if(padapter->HalFunc.free_recv_priv)
 403                 padapter->HalFunc.free_recv_priv(padapter);
 404 }
 405
 406 void rtw_hal_update_ra_mask(struct sta_info *psta, u8 rssi_level)
 407 {
 408         _adapter *padapter;
 409         struct mlme_priv *pmlmepriv;
 410
 411         if(!psta)
 412                 return;
 413
 414         padapter = psta->padapter;
 415
 416         pmlmepriv = &(padapter->mlmepriv);
 417
 418         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
 419         {
 420                 add_RATid(padapter, psta, rssi_level);
 421         }
 422         else
 423         {
 424                 if(padapter->HalFunc.UpdateRAMaskHandler)
 425                         padapter->HalFunc.UpdateRAMaskHandler(padapter, psta->mac_id, rssi_level);
 426         }
 427 }
 428
 429 void    rtw_hal_add_ra_tid(_adapter *padapter, u32 bitmap, u8* arg, u8 rssi_level)
 430 {
 431         if(padapter->HalFunc.Add_RateATid)
 432                 padapter->HalFunc.Add_RateATid(padapter, bitmap, arg, rssi_level);
 433 }
 434
 435 /*      Start specifical interface thread               */
 436 void    rtw_hal_start_thread(_adapter *padapter)
 437 {
 438         if(padapter->HalFunc.run_thread)
 439                 padapter->HalFunc.run_thread(padapter);
 440 }
 441 /*      Start specifical interface thread               */
 442 void    rtw_hal_stop_thread(_adapter *padapter)
 443 {
 444         if(padapter->HalFunc.cancel_thread)
 445                 padapter->HalFunc.cancel_thread(padapter);
 446 }
 447
 448 u32     rtw_hal_read_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask)
 449 {
 450         u32 data = 0;
 451         if(padapter->HalFunc.read_bbreg)
 452                  data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask);
 453         return data;
 454 }
 455 void    rtw_hal_write_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
 456 {
 457         if(padapter->HalFunc.write_bbreg)
 458                 padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data);
 459 }
 460
 461 u32     rtw_hal_read_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
 462 {
 463         u32 data = 0;
 464         if( padapter->HalFunc.read_rfreg)
 465                 data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
 466         return data;
 467 }
 468 void    rtw_hal_write_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
 469 {
 470         if(padapter->HalFunc.write_rfreg)
 471                 padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
 472 }
 473
 474 s32     rtw_hal_interrupt_handler(_adapter *padapter)
 475 {
 476         if(padapter->HalFunc.interrupt_handler)
 477                 return padapter->HalFunc.interrupt_handler(padapter);
 478         return _FAIL;
 479 }
 480
 481 void    rtw_hal_set_bwmode(_adapter *padapter, CHANNEL_WIDTH Bandwidth, u8 Offset)
 482 {
 483         if(padapter->HalFunc.set_bwmode_handler)
 484                 padapter->HalFunc.set_bwmode_handler(padapter, Bandwidth, Offset);
 485 }
 486
 487 void    rtw_hal_set_chan(_adapter *padapter, u8 channel)
 488 {
 489         if(padapter->HalFunc.set_channel_handler)
 490                 padapter->HalFunc.set_channel_handler(padapter, channel);
 491 }
 492
 493 void    rtw_hal_set_chnl_bw(_adapter *padapter, u8 channel, CHANNEL_WIDTH Bandwidth, u8 Offset40, u8 Offset80)
 494 {
 495         if(padapter->HalFunc.set_chnl_bw_handler)
 496                 padapter->HalFunc.set_chnl_bw_handler(padapter, channel, Bandwidth, Offset40, Offset80);
 497 }
 498
 499 void    rtw_hal_set_tx_power_level(_adapter *padapter, u8 channel)
 500 {
 501         if(padapter->HalFunc.set_tx_power_level_handler)
 502                 padapter->HalFunc.set_tx_power_level_handler(padapter, channel);
 503 }
 504
 505 void    rtw_hal_get_tx_power_level(_adapter *padapter, s32 *powerlevel)
 506 {
 507         if(padapter->HalFunc.get_tx_power_level_handler)
 508                 padapter->HalFunc.get_tx_power_level_handler(padapter, powerlevel);
 509 }
 510
 511 void    rtw_hal_dm_watchdog(_adapter *padapter)
 512 {
 513 #if defined(CONFIG_CONCURRENT_MODE)
 514         if (padapter->adapter_type != PRIMARY_ADAPTER)
 515                 return;
 516 #endif
 517
 518         if(padapter->HalFunc.hal_dm_watchdog)
 519                 padapter->HalFunc.hal_dm_watchdog(padapter);
 520
 521 }
 522
 523 void    rtw_hal_dm_watchdog_in_lps(_adapter *padapter)
 524 {
 525 #if defined(CONFIG_CONCURRENT_MODE)
 526         if (padapter->iface_type != IFACE_PORT0)
 527                 return;
 528 #endif
 529
 530         if (adapter_to_pwrctl(padapter)->bFwCurrentInPSMode ==_TRUE )
 531         {
 532                 if(padapter->HalFunc.hal_dm_watchdog_in_lps)
 533                 {
 534                         padapter->HalFunc.hal_dm_watchdog_in_lps(padapter);//this fuction caller is in interrupt context
 535                 }
 536         }
 537 }
 538
 539 void rtw_hal_bcn_related_reg_setting(_adapter *padapter)
 540 {
 541         if(padapter->HalFunc.SetBeaconRelatedRegistersHandler)
 542                 padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter);
 543 }
 544
 545
 546 #ifdef CONFIG_ANTENNA_DIVERSITY
 547 u8      rtw_hal_antdiv_before_linked(_adapter *padapter)
 548 {
 549         if(padapter->HalFunc.AntDivBeforeLinkHandler)
 550                 return padapter->HalFunc.AntDivBeforeLinkHandler(padapter);
 551         return _FALSE;
 552 }
 553 void    rtw_hal_antdiv_rssi_compared(_adapter *padapter, WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src)
 554 {
 555         if(padapter->HalFunc.AntDivCompareHandler)
 556                 padapter->HalFunc.AntDivCompareHandler(padapter, dst, src);
 557 }
 558 #endif
 559
 560 #ifdef CONFIG_HOSTAPD_MLME
 561 s32     rtw_hal_hostap_mgnt_xmit_entry(_adapter *padapter, _pkt *pkt)
 562 {
 563         if(padapter->HalFunc.hostap_mgnt_xmit_entry)
 564                 return padapter->HalFunc.hostap_mgnt_xmit_entry(padapter, pkt);
 565         return _FAIL;
 566 }
 567 #endif //CONFIG_HOSTAPD_MLME
 568
 569 #ifdef DBG_CONFIG_ERROR_DETECT
 570 void    rtw_hal_sreset_init(_adapter *padapter)
 571 {
 572         if(padapter->HalFunc.sreset_init_value)
 573                 padapter->HalFunc.sreset_init_value(padapter);
 574 }
 575 void rtw_hal_sreset_reset(_adapter *padapter)
 576 {
 577         padapter = GET_PRIMARY_ADAPTER(padapter);
 578
 579         if(padapter->HalFunc.silentreset)
 580                 padapter->HalFunc.silentreset(padapter);
 581 }
 582
 583 void rtw_hal_sreset_reset_value(_adapter *padapter)
 584 {
 585         if(padapter->HalFunc.sreset_reset_value)
 586                 padapter->HalFunc.sreset_reset_value(padapter);
 587 }
 588
 589 void rtw_hal_sreset_xmit_status_check(_adapter *padapter)
 590 {
 591         if (!is_primary_adapter(padapter))
 592                 return;
 593
 594         if(padapter->HalFunc.sreset_xmit_status_check)
 595                 padapter->HalFunc.sreset_xmit_status_check(padapter);
 596 }
 597 void rtw_hal_sreset_linked_status_check(_adapter *padapter)
 598 {
 599         if (!is_primary_adapter(padapter))
 600                 return;
 601
 602         if(padapter->HalFunc.sreset_linked_status_check)
 603                 padapter->HalFunc.sreset_linked_status_check(padapter);
 604 }
 605 u8   rtw_hal_sreset_get_wifi_status(_adapter *padapter)
 606 {
 607         u8 status = 0;
 608         if(padapter->HalFunc.sreset_get_wifi_status)
 609                 status = padapter->HalFunc.sreset_get_wifi_status(padapter);
 610         return status;
 611 }
 612
 613 bool rtw_hal_sreset_inprogress(_adapter *padapter)
 614 {
 615         bool inprogress = _FALSE;
 616
 617         padapter = GET_PRIMARY_ADAPTER(padapter);
 618
 619         if(padapter->HalFunc.sreset_inprogress)
 620                 inprogress = padapter->HalFunc.sreset_inprogress(padapter);
 621         return inprogress;
 622 }
 623 #endif  //DBG_CONFIG_ERROR_DETECT
 624
 625 #ifdef CONFIG_IOL
 626 int rtw_hal_iol_cmd(ADAPTER *adapter, struct xmit_frame *xmit_frame, u32 max_wating_ms, u32 bndy_cnt)
 627 {
 628         if(adapter->HalFunc.IOL_exec_cmds_sync)
 629                 return adapter->HalFunc.IOL_exec_cmds_sync(adapter, xmit_frame, max_wating_ms,bndy_cnt);
 630         return _FAIL;
 631 }
 632 #endif
 633
 634 #ifdef CONFIG_XMIT_THREAD_MODE
 635 s32 rtw_hal_xmit_thread_handler(_adapter *padapter)
 636 {
 637         if(padapter->HalFunc.xmit_thread_handler)
 638                 return padapter->HalFunc.xmit_thread_handler(padapter);
 639         return _FAIL;
 640 }
 641 #endif
 642
 643 void rtw_hal_notch_filter(_adapter *adapter, bool enable)
 644 {
 645         if(adapter->HalFunc.hal_notch_filter)
 646                 adapter->HalFunc.hal_notch_filter(adapter,enable);
 647 }
 648
 649 void rtw_hal_reset_security_engine(_adapter * adapter)
 650 {
 651         if(adapter->HalFunc.hal_reset_security_engine)
 652                 adapter->HalFunc.hal_reset_security_engine(adapter);
 653 }
 654
 655 bool rtw_hal_c2h_valid(_adapter *adapter, u8 *buf)
 656 {
 657         HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
 658         HAL_VERSION *hal_ver = &HalData->VersionID;
 659         bool ret = _FAIL;
 660
 661         if (IS_81XXC(*hal_ver) || IS_8723_SERIES(*hal_ver) ||IS_92D(*hal_ver) ||IS_8188E(*hal_ver)) {
 662                 ret = c2h_evt_valid((struct c2h_evt_hdr *)buf);
 663         } else if(IS_8192E(*hal_ver) || IS_8812_SERIES(*hal_ver) || IS_8821_SERIES(*hal_ver) || IS_8723B_SERIES(*hal_ver)) {
 664                 ret = c2h_evt_valid((struct c2h_evt_hdr_88xx*)buf);
 665         } else {
 666                 rtw_warn_on(1);
 667         }
 668
 669         return ret;
 670 }
 671
 672 s32 rtw_hal_c2h_evt_read(_adapter *adapter, u8 *buf)
 673 {
 674         HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
 675         HAL_VERSION *hal_ver = &HalData->VersionID;
 676         s32 ret = _FAIL;
 677
 678         if (IS_81XXC(*hal_ver) || IS_8723_SERIES(*hal_ver) ||IS_92D(*hal_ver) ||IS_8188E(*hal_ver)) {
 679                 ret = c2h_evt_read(adapter, buf);
 680         } else if(IS_8192E(*hal_ver) || IS_8812_SERIES(*hal_ver) || IS_8821_SERIES(*hal_ver) || IS_8723B_SERIES(*hal_ver)) {
 681                 ret = c2h_evt_read_88xx(adapter, buf);
 682         } else {
 683                 rtw_warn_on(1);
 684         }
 685
 686         return ret;
 687 }
 688
 689 s32 rtw_hal_c2h_handler(_adapter *adapter, u8 *c2h_evt)
 690 {
 691         s32 ret = _FAIL;
 692         if (adapter->HalFunc.c2h_handler)
 693                 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
 694         return ret;
 695 }
 696
 697 c2h_id_filter rtw_hal_c2h_id_filter_ccx(_adapter *adapter)
 698 {
 699         return adapter->HalFunc.c2h_id_filter_ccx;
 700 }
 701
 702 s32 rtw_hal_is_disable_sw_channel_plan(PADAPTER padapter)
 703 {
 704         return GET_HAL_DATA(padapter)->bDisableSWChannelPlan;
 705 }
 706
 707 s32 rtw_hal_macid_sleep(PADAPTER padapter, u32 macid)
 708 {
 709         u8 support;
 710
 711
 712         support = _FALSE;
 713         rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
 714         if (_FALSE == support)
 715                 return _FAIL;
 716
 717         rtw_hal_set_hwreg(padapter, HW_VAR_MACID_SLEEP, (u8*)&macid);
 718
 719         return _SUCCESS;
 720 }
 721
 722 s32 rtw_hal_macid_wakeup(PADAPTER padapter, u32 macid)
 723 {
 724         u8 support;
 725
 726
 727         support = _FALSE;
 728         rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
 729         if (_FALSE == support)
 730                 return _FAIL;
 731
 732         rtw_hal_set_hwreg(padapter, HW_VAR_MACID_WAKEUP, (u8*)&macid);
 733
 734         return _SUCCESS;
 735 }
 736
 737 #ifdef CONFIG_BT_COEXIST
 738 s32 rtw_hal_fill_h2c_cmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
 739 {
 740         s32 ret = _FAIL;
 741
 742         if (padapter->HalFunc.fill_h2c_cmd)
 743                 ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
 744         else
 745         {
 746                 DBG_871X("%s:  func[fill_h2c_cmd] not defined!\n", __FUNCTION__);
 747         }
 748
 749         return ret;
 750 }
 751 #endif // CONFIG_BT_COEXIST
 752
 753