drivers/staging/rtl8723bs/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  ******************************************************************************/
  15
  16 #define _HAL_INTF_C_
  17
  18 #include <drv_types.h>
  19 #include <rtw_debug.h>
  20 #include <hal_data.h>
  21
  22 void rtw_hal_chip_configure(struct adapter *padapter)
  23 {
  24         if (padapter->HalFunc.intf_chip_configure)
  25                 padapter->HalFunc.intf_chip_configure(padapter);
  26 }
  27
  28 void rtw_hal_read_chip_info(struct adapter *padapter)
  29 {
  30         if (padapter->HalFunc.read_adapter_info)
  31                 padapter->HalFunc.read_adapter_info(padapter);
  32 }
  33
  34 void rtw_hal_read_chip_version(struct adapter *padapter)
  35 {
  36         if (padapter->HalFunc.read_chip_version)
  37                 padapter->HalFunc.read_chip_version(padapter);
  38 }
  39
  40 void rtw_hal_def_value_init(struct adapter *padapter)
  41 {
  42         if (is_primary_adapter(padapter))
  43                 if (padapter->HalFunc.init_default_value)
  44                         padapter->HalFunc.init_default_value(padapter);
  45 }
  46 void rtw_hal_free_data(struct adapter *padapter)
  47 {
  48         /* free HAL Data */
  49         rtw_hal_data_deinit(padapter);
  50
  51         if (is_primary_adapter(padapter))
  52                 if (padapter->HalFunc.free_hal_data)
  53                         padapter->HalFunc.free_hal_data(padapter);
  54 }
  55 void rtw_hal_dm_init(struct adapter *padapter)
  56 {
  57         if (is_primary_adapter(padapter))
  58                 if (padapter->HalFunc.dm_init)
  59                         padapter->HalFunc.dm_init(padapter);
  60 }
  61 void rtw_hal_dm_deinit(struct adapter *padapter)
  62 {
  63         /*  cancel dm  timer */
  64         if (is_primary_adapter(padapter))
  65                 if (padapter->HalFunc.dm_deinit)
  66                         padapter->HalFunc.dm_deinit(padapter);
  67 }
  68
  69 static void rtw_hal_init_opmode(struct adapter *padapter)
  70 {
  71         enum NDIS_802_11_NETWORK_INFRASTRUCTURE networkType = Ndis802_11InfrastructureMax;
  72         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
  73         sint fw_state;
  74
  75         fw_state = get_fwstate(pmlmepriv);
  76
  77         if (fw_state & WIFI_ADHOC_STATE)
  78                 networkType = Ndis802_11IBSS;
  79         else if (fw_state & WIFI_STATION_STATE)
  80                 networkType = Ndis802_11Infrastructure;
  81         else if (fw_state & WIFI_AP_STATE)
  82                 networkType = Ndis802_11APMode;
  83         else
  84                 return;
  85
  86         rtw_setopmode_cmd(padapter, networkType, false);
  87 }
  88
  89 uint     rtw_hal_init(struct adapter *padapter)
  90 {
  91         uint    status;
  92         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
  93
  94         status = padapter->HalFunc.hal_init(padapter);
  95
  96         if (status == _SUCCESS) {
  97                 rtw_hal_init_opmode(padapter);
  98
  99                 dvobj->padapters->hw_init_completed = true;
 100
 101                 if (padapter->registrypriv.notch_filter == 1)
 102                         rtw_hal_notch_filter(padapter, 1);
 103
 104                 rtw_hal_reset_security_engine(padapter);
 105
 106                 rtw_sec_restore_wep_key(dvobj->padapters);
 107
 108                 init_hw_mlme_ext(padapter);
 109
 110                 rtw_bb_rf_gain_offset(padapter);
 111         } else {
 112                 dvobj->padapters->hw_init_completed = false;
 113                 DBG_871X("rtw_hal_init: hal__init fail\n");
 114         }
 115
 116         RT_TRACE(_module_hal_init_c_, _drv_err_, ("-rtl871x_hal_init:status = 0x%x\n", status));
 117
 118         return status;
 119
 120 }
 121
 122 uint rtw_hal_deinit(struct adapter *padapter)
 123 {
 124         uint    status = _SUCCESS;
 125         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 126
 127         status = padapter->HalFunc.hal_deinit(padapter);
 128
 129         if (status == _SUCCESS) {
 130                 padapter = dvobj->padapters;
 131                 padapter->hw_init_completed = false;
 132         } else {
 133                 DBG_871X("\n rtw_hal_deinit: hal_init fail\n");
 134         }
 135         return status;
 136 }
 137
 138 void rtw_hal_set_hwreg(struct adapter *padapter, u8 variable, u8 *val)
 139 {
 140         if (padapter->HalFunc.SetHwRegHandler)
 141                 padapter->HalFunc.SetHwRegHandler(padapter, variable, val);
 142 }
 143
 144 void rtw_hal_get_hwreg(struct adapter *padapter, u8 variable, u8 *val)
 145 {
 146         if (padapter->HalFunc.GetHwRegHandler)
 147                 padapter->HalFunc.GetHwRegHandler(padapter, variable, val);
 148 }
 149
 150 void rtw_hal_set_hwreg_with_buf(struct adapter *padapter, u8 variable, u8 *pbuf, int len)
 151 {
 152         if (padapter->HalFunc.SetHwRegHandlerWithBuf)
 153                 padapter->HalFunc.SetHwRegHandlerWithBuf(padapter, variable, pbuf, len);
 154 }
 155
 156 u8 rtw_hal_set_def_var(struct adapter *padapter, enum HAL_DEF_VARIABLE eVariable, void *pValue)
 157 {
 158         if (padapter->HalFunc.SetHalDefVarHandler)
 159                 return padapter->HalFunc.SetHalDefVarHandler(padapter, eVariable, pValue);
 160         return _FAIL;
 161 }
 162 u8 rtw_hal_get_def_var(struct adapter *padapter, enum HAL_DEF_VARIABLE eVariable, void *pValue)
 163 {
 164         if (padapter->HalFunc.GetHalDefVarHandler)
 165                 return padapter->HalFunc.GetHalDefVarHandler(padapter, eVariable, pValue);
 166         return _FAIL;
 167 }
 168
 169 void rtw_hal_set_odm_var(struct adapter *padapter, enum HAL_ODM_VARIABLE eVariable, void *pValue1, bool bSet)
 170 {
 171         if (padapter->HalFunc.SetHalODMVarHandler)
 172                 padapter->HalFunc.SetHalODMVarHandler(padapter, eVariable, pValue1, bSet);
 173 }
 174 void rtw_hal_get_odm_var(struct adapter *padapter, enum HAL_ODM_VARIABLE eVariable, void *pValue1, void *pValue2)
 175 {
 176         if (padapter->HalFunc.GetHalODMVarHandler)
 177                 padapter->HalFunc.GetHalODMVarHandler(padapter, eVariable, pValue1, pValue2);
 178 }
 179
 180 void rtw_hal_enable_interrupt(struct adapter *padapter)
 181 {
 182         if (padapter->HalFunc.enable_interrupt)
 183                 padapter->HalFunc.enable_interrupt(padapter);
 184         else
 185                 DBG_871X("%s: HalFunc.enable_interrupt is NULL!\n", __func__);
 186
 187 }
 188 void rtw_hal_disable_interrupt(struct adapter *padapter)
 189 {
 190         if (padapter->HalFunc.disable_interrupt)
 191                 padapter->HalFunc.disable_interrupt(padapter);
 192         else
 193                 DBG_871X("%s: HalFunc.disable_interrupt is NULL!\n", __func__);
 194
 195 }
 196
 197 u8 rtw_hal_check_ips_status(struct adapter *padapter)
 198 {
 199         u8 val = false;
 200         if (padapter->HalFunc.check_ips_status)
 201                 val = padapter->HalFunc.check_ips_status(padapter);
 202         else
 203                 DBG_871X("%s: HalFunc.check_ips_status is NULL!\n", __func__);
 204
 205         return val;
 206 }
 207
 208 s32     rtw_hal_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
 209 {
 210         if (padapter->HalFunc.hal_xmitframe_enqueue)
 211                 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
 212
 213         return false;
 214 }
 215
 216 s32     rtw_hal_xmit(struct adapter *padapter, struct xmit_frame *pxmitframe)
 217 {
 218         if (padapter->HalFunc.hal_xmit)
 219                 return padapter->HalFunc.hal_xmit(padapter, pxmitframe);
 220
 221         return false;
 222 }
 223
 224 /*
 225  * [IMPORTANT] This function would be run in interrupt context.
 226  */
 227 s32     rtw_hal_mgnt_xmit(struct adapter *padapter, struct xmit_frame *pmgntframe)
 228 {
 229         s32 ret = _FAIL;
 230         update_mgntframe_attrib_addr(padapter, pmgntframe);
 231         /* pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET; */
 232         /* pwlanhdr = (struct rtw_ieee80211_hdr *)pframe; */
 233         /* memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN); */
 234
 235         if (padapter->securitypriv.binstallBIPkey == true)
 236         {
 237                 if (IS_MCAST(pmgntframe->attrib.ra))
 238                 {
 239                         pmgntframe->attrib.encrypt = _BIP_;
 240                         /* pmgntframe->attrib.bswenc = true; */
 241                 }
 242                 else
 243                 {
 244                         pmgntframe->attrib.encrypt = _AES_;
 245                         pmgntframe->attrib.bswenc = true;
 246                 }
 247                 rtw_mgmt_xmitframe_coalesce(padapter, pmgntframe->pkt, pmgntframe);
 248         }
 249
 250         if (padapter->HalFunc.mgnt_xmit)
 251                 ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe);
 252         return ret;
 253 }
 254
 255 s32     rtw_hal_init_xmit_priv(struct adapter *padapter)
 256 {
 257         if (padapter->HalFunc.init_xmit_priv != NULL)
 258                 return padapter->HalFunc.init_xmit_priv(padapter);
 259         return _FAIL;
 260 }
 261 void rtw_hal_free_xmit_priv(struct adapter *padapter)
 262 {
 263         if (padapter->HalFunc.free_xmit_priv != NULL)
 264                 padapter->HalFunc.free_xmit_priv(padapter);
 265 }
 266
 267 s32     rtw_hal_init_recv_priv(struct adapter *padapter)
 268 {
 269         if (padapter->HalFunc.init_recv_priv)
 270                 return padapter->HalFunc.init_recv_priv(padapter);
 271
 272         return _FAIL;
 273 }
 274 void rtw_hal_free_recv_priv(struct adapter *padapter)
 275 {
 276
 277         if (padapter->HalFunc.free_recv_priv)
 278                 padapter->HalFunc.free_recv_priv(padapter);
 279 }
 280
 281 void rtw_hal_update_ra_mask(struct sta_info *psta, u8 rssi_level)
 282 {
 283         struct adapter *padapter;
 284         struct mlme_priv *pmlmepriv;
 285
 286         if (!psta)
 287                 return;
 288
 289         padapter = psta->padapter;
 290
 291         pmlmepriv = &(padapter->mlmepriv);
 292
 293         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
 294         {
 295                 add_RATid(padapter, psta, rssi_level);
 296         }
 297         else
 298         {
 299                 if (padapter->HalFunc.UpdateRAMaskHandler)
 300                         padapter->HalFunc.UpdateRAMaskHandler(padapter, psta->mac_id, rssi_level);
 301         }
 302 }
 303
 304 void rtw_hal_add_ra_tid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level)
 305 {
 306         if (padapter->HalFunc.Add_RateATid)
 307                 padapter->HalFunc.Add_RateATid(padapter, bitmap, arg, rssi_level);
 308 }
 309
 310 /*Start specifical interface thread             */
 311 void rtw_hal_start_thread(struct adapter *padapter)
 312 {
 313         if (padapter->HalFunc.run_thread)
 314                 padapter->HalFunc.run_thread(padapter);
 315 }
 316 /*Start specifical interface thread             */
 317 void rtw_hal_stop_thread(struct adapter *padapter)
 318 {
 319         if (padapter->HalFunc.cancel_thread)
 320                 padapter->HalFunc.cancel_thread(padapter);
 321 }
 322
 323 u32 rtw_hal_read_bbreg(struct adapter *padapter, u32 RegAddr, u32 BitMask)
 324 {
 325         u32 data = 0;
 326         if (padapter->HalFunc.read_bbreg)
 327                  data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask);
 328         return data;
 329 }
 330 void rtw_hal_write_bbreg(struct adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
 331 {
 332         if (padapter->HalFunc.write_bbreg)
 333                 padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data);
 334 }
 335
 336 u32 rtw_hal_read_rfreg(struct adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
 337 {
 338         u32 data = 0;
 339         if (padapter->HalFunc.read_rfreg)
 340                 data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
 341         return data;
 342 }
 343 void rtw_hal_write_rfreg(struct adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
 344 {
 345         if (padapter->HalFunc.write_rfreg)
 346                 padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
 347 }
 348
 349 void rtw_hal_set_chan(struct adapter *padapter, u8 channel)
 350 {
 351         if (padapter->HalFunc.set_channel_handler)
 352                 padapter->HalFunc.set_channel_handler(padapter, channel);
 353 }
 354
 355 void rtw_hal_set_chnl_bw(struct adapter *padapter, u8 channel,
 356                          enum CHANNEL_WIDTH Bandwidth, u8 Offset40, u8 Offset80)
 357 {
 358         if (padapter->HalFunc.set_chnl_bw_handler)
 359                 padapter->HalFunc.set_chnl_bw_handler(padapter, channel,
 360                                                       Bandwidth, Offset40,
 361                                                       Offset80);
 362 }
 363
 364 void rtw_hal_dm_watchdog(struct adapter *padapter)
 365 {
 366         if (padapter->HalFunc.hal_dm_watchdog)
 367                 padapter->HalFunc.hal_dm_watchdog(padapter);
 368
 369 }
 370
 371 void rtw_hal_dm_watchdog_in_lps(struct adapter *padapter)
 372 {
 373         if (adapter_to_pwrctl(padapter)->bFwCurrentInPSMode ==true)
 374         {
 375                 if (padapter->HalFunc.hal_dm_watchdog_in_lps)
 376                 {
 377                         padapter->HalFunc.hal_dm_watchdog_in_lps(padapter);/* this fuction caller is in interrupt context */
 378                 }
 379         }
 380 }
 381
 382 void rtw_hal_bcn_related_reg_setting(struct adapter *padapter)
 383 {
 384         if (padapter->HalFunc.SetBeaconRelatedRegistersHandler)
 385                 padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter);
 386 }
 387
 388
 389 s32 rtw_hal_xmit_thread_handler(struct adapter *padapter)
 390 {
 391         if (padapter->HalFunc.xmit_thread_handler)
 392                 return padapter->HalFunc.xmit_thread_handler(padapter);
 393         return _FAIL;
 394 }
 395
 396 void rtw_hal_notch_filter(struct adapter *adapter, bool enable)
 397 {
 398         if (adapter->HalFunc.hal_notch_filter)
 399                 adapter->HalFunc.hal_notch_filter(adapter, enable);
 400 }
 401
 402 void rtw_hal_reset_security_engine(struct adapter * adapter)
 403 {
 404         if (adapter->HalFunc.hal_reset_security_engine)
 405                 adapter->HalFunc.hal_reset_security_engine(adapter);
 406 }
 407
 408 bool rtw_hal_c2h_valid(struct adapter *adapter, u8 *buf)
 409 {
 410         return c2h_evt_valid((struct c2h_evt_hdr_88xx*)buf);
 411 }
 412
 413 s32 rtw_hal_c2h_evt_read(struct adapter *adapter, u8 *buf)
 414 {
 415         return c2h_evt_read_88xx(adapter, buf);
 416 }
 417
 418 s32 rtw_hal_c2h_handler(struct adapter *adapter, u8 *c2h_evt)
 419 {
 420         s32 ret = _FAIL;
 421         if (adapter->HalFunc.c2h_handler)
 422                 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
 423         return ret;
 424 }
 425
 426 c2h_id_filter rtw_hal_c2h_id_filter_ccx(struct adapter *adapter)
 427 {
 428         return adapter->HalFunc.c2h_id_filter_ccx;
 429 }
 430
 431 s32 rtw_hal_is_disable_sw_channel_plan(struct adapter *padapter)
 432 {
 433         return GET_HAL_DATA(padapter)->bDisableSWChannelPlan;
 434 }
 435
 436 s32 rtw_hal_macid_sleep(struct adapter *padapter, u32 macid)
 437 {
 438         u8 support;
 439
 440
 441         support = false;
 442         rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
 443         if (false == support)
 444                 return _FAIL;
 445
 446         rtw_hal_set_hwreg(padapter, HW_VAR_MACID_SLEEP, (u8 *)&macid);
 447
 448         return _SUCCESS;
 449 }
 450
 451 s32 rtw_hal_macid_wakeup(struct adapter *padapter, u32 macid)
 452 {
 453         u8 support;
 454
 455
 456         support = false;
 457         rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
 458         if (false == support)
 459                 return _FAIL;
 460
 461         rtw_hal_set_hwreg(padapter, HW_VAR_MACID_WAKEUP, (u8 *)&macid);
 462
 463         return _SUCCESS;
 464 }
 465
 466 s32 rtw_hal_fill_h2c_cmd(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
 467 {
 468         s32 ret = _FAIL;
 469
 470         if (padapter->HalFunc.fill_h2c_cmd)
 471                 ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
 472         else
 473         {
 474                 DBG_871X("%s:  func[fill_h2c_cmd] not defined!\n", __func__);
 475         }
 476
 477         return ret;
 478 }