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