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