drivers/staging/rtl8723bs/hal/hal_intf.c

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