drivers/staging/r8188eu/hal/hal_intf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2007 - 2012 Realtek Corporation. */
   3
   4 #define _HAL_INTF_C_
   5 #include "../include/osdep_service.h"
   6 #include "../include/drv_types.h"
   7 #include "../include/hal_intf.h"
   8
   9 void rtw_hal_chip_configure(struct adapter *adapt)
  10 {
  11         if (adapt->HalFunc.intf_chip_configure)
  12                 adapt->HalFunc.intf_chip_configure(adapt);
  13 }
  14
  15 void rtw_hal_read_chip_info(struct adapter *adapt)
  16 {
  17         if (adapt->HalFunc.read_adapter_info)
  18                 adapt->HalFunc.read_adapter_info(adapt);
  19 }
  20
  21 void rtw_hal_read_chip_version(struct adapter *adapt)
  22 {
  23         if (adapt->HalFunc.read_chip_version)
  24                 adapt->HalFunc.read_chip_version(adapt);
  25 }
  26
  27 void rtw_hal_def_value_init(struct adapter *adapt)
  28 {
  29         if (adapt->HalFunc.init_default_value)
  30                 adapt->HalFunc.init_default_value(adapt);
  31 }
  32
  33 void rtw_hal_free_data(struct adapter *adapt)
  34 {
  35         if (adapt->HalFunc.free_hal_data)
  36                 adapt->HalFunc.free_hal_data(adapt);
  37 }
  38
  39 void rtw_hal_dm_init(struct adapter *adapt)
  40 {
  41         if (adapt->HalFunc.dm_init)
  42                 adapt->HalFunc.dm_init(adapt);
  43 }
  44
  45 void rtw_hal_dm_deinit(struct adapter *adapt)
  46 {
  47         /*  cancel dm  timer */
  48         if (adapt->HalFunc.dm_deinit)
  49                 adapt->HalFunc.dm_deinit(adapt);
  50 }
  51
  52 void rtw_hal_sw_led_init(struct adapter *adapt)
  53 {
  54         if (adapt->HalFunc.InitSwLeds)
  55                 adapt->HalFunc.InitSwLeds(adapt);
  56 }
  57
  58 void rtw_hal_sw_led_deinit(struct adapter *adapt)
  59 {
  60         if (adapt->HalFunc.DeInitSwLeds)
  61                 adapt->HalFunc.DeInitSwLeds(adapt);
  62 }
  63
  64 u32 rtw_hal_power_on(struct adapter *adapt)
  65 {
  66         if (adapt->HalFunc.hal_power_on)
  67                 return adapt->HalFunc.hal_power_on(adapt);
  68         return _FAIL;
  69 }
  70
  71 uint     rtw_hal_init(struct adapter *adapt)
  72 {
  73         uint    status = _SUCCESS;
  74
  75         adapt->hw_init_completed = false;
  76
  77         status = adapt->HalFunc.hal_init(adapt);
  78
  79         if (status == _SUCCESS) {
  80                 adapt->hw_init_completed = true;
  81
  82                 if (adapt->registrypriv.notch_filter == 1)
  83                         rtw_hal_notch_filter(adapt, 1);
  84
  85                 rtw_hal_reset_security_engine(adapt);
  86         } else {
  87                 adapt->hw_init_completed = false;
  88                 DBG_88E("rtw_hal_init: hal__init fail\n");
  89         }
  90
  91         return status;
  92 }
  93
  94 uint rtw_hal_deinit(struct adapter *adapt)
  95 {
  96         uint    status = _SUCCESS;
  97
  98         status = adapt->HalFunc.hal_deinit(adapt);
  99
 100         if (status == _SUCCESS)
 101                 adapt->hw_init_completed = false;
 102         else
 103                 DBG_88E("\n rtw_hal_deinit: hal_init fail\n");
 104
 105         return status;
 106 }
 107
 108 void rtw_hal_set_hwreg(struct adapter *adapt, u8 variable, u8 *val)
 109 {
 110         if (adapt->HalFunc.SetHwRegHandler)
 111                 adapt->HalFunc.SetHwRegHandler(adapt, variable, val);
 112 }
 113
 114 void rtw_hal_get_hwreg(struct adapter *adapt, u8 variable, u8 *val)
 115 {
 116         if (adapt->HalFunc.GetHwRegHandler)
 117                 adapt->HalFunc.GetHwRegHandler(adapt, variable, val);
 118 }
 119
 120 u8 rtw_hal_set_def_var(struct adapter *adapt, enum hal_def_variable var,
 121                       void *val)
 122 {
 123         if (adapt->HalFunc.SetHalDefVarHandler)
 124                 return adapt->HalFunc.SetHalDefVarHandler(adapt, var, val);
 125         return _FAIL;
 126 }
 127
 128 u8 rtw_hal_get_def_var(struct adapter *adapt,
 129                        enum hal_def_variable var, void *val)
 130 {
 131         if (adapt->HalFunc.GetHalDefVarHandler)
 132                 return adapt->HalFunc.GetHalDefVarHandler(adapt, var, val);
 133         return _FAIL;
 134 }
 135
 136 void rtw_hal_set_odm_var(struct adapter *adapt,
 137                          enum hal_odm_variable var, void *val1,
 138                          bool set)
 139 {
 140         if (adapt->HalFunc.SetHalODMVarHandler)
 141                 adapt->HalFunc.SetHalODMVarHandler(adapt, var,
 142                                                       val1, set);
 143 }
 144
 145 void rtw_hal_get_odm_var(struct adapter *adapt,
 146                          enum hal_odm_variable var, void *val1,
 147                          bool set)
 148 {
 149         if (adapt->HalFunc.GetHalODMVarHandler)
 150                 adapt->HalFunc.GetHalODMVarHandler(adapt, var,
 151                                                       val1, set);
 152 }
 153
 154 void rtw_hal_enable_interrupt(struct adapter *adapt)
 155 {
 156         if (adapt->HalFunc.enable_interrupt)
 157                 adapt->HalFunc.enable_interrupt(adapt);
 158         else
 159                 DBG_88E("%s: HalFunc.enable_interrupt is NULL!\n", __func__);
 160 }
 161
 162 void rtw_hal_disable_interrupt(struct adapter *adapt)
 163 {
 164         if (adapt->HalFunc.disable_interrupt)
 165                 adapt->HalFunc.disable_interrupt(adapt);
 166         else
 167                 DBG_88E("%s: HalFunc.disable_interrupt is NULL!\n", __func__);
 168 }
 169
 170 u32 rtw_hal_inirp_init(struct adapter *adapt)
 171 {
 172         u32 rst = _FAIL;
 173
 174         if (adapt->HalFunc.inirp_init)
 175                 rst = adapt->HalFunc.inirp_init(adapt);
 176         else
 177                 DBG_88E(" %s HalFunc.inirp_init is NULL!!!\n", __func__);
 178         return rst;
 179 }
 180
 181 u32 rtw_hal_inirp_deinit(struct adapter *adapt)
 182 {
 183         if (adapt->HalFunc.inirp_deinit)
 184                 return adapt->HalFunc.inirp_deinit(adapt);
 185
 186         return _FAIL;
 187 }
 188
 189 u8 rtw_hal_intf_ps_func(struct adapter *adapt,
 190                         enum hal_intf_ps_func efunc_id, u8 *val)
 191 {
 192         if (adapt->HalFunc.interface_ps_func)
 193                 return adapt->HalFunc.interface_ps_func(adapt, efunc_id,
 194                                                            val);
 195         return _FAIL;
 196 }
 197
 198 s32 rtw_hal_xmitframe_enqueue(struct adapter *padapter,
 199                               struct xmit_frame *pxmitframe)
 200 {
 201         if (padapter->HalFunc.hal_xmitframe_enqueue)
 202                 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
 203         return false;
 204 }
 205
 206 s32 rtw_hal_xmit(struct adapter *adapt, struct xmit_frame *pxmitframe)
 207 {
 208         if (adapt->HalFunc.hal_xmit)
 209                 return adapt->HalFunc.hal_xmit(adapt, pxmitframe);
 210
 211         return false;
 212 }
 213
 214 s32 rtw_hal_mgnt_xmit(struct adapter *adapt, struct xmit_frame *pmgntframe)
 215 {
 216         s32 ret = _FAIL;
 217         if (adapt->HalFunc.mgnt_xmit)
 218                 ret = adapt->HalFunc.mgnt_xmit(adapt, pmgntframe);
 219         return ret;
 220 }
 221
 222 s32 rtw_hal_init_xmit_priv(struct adapter *adapt)
 223 {
 224         if (adapt->HalFunc.init_xmit_priv)
 225                 return adapt->HalFunc.init_xmit_priv(adapt);
 226         return _FAIL;
 227 }
 228
 229 void rtw_hal_free_xmit_priv(struct adapter *adapt)
 230 {
 231         if (adapt->HalFunc.free_xmit_priv)
 232                 adapt->HalFunc.free_xmit_priv(adapt);
 233 }
 234
 235 s32 rtw_hal_init_recv_priv(struct adapter *adapt)
 236 {
 237         if (adapt->HalFunc.init_recv_priv)
 238                 return adapt->HalFunc.init_recv_priv(adapt);
 239
 240         return _FAIL;
 241 }
 242
 243 void rtw_hal_free_recv_priv(struct adapter *adapt)
 244 {
 245         if (adapt->HalFunc.free_recv_priv)
 246                 adapt->HalFunc.free_recv_priv(adapt);
 247 }
 248
 249 void rtw_hal_update_ra_mask(struct adapter *adapt, u32 mac_id, u8 rssi_level)
 250 {
 251         struct mlme_priv *pmlmepriv = &adapt->mlmepriv;
 252
 253         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
 254 #ifdef CONFIG_88EU_AP_MODE
 255                 struct sta_info *psta = NULL;
 256                 struct sta_priv *pstapriv = &adapt->stapriv;
 257                 if ((mac_id - 1) > 0)
 258                         psta = pstapriv->sta_aid[(mac_id - 1) - 1];
 259                 if (psta)
 260                         add_RATid(adapt, psta, 0);/* todo: based on rssi_level*/
 261 #endif
 262         } else {
 263                 if (adapt->HalFunc.UpdateRAMaskHandler)
 264                         adapt->HalFunc.UpdateRAMaskHandler(adapt, mac_id,
 265                                                               rssi_level);
 266         }
 267 }
 268
 269 void rtw_hal_add_ra_tid(struct adapter *adapt, u32 bitmap, u8 arg,
 270                         u8 rssi_level)
 271 {
 272         if (adapt->HalFunc.Add_RateATid)
 273                 adapt->HalFunc.Add_RateATid(adapt, bitmap, arg,
 274                                                rssi_level);
 275 }
 276
 277 /*      Start specifical interface thread               */
 278 void rtw_hal_start_thread(struct adapter *adapt)
 279 {
 280         if (adapt->HalFunc.run_thread)
 281                 adapt->HalFunc.run_thread(adapt);
 282 }
 283
 284 /*      Start specifical interface thread               */
 285 void rtw_hal_stop_thread(struct adapter *adapt)
 286 {
 287         if (adapt->HalFunc.cancel_thread)
 288                 adapt->HalFunc.cancel_thread(adapt);
 289 }
 290
 291 u32 rtw_hal_read_bbreg(struct adapter *adapt, u32 regaddr, u32 bitmask)
 292 {
 293         u32 data = 0;
 294
 295         if (adapt->HalFunc.read_bbreg)
 296                 data = adapt->HalFunc.read_bbreg(adapt, regaddr, bitmask);
 297         return data;
 298 }
 299
 300 void rtw_hal_write_bbreg(struct adapter *adapt, u32 regaddr, u32 bitmask,
 301                          u32 data)
 302 {
 303         if (adapt->HalFunc.write_bbreg)
 304                 adapt->HalFunc.write_bbreg(adapt, regaddr, bitmask, data);
 305 }
 306
 307 u32 rtw_hal_read_rfreg(struct adapter *adapt, enum rf_radio_path rfpath,
 308                        u32 regaddr, u32 bitmask)
 309 {
 310         u32 data = 0;
 311
 312         if (adapt->HalFunc.read_rfreg)
 313                 data = adapt->HalFunc.read_rfreg(adapt, rfpath, regaddr,
 314                                                     bitmask);
 315         return data;
 316 }
 317
 318 void rtw_hal_write_rfreg(struct adapter *adapt, enum rf_radio_path rfpath,
 319                          u32 regaddr, u32 bitmask, u32 data)
 320 {
 321         if (adapt->HalFunc.write_rfreg)
 322                 adapt->HalFunc.write_rfreg(adapt, rfpath, regaddr,
 323                                               bitmask, data);
 324 }
 325
 326 s32 rtw_hal_interrupt_handler(struct adapter *adapt)
 327 {
 328         if (adapt->HalFunc.interrupt_handler)
 329                 return adapt->HalFunc.interrupt_handler(adapt);
 330         return _FAIL;
 331 }
 332
 333 void rtw_hal_set_bwmode(struct adapter *adapt,
 334                         enum ht_channel_width bandwidth, u8 offset)
 335 {
 336         if (adapt->HalFunc.set_bwmode_handler)
 337                 adapt->HalFunc.set_bwmode_handler(adapt, bandwidth,
 338                                                      offset);
 339 }
 340
 341 void rtw_hal_set_chan(struct adapter *adapt, u8 channel)
 342 {
 343         if (adapt->HalFunc.set_channel_handler)
 344                 adapt->HalFunc.set_channel_handler(adapt, channel);
 345 }
 346
 347 void rtw_hal_dm_watchdog(struct adapter *adapt)
 348 {
 349         if (adapt->HalFunc.hal_dm_watchdog)
 350                 adapt->HalFunc.hal_dm_watchdog(adapt);
 351 }
 352
 353 void rtw_hal_bcn_related_reg_setting(struct adapter *adapt)
 354 {
 355         if (adapt->HalFunc.SetBeaconRelatedRegistersHandler)
 356                 adapt->HalFunc.SetBeaconRelatedRegistersHandler(adapt);
 357 }
 358
 359 u8 rtw_hal_antdiv_before_linked(struct adapter *adapt)
 360 {
 361         if (adapt->HalFunc.AntDivBeforeLinkHandler)
 362                 return adapt->HalFunc.AntDivBeforeLinkHandler(adapt);
 363         return false;
 364 }
 365
 366 void rtw_hal_antdiv_rssi_compared(struct adapter *adapt,
 367                                   struct wlan_bssid_ex *dst,
 368                                   struct wlan_bssid_ex *src)
 369 {
 370         if (adapt->HalFunc.AntDivCompareHandler)
 371                 adapt->HalFunc.AntDivCompareHandler(adapt, dst, src);
 372 }
 373
 374 void rtw_hal_sreset_init(struct adapter *adapt)
 375 {
 376         if (adapt->HalFunc.sreset_init_value)
 377                 adapt->HalFunc.sreset_init_value(adapt);
 378 }
 379
 380 void rtw_hal_sreset_reset(struct adapter *adapt)
 381 {
 382         if (adapt->HalFunc.silentreset)
 383                 adapt->HalFunc.silentreset(adapt);
 384 }
 385
 386 void rtw_hal_sreset_reset_value(struct adapter *adapt)
 387 {
 388         if (adapt->HalFunc.sreset_reset_value)
 389                 adapt->HalFunc.sreset_reset_value(adapt);
 390 }
 391
 392 void rtw_hal_sreset_xmit_status_check(struct adapter *adapt)
 393 {
 394         if (adapt->HalFunc.sreset_xmit_status_check)
 395                 adapt->HalFunc.sreset_xmit_status_check(adapt);
 396 }
 397
 398 void rtw_hal_sreset_linked_status_check(struct adapter *adapt)
 399 {
 400         if (adapt->HalFunc.sreset_linked_status_check)
 401                 adapt->HalFunc.sreset_linked_status_check(adapt);
 402 }
 403
 404 u8   rtw_hal_sreset_get_wifi_status(struct adapter *adapt)
 405 {
 406         u8 status = 0;
 407
 408         if (adapt->HalFunc.sreset_get_wifi_status)
 409                 status = adapt->HalFunc.sreset_get_wifi_status(adapt);
 410         return status;
 411 }
 412
 413 int rtw_hal_iol_cmd(struct adapter  *adapter, struct xmit_frame *xmit_frame,
 414                     u32 max_wating_ms, u32 bndy_cnt)
 415 {
 416         if (adapter->HalFunc.IOL_exec_cmds_sync)
 417                 return adapter->HalFunc.IOL_exec_cmds_sync(adapter, xmit_frame,
 418                                                            max_wating_ms,
 419                                                            bndy_cnt);
 420         return _FAIL;
 421 }
 422
 423 void rtw_hal_notch_filter(struct adapter *adapter, bool enable)
 424 {
 425         if (adapter->HalFunc.hal_notch_filter)
 426                 adapter->HalFunc.hal_notch_filter(adapter, enable);
 427 }
 428
 429 void rtw_hal_reset_security_engine(struct adapter *adapter)
 430 {
 431         if (adapter->HalFunc.hal_reset_security_engine)
 432                 adapter->HalFunc.hal_reset_security_engine(adapter);
 433 }
 434
 435 s32 rtw_hal_c2h_handler(struct adapter *adapter, struct c2h_evt_hdr *c2h_evt)
 436 {
 437         s32 ret = _FAIL;
 438
 439         if (adapter->HalFunc.c2h_handler)
 440                 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
 441         return ret;
 442 }
 443
 444 c2h_id_filter rtw_hal_c2h_id_filter_ccx(struct adapter *adapter)
 445 {
 446         return adapter->HalFunc.c2h_id_filter_ccx;
 447 }