drivers/net/wireless/rockchip_wlan/rtl8192du/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(padapter->HalFunc.init_default_value)
  58                 padapter->HalFunc.init_default_value(padapter);
  59 }
  60
  61 void rtw_hal_free_data(_adapter *padapter)
  62 {
  63         if(padapter->HalFunc.free_hal_data)
  64                 padapter->HalFunc.free_hal_data(padapter);
  65 }
  66
  67 void rtw_hal_dm_init(_adapter *padapter)
  68 {
  69         if(padapter->HalFunc.dm_init)
  70                 padapter->HalFunc.dm_init(padapter);
  71 }
  72
  73 void rtw_hal_dm_deinit(_adapter *padapter)
  74 {
  75         // cancel dm  timer
  76         if(padapter->HalFunc.dm_deinit)
  77                 padapter->HalFunc.dm_deinit(padapter);
  78 }
  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 uint     rtw_hal_init(_adapter *padapter)
  93 {
  94         uint    status = _SUCCESS;
  95
  96         if(padapter->hw_init_completed == _TRUE)
  97         {
  98                 DBG_871X("rtw_hal_init: hw_init_completed == _TRUE\n");
  99                 goto success;
 100         }
 101 #ifdef CONFIG_DEINIT_BEFORE_INIT
 102         status = padapter->HalFunc.hal_deinit(padapter);
 103         if(status != _SUCCESS){
 104                 DBG_871X("rtw_hal_init: hal_deinit before hal_init FAIL !!\n");
 105                 goto fail;
 106         }
 107 #endif
 108
 109 #ifdef CONFIG_DUALMAC_CONCURRENT
 110         // before init mac0, driver must init mac1 first to avoid usb rx error.
 111         if((padapter->pbuddy_adapter != NULL) && (padapter->DualMacConcurrent == _TRUE)
 112                 && (padapter->adapter_type == PRIMARY_ADAPTER))
 113         {
 114                 if(padapter->pbuddy_adapter->hw_init_completed == _TRUE)
 115                 {
 116                         DBG_871X("rtw_hal_init: pbuddy_adapter hw_init_completed == _TRUE\n");
 117                 }
 118                 else
 119                 {
 120 #ifdef CONFIG_DEINIT_BEFORE_INIT
 121                         status = padapter->HalFunc.hal_deinit(padapter->pbuddy_adapter);
 122                         if(status != _SUCCESS){
 123                                 DBG_871X("rtw_hal_init: hal_deinit before hal_init FAIL !!(pbuddy_adapter)\n");
 124                                 goto fail;
 125                         }
 126 #endif
 127                         status =        padapter->HalFunc.hal_init(padapter->pbuddy_adapter);
 128                         if(status == _SUCCESS){
 129                                 padapter->pbuddy_adapter->hw_init_completed = _TRUE;
 130                         }
 131                         else{
 132                                 padapter->pbuddy_adapter->hw_init_completed = _FALSE;
 133                                 RT_TRACE(_module_hal_init_c_,_drv_err_,("rtw_hal_init: hal__init fail(pbuddy_adapter)\n"));
 134                                 goto fail;
 135                         }
 136                 }
 137         }
 138 #else
 139         if(adapter_to_dvobj(padapter)->DualMacMode == _TRUE)
 140         {
 141                 if(padapter->pbuddy_adapter != NULL) {
 142                         if(padapter->pbuddy_adapter->hw_init_completed == _FALSE)
 143                         {
 144 #ifdef CONFIG_DEINIT_BEFORE_INIT
 145                                 status = padapter->HalFunc.hal_deinit(padapter->pbuddy_adapter);
 146                                 if(status != _SUCCESS){
 147                                         DBG_871X("rtw_hal_init: hal_deinit before hal_init FAIL !!(pbuddy_adapter)\n");
 148                                         goto fail;
 149                                 }
 150 #endif
 151                                 status = padapter->HalFunc.hal_init(padapter->pbuddy_adapter);
 152                                 if(status == _SUCCESS){
 153                                         padapter->pbuddy_adapter->hw_init_completed = _TRUE;
 154                                 }
 155                                 else{
 156                                         padapter->pbuddy_adapter->hw_init_completed = _FALSE;
 157                                         RT_TRACE(_module_hal_init_c_,_drv_err_,("rtw_hal_init: hal__init fail for another interface\n"));
 158                                 }
 159                         }
 160                 }
 161         }
 162 #endif
 163
 164         padapter->hw_init_completed=_FALSE;
 165
 166         status = padapter->HalFunc.hal_init(padapter);
 167
 168         if(status == _SUCCESS){
 169                 padapter->hw_init_completed = _TRUE;
 170         }
 171         else{
 172                 padapter->hw_init_completed = _FALSE;
 173                 RT_TRACE(_module_hal_init_c_,_drv_err_,("rtw_hal_init: hal__init fail\n"));
 174                 goto fail;
 175         }
 176
 177 success:
 178
 179         if (padapter->registrypriv.notch_filter == 1)
 180                 rtw_hal_notch_filter(padapter, 1);
 181
 182         rtw_hal_reset_security_engine(padapter);
 183
 184         rtw_sec_restore_wep_key(padapter);
 185
 186         rtw_led_control(padapter, LED_CTL_POWER_ON);
 187
 188         init_hw_mlme_ext(padapter);
 189
 190 fail:
 191
 192         RT_TRACE(_module_hal_init_c_,_drv_err_,("-rtl871x_hal_init:status=0x%x\n",status));
 193
 194         return status;
 195 }
 196
 197 uint rtw_hal_deinit(_adapter *padapter)
 198 {
 199         uint    status = _SUCCESS;
 200
 201 _func_enter_;
 202
 203         status = padapter->HalFunc.hal_deinit(padapter);
 204
 205         if(status == _SUCCESS){
 206                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
 207                 padapter->hw_init_completed = _FALSE;
 208         }
 209         else
 210         {
 211                 RT_TRACE(_module_hal_init_c_,_drv_err_,("\n rtw_hal_deinit: hal_init fail\n"));
 212         }
 213
 214 _func_exit_;
 215
 216         return status;
 217 }
 218
 219 void rtw_hal_set_hwreg(_adapter *padapter, u8 variable, u8 *val)
 220 {
 221         if (padapter->HalFunc.SetHwRegHandler)
 222                 padapter->HalFunc.SetHwRegHandler(padapter, variable, val);
 223 }
 224
 225 void rtw_hal_get_hwreg(_adapter *padapter, u8 variable, u8 *val)
 226 {
 227         if (padapter->HalFunc.GetHwRegHandler)
 228                 padapter->HalFunc.GetHwRegHandler(padapter, variable, val);
 229 }
 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
 238 u8 rtw_hal_get_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
 239 {
 240         if(padapter->HalFunc.GetHalDefVarHandler)
 241                 return padapter->HalFunc.GetHalDefVarHandler(padapter,eVariable,pValue);
 242         return _FAIL;
 243 }
 244
 245 void rtw_hal_enable_interrupt(_adapter *padapter)
 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 (padapter->HalFunc.disable_interrupt)
 256                 padapter->HalFunc.disable_interrupt(padapter);
 257         else
 258                 DBG_871X("%s: HalFunc.disable_interrupt is NULL!\n", __FUNCTION__);
 259
 260 }
 261
 262 u32     rtw_hal_inirp_init(_adapter *padapter)
 263 {
 264         u32 rst = _FAIL;
 265         if(padapter->HalFunc.inirp_init)
 266                 rst = padapter->HalFunc.inirp_init(padapter);
 267         else
 268                 DBG_871X(" %s HalFunc.inirp_init is NULL!!!\n",__FUNCTION__);
 269         return rst;
 270 }
 271
 272 u32     rtw_hal_inirp_deinit(_adapter *padapter)
 273 {
 274
 275         if(padapter->HalFunc.inirp_deinit)
 276                 return padapter->HalFunc.inirp_deinit(padapter);
 277
 278         return _FAIL;
 279
 280 }
 281
 282 u8 rtw_hal_intf_ps_func(_adapter *padapter,HAL_INTF_PS_FUNC efunc_id, u8* val)
 283 {
 284         if(padapter->HalFunc.interface_ps_func)
 285                 return padapter->HalFunc.interface_ps_func(padapter,efunc_id,val);
 286         return _FAIL;
 287 }
 288
 289 s32     rtw_hal_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
 290 {
 291         if(padapter->HalFunc.hal_xmitframe_enqueue)
 292                 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
 293
 294         return _FALSE;
 295 }
 296
 297 s32 rtw_hal_xmit(_adapter *padapter, struct xmit_frame *pxmitframe)
 298 {
 299         if(padapter->HalFunc.hal_xmit)
 300                 return padapter->HalFunc.hal_xmit(padapter, pxmitframe);
 301
 302         return _FALSE;
 303 }
 304
 305 s32     rtw_hal_mgnt_xmit(_adapter *padapter, struct xmit_frame *pmgntframe)
 306 {
 307         s32 ret = _FAIL;
 308         unsigned char   *pframe;
 309         struct rtw_ieee80211_hdr        *pwlanhdr;
 310
 311         pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
 312         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 313         _rtw_memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN);
 314
 315 #ifdef CONFIG_IEEE80211W
 316         if(padapter->securitypriv.binstallBIPkey == _TRUE)
 317         {
 318                 if(IS_MCAST(pmgntframe->attrib.ra))
 319                 {
 320                         pmgntframe->attrib.encrypt = _BIP_;
 321                         //pmgntframe->attrib.bswenc = _TRUE;
 322                 }
 323                 else
 324                 {
 325                         pmgntframe->attrib.encrypt = _AES_;
 326                         pmgntframe->attrib.bswenc = _TRUE;
 327                 }
 328                 rtw_mgmt_xmitframe_coalesce(padapter, pmgntframe->pkt, pmgntframe);
 329         }
 330 #endif //CONFIG_IEEE80211W
 331
 332         if(padapter->HalFunc.mgnt_xmit)
 333                 ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe);
 334         return ret;
 335 }
 336
 337 s32 rtw_hal_init_xmit_priv(_adapter *padapter)
 338 {
 339         if(padapter->HalFunc.init_xmit_priv != NULL)
 340                 return padapter->HalFunc.init_xmit_priv(padapter);
 341         return _FAIL;
 342 }
 343
 344 void rtw_hal_free_xmit_priv(_adapter *padapter)
 345 {
 346         if(padapter->HalFunc.free_xmit_priv != NULL)
 347                 padapter->HalFunc.free_xmit_priv(padapter);
 348 }
 349
 350 s32 rtw_hal_init_recv_priv(_adapter *padapter)
 351 {
 352         if(padapter->HalFunc.init_recv_priv)
 353                 return padapter->HalFunc.init_recv_priv(padapter);
 354
 355         return _FAIL;
 356 }
 357
 358 void rtw_hal_free_recv_priv(_adapter *padapter)
 359 {
 360         if(padapter->HalFunc.free_recv_priv)
 361                 padapter->HalFunc.free_recv_priv(padapter);
 362 }
 363
 364 void rtw_hal_update_ra_mask(_adapter *padapter, u32 mac_id)
 365 {
 366         if(padapter->HalFunc.UpdateRAMaskHandler)
 367                 padapter->HalFunc.UpdateRAMaskHandler(padapter,mac_id);
 368 }
 369
 370 void rtw_hal_add_ra_tid(_adapter *padapter, u32 bitmap, u8 arg)
 371 {
 372         if(padapter->HalFunc.Add_RateATid)
 373                 padapter->HalFunc.Add_RateATid(padapter, bitmap, arg);
 374 }
 375
 376 u32 rtw_hal_read_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask)
 377 {
 378         u32 data = 0;
 379         if (padapter->HalFunc.read_bbreg)
 380                 data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask);
 381         return data;
 382 }
 383
 384 void rtw_hal_write_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
 385 {
 386         if (padapter->HalFunc.write_bbreg)
 387                 padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data);
 388 }
 389
 390 u32 rtw_hal_read_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
 391 {
 392         u32 data = 0;
 393         if (padapter->HalFunc.read_rfreg)
 394                 data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
 395         return data;
 396 }
 397
 398 void rtw_hal_write_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
 399 {
 400         if (padapter->HalFunc.write_rfreg)
 401                 padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
 402 }
 403
 404 s32 rtw_hal_interrupt_handler(_adapter *padapter)
 405 {
 406         if(padapter->HalFunc.interrupt_handler)
 407                 return padapter->HalFunc.interrupt_handler(padapter);
 408         return _FAIL;
 409 }
 410
 411 void rtw_hal_set_bwmode(_adapter *padapter, HT_CHANNEL_WIDTH Bandwidth, u8 Offset)
 412 {
 413         if(padapter->HalFunc.set_bwmode_handler)
 414                 padapter->HalFunc.set_bwmode_handler(padapter, Bandwidth, Offset);
 415 }
 416
 417 void rtw_hal_set_chan(_adapter *padapter, u8 channel)
 418 {
 419         if(padapter->HalFunc.set_channel_handler)
 420                 padapter->HalFunc.set_channel_handler(padapter, channel);
 421 }
 422
 423 void rtw_hal_dm_watchdog(_adapter *padapter)
 424 {
 425         if(padapter->HalFunc.hal_dm_watchdog)
 426                 padapter->HalFunc.hal_dm_watchdog(padapter);
 427 }
 428
 429 void rtw_hal_bcn_related_reg_setting(_adapter *padapter)
 430 {
 431         if(padapter->HalFunc.SetBeaconRelatedRegistersHandler)
 432                 padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter);
 433 }
 434
 435 #ifdef CONFIG_ANTENNA_DIVERSITY
 436 u8 rtw_hal_antdiv_before_linked(_adapter *padapter)
 437 {
 438         if (padapter->HalFunc.AntDivBeforeLinkHandler)
 439                 return padapter->HalFunc.AntDivBeforeLinkHandler(padapter);
 440         return _FALSE;
 441 }
 442
 443 void rtw_hal_antdiv_rssi_compared(_adapter *padapter, WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src)
 444 {
 445         if (padapter->HalFunc.AntDivCompareHandler)
 446                 padapter->HalFunc.AntDivCompareHandler(padapter, dst, src);
 447 }
 448 #endif
 449
 450 #ifdef CONFIG_HOSTAPD_MLME
 451 s32     rtw_hal_hostap_mgnt_xmit_entry(_adapter *padapter, _pkt *pkt)
 452 {
 453         if (padapter->HalFunc.hostap_mgnt_xmit_entry)
 454                 return padapter->HalFunc.hostap_mgnt_xmit_entry(padapter, pkt);
 455         return _FAIL;
 456 }
 457 #endif //CONFIG_HOSTAPD_MLME
 458
 459 #ifdef DBG_CONFIG_ERROR_DETECT
 460 void rtw_hal_sreset_init(_adapter *padapter)
 461 {
 462         if(padapter->HalFunc.sreset_init_value)
 463                 padapter->HalFunc.sreset_init_value(padapter);
 464 }
 465
 466 void rtw_hal_sreset_reset(_adapter *padapter)
 467 {
 468         padapter = GET_PRIMARY_ADAPTER(padapter);
 469
 470         if(padapter->HalFunc.silentreset)
 471                 padapter->HalFunc.silentreset(padapter);
 472 }
 473
 474 void rtw_hal_sreset_reset_value(_adapter *padapter)
 475 {
 476         if(padapter->HalFunc.sreset_reset_value)
 477                 padapter->HalFunc.sreset_reset_value(padapter);
 478 }
 479
 480 void rtw_hal_sreset_xmit_status_check(_adapter *padapter)
 481 {
 482 #ifdef CONFIG_CONCURRENT_MODE
 483         if (padapter->adapter_type != PRIMARY_ADAPTER)
 484                 return;
 485 #endif
 486         if(padapter->HalFunc.sreset_xmit_status_check)
 487                 padapter->HalFunc.sreset_xmit_status_check(padapter);
 488 }
 489
 490 void rtw_hal_sreset_linked_status_check(_adapter *padapter)
 491 {
 492         if(padapter->HalFunc.sreset_linked_status_check)
 493                 padapter->HalFunc.sreset_linked_status_check(padapter);
 494 }
 495
 496 u8 rtw_hal_sreset_get_wifi_status(_adapter *padapter)
 497 {
 498         u8 status = 0;
 499         if(padapter->HalFunc.sreset_get_wifi_status)
 500                 status = padapter->HalFunc.sreset_get_wifi_status(padapter);
 501         return status;
 502 }
 503
 504 bool rtw_hal_sreset_inprogress(_adapter *padapter)
 505 {
 506         bool inprogress = _FALSE;
 507
 508         padapter = GET_PRIMARY_ADAPTER(padapter);
 509
 510         if(padapter->HalFunc.sreset_inprogress)
 511                 inprogress = padapter->HalFunc.sreset_inprogress(padapter);
 512         return inprogress;
 513 }
 514 #endif //DBG_CONFIG_ERROR_DETECT
 515
 516 #ifdef CONFIG_IOL
 517 int rtw_hal_iol_cmd(ADAPTER *adapter, struct xmit_frame *xmit_frame, u32 max_wating_ms)
 518 {
 519         if (adapter->HalFunc.IOL_exec_cmds_sync)
 520                 return adapter->HalFunc.IOL_exec_cmds_sync(adapter, xmit_frame, max_wating_ms);
 521         return _FAIL;
 522 }
 523 #endif
 524
 525 void rtw_hal_notch_filter(_adapter *adapter, bool enable)
 526 {
 527         if(adapter->HalFunc.hal_notch_filter)
 528                 adapter->HalFunc.hal_notch_filter(adapter,enable);
 529 }
 530
 531 void rtw_hal_reset_security_engine(_adapter * adapter)
 532 {
 533         if(adapter->HalFunc.hal_reset_security_engine)
 534                 adapter->HalFunc.hal_reset_security_engine(adapter);
 535 }
 536
 537 s32 rtw_hal_c2h_handler(_adapter *adapter, struct c2h_evt_hdr *c2h_evt)
 538 {
 539         s32 ret = _FAIL;
 540         if (adapter->HalFunc.c2h_handler)
 541                 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
 542         return ret;
 543 }
 544
 545 c2h_id_filter rtw_hal_c2h_id_filter_ccx(_adapter *adapter)
 546 {
 547         return adapter->HalFunc.c2h_id_filter_ccx;
 548 }
 549