drivers/staging/rtl8723au/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 #include <osdep_service.h>
  18 #include <drv_types.h>
  19
  20 #include <hal_intf.h>
  21
  22 #include <usb_hal.h>
  23
  24 void rtw_hal_chip_configure23a(struct rtw_adapter *padapter)
  25 {
  26         if (padapter->HalFunc.intf_chip_configure)
  27                 padapter->HalFunc.intf_chip_configure(padapter);
  28 }
  29
  30 void rtw_hal_read_chip_info23a(struct rtw_adapter *padapter)
  31 {
  32         if (padapter->HalFunc.read_adapter_info)
  33                 padapter->HalFunc.read_adapter_info(padapter);
  34 }
  35
  36 void rtw_hal_read_chip_version23a(struct rtw_adapter *padapter)
  37 {
  38         if (padapter->HalFunc.read_chip_version)
  39                 padapter->HalFunc.read_chip_version(padapter);
  40 }
  41
  42 void rtw_hal_def_value_init23a(struct rtw_adapter *padapter)
  43 {
  44         if (padapter->HalFunc.init_default_value)
  45                 padapter->HalFunc.init_default_value(padapter);
  46 }
  47 void    rtw_hal_free_data23a(struct rtw_adapter *padapter)
  48 {
  49         if (padapter->HalFunc.free_hal_data)
  50                 padapter->HalFunc.free_hal_data(padapter);
  51 }
  52 void    rtw_hal_dm_init23a(struct rtw_adapter *padapter)
  53 {
  54         if (padapter->HalFunc.dm_init)
  55                 padapter->HalFunc.dm_init(padapter);
  56 }
  57 void rtw_hal_dm_deinit23a(struct rtw_adapter *padapter)
  58 {
  59         /*  cancel dm  timer */
  60         if (padapter->HalFunc.dm_deinit)
  61                 padapter->HalFunc.dm_deinit(padapter);
  62 }
  63 void    rtw_hal_sw_led_init23a(struct rtw_adapter *padapter)
  64 {
  65         if (padapter->HalFunc.InitSwLeds)
  66                 padapter->HalFunc.InitSwLeds(padapter);
  67 }
  68
  69 void rtw_hal_sw_led_deinit23a(struct rtw_adapter *padapter)
  70 {
  71         if (padapter->HalFunc.DeInitSwLeds)
  72                 padapter->HalFunc.DeInitSwLeds(padapter);
  73 }
  74
  75 u32 rtw_hal_power_on23a(struct rtw_adapter *padapter)
  76 {
  77         if (padapter->HalFunc.hal_power_on)
  78                 return padapter->HalFunc.hal_power_on(padapter);
  79         return _FAIL;
  80 }
  81
  82 uint     rtw_hal_init23a(struct rtw_adapter *padapter)
  83 {
  84         uint    status = _SUCCESS;
  85
  86         padapter->hw_init_completed = false;
  87
  88         status = padapter->HalFunc.hal_init(padapter);
  89
  90         if (status == _SUCCESS) {
  91                 padapter->hw_init_completed = true;
  92
  93                 if (padapter->registrypriv.notch_filter == 1)
  94                         rtw_hal_notch_filter23a(padapter, 1);
  95
  96                 rtw_hal_reset_security_engine23a(padapter);
  97         } else {
  98                 padapter->hw_init_completed = false;
  99                 DBG_8723A("rtw_hal_init23a: hal__init fail\n");
 100         }
 101
 102         RT_TRACE(_module_hal_init_c_, _drv_err_, ("-rtl871x_hal_init:status = 0x%x\n", status));
 103
 104         return status;
 105 }
 106
 107 uint rtw_hal_deinit23a(struct rtw_adapter *padapter)
 108 {
 109         uint    status = _SUCCESS;
 110
 111         status = padapter->HalFunc.hal_deinit(padapter);
 112
 113         if (status == _SUCCESS)
 114                 padapter->hw_init_completed = false;
 115         else
 116                 DBG_8723A("\n rtw_hal_deinit23a: hal_init fail\n");
 117         return status;
 118 }
 119
 120 void rtw_hal_set_hwreg23a(struct rtw_adapter *padapter, u8 variable, u8 *val)
 121 {
 122         if (padapter->HalFunc.SetHwRegHandler)
 123                 padapter->HalFunc.SetHwRegHandler(padapter, variable, val);
 124 }
 125
 126 void rtw23a_hal_get_hwreg(struct rtw_adapter *padapter, u8 variable, u8 *val)
 127 {
 128         if (padapter->HalFunc.GetHwRegHandler)
 129                 padapter->HalFunc.GetHwRegHandler(padapter, variable, val);
 130 }
 131
 132 u8 rtw_hal_set_def_var23a(struct rtw_adapter *padapter, enum hal_def_variable eVariable, void *pValue)
 133 {
 134         if (padapter->HalFunc.SetHalDefVarHandler)
 135                 return padapter->HalFunc.SetHalDefVarHandler(padapter, eVariable, pValue);
 136         return _FAIL;
 137 }
 138 u8 rtw_hal_get_def_var23a(struct rtw_adapter *padapter, enum hal_def_variable eVariable, void *pValue)
 139 {
 140         if (padapter->HalFunc.GetHalDefVarHandler)
 141                 return padapter->HalFunc.GetHalDefVarHandler(padapter, eVariable, pValue);
 142         return _FAIL;
 143 }
 144
 145 void rtw_hal_set_odm_var23a(struct rtw_adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, bool bSet)
 146 {
 147         if (padapter->HalFunc.SetHalODMVarHandler)
 148                 padapter->HalFunc.SetHalODMVarHandler(padapter, eVariable, pValue1, bSet);
 149 }
 150 void    rtw_hal_get_odm_var23a(struct rtw_adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, bool bSet)
 151 {
 152         if (padapter->HalFunc.GetHalODMVarHandler)
 153                 padapter->HalFunc.GetHalODMVarHandler(padapter, eVariable, pValue1, bSet);
 154 }
 155
 156 void rtw_hal_enable_interrupt23a(struct rtw_adapter *padapter)
 157 {
 158         if (padapter->HalFunc.enable_interrupt)
 159                 padapter->HalFunc.enable_interrupt(padapter);
 160         else
 161                 DBG_8723A("%s: HalFunc.enable_interrupt is NULL!\n", __FUNCTION__);
 162
 163 }
 164 void rtw_hal_disable_interrupt23a(struct rtw_adapter *padapter)
 165 {
 166         if (padapter->HalFunc.disable_interrupt)
 167                 padapter->HalFunc.disable_interrupt(padapter);
 168         else
 169                 DBG_8723A("%s: HalFunc.disable_interrupt is NULL!\n", __FUNCTION__);
 170
 171 }
 172
 173 u32     rtw_hal_inirp_init23a(struct rtw_adapter *padapter)
 174 {
 175         u32 rst = _FAIL;
 176         if (padapter->HalFunc.inirp_init)
 177                 rst = padapter->HalFunc.inirp_init(padapter);
 178         else
 179                 DBG_8723A(" %s HalFunc.inirp_init is NULL!!!\n", __FUNCTION__);
 180         return rst;
 181 }
 182
 183 u32     rtw_hal_inirp_deinit23a(struct rtw_adapter *padapter)
 184 {
 185
 186         if (padapter->HalFunc.inirp_deinit)
 187                 return padapter->HalFunc.inirp_deinit(padapter);
 188
 189         return _FAIL;
 190
 191 }
 192
 193 u8      rtw_hal_intf_ps_func23a(struct rtw_adapter *padapter, enum hal_intf_ps_func efunc_id, u8 *val)
 194 {
 195         if (padapter->HalFunc.interface_ps_func)
 196                 return padapter->HalFunc.interface_ps_func(padapter, efunc_id, val);
 197         return _FAIL;
 198 }
 199
 200 s32     rtw_hal_xmit23aframe_enqueue(struct rtw_adapter *padapter, struct xmit_frame *pxmitframe)
 201 {
 202         if (padapter->HalFunc.hal_xmitframe_enqueue)
 203                 return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
 204
 205         return false;
 206 }
 207
 208 s32     rtw_hal_xmit23a(struct rtw_adapter *padapter, struct xmit_frame *pxmitframe)
 209 {
 210         if (padapter->HalFunc.hal_xmit)
 211                 return padapter->HalFunc.hal_xmit(padapter, pxmitframe);
 212
 213         return false;
 214 }
 215
 216 s32     rtw_hal_mgnt_xmit23a(struct rtw_adapter *padapter, struct xmit_frame *pmgntframe)
 217 {
 218         s32 ret = _FAIL;
 219         if (padapter->HalFunc.mgnt_xmit)
 220                 ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe);
 221         return ret;
 222 }
 223
 224 s32     rtw_hal_init23a_xmit_priv(struct rtw_adapter *padapter)
 225 {
 226         if (padapter->HalFunc.init_xmit_priv != NULL)
 227                 return padapter->HalFunc.init_xmit_priv(padapter);
 228         return _FAIL;
 229 }
 230 void    rtw_hal_free_xmit_priv23a(struct rtw_adapter *padapter)
 231 {
 232         if (padapter->HalFunc.free_xmit_priv != NULL)
 233                 padapter->HalFunc.free_xmit_priv(padapter);
 234 }
 235
 236 s32     rtw_hal_init23a_recv_priv(struct rtw_adapter *padapter)
 237 {
 238         if (padapter->HalFunc.init_recv_priv)
 239                 return padapter->HalFunc.init_recv_priv(padapter);
 240
 241         return _FAIL;
 242 }
 243 void    rtw_hal_free_recv_priv23a(struct rtw_adapter *padapter)
 244 {
 245         if (padapter->HalFunc.free_recv_priv)
 246                 padapter->HalFunc.free_recv_priv(padapter);
 247 }
 248
 249 void rtw_hal_update_ra_mask23a(struct sta_info *psta, u8 rssi_level)
 250 {
 251         struct rtw_adapter *padapter;
 252         struct mlme_priv *pmlmepriv;
 253
 254         if (!psta)
 255                 return;
 256
 257         padapter = psta->padapter;
 258
 259         pmlmepriv = &padapter->mlmepriv;
 260
 261         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 262 #ifdef CONFIG_8723AU_AP_MODE
 263                 add_RATid23a(padapter, psta, rssi_level);
 264 #endif
 265         } else {
 266                 if (padapter->HalFunc.UpdateRAMaskHandler)
 267                         padapter->HalFunc.UpdateRAMaskHandler(padapter, psta->mac_id, rssi_level);
 268         }
 269 }
 270
 271 void    rtw_hal_add_ra_tid23a(struct rtw_adapter *padapter, u32 bitmap, u8 arg, u8 rssi_level)
 272 {
 273         if (padapter->HalFunc.Add_RateATid)
 274                 padapter->HalFunc.Add_RateATid(padapter, bitmap, arg, rssi_level);
 275 }
 276
 277 /*      Start specifical interface thread               */
 278 void    rtw_hal_start_thread23a(struct rtw_adapter *padapter)
 279 {
 280         if (padapter->HalFunc.run_thread)
 281                 padapter->HalFunc.run_thread(padapter);
 282 }
 283 /*      Start specifical interface thread               */
 284 void    rtw_hal_stop_thread23a(struct rtw_adapter *padapter)
 285 {
 286         if (padapter->HalFunc.cancel_thread)
 287                 padapter->HalFunc.cancel_thread(padapter);
 288 }
 289
 290 u32     rtw_hal_read_bbreg23a(struct rtw_adapter *padapter, u32 RegAddr, u32 BitMask)
 291 {
 292         u32 data = 0;
 293         if (padapter->HalFunc.read_bbreg)
 294                  data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask);
 295         return data;
 296 }
 297 void    rtw_hal_write_bbreg23a(struct rtw_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
 298 {
 299         if (padapter->HalFunc.write_bbreg)
 300                 padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data);
 301 }
 302
 303 u32     rtw_hal_read_rfreg23a(struct rtw_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
 304 {
 305         u32 data = 0;
 306         if (padapter->HalFunc.read_rfreg)
 307                 data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
 308         return data;
 309 }
 310 void    rtw_hal_write_rfreg23a(struct rtw_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
 311 {
 312         if (padapter->HalFunc.write_rfreg)
 313                 padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
 314 }
 315
 316 s32     rtw_hal_interrupt_handler23a(struct rtw_adapter *padapter)
 317 {
 318         if (padapter->HalFunc.interrupt_handler)
 319                 return padapter->HalFunc.interrupt_handler(padapter);
 320         return _FAIL;
 321 }
 322
 323 void    rtw_hal_set_bwmode23a(struct rtw_adapter *padapter,
 324                            enum ht_channel_width Bandwidth, u8 offset)
 325 {
 326         if (padapter->HalFunc.set_bwmode_handler)
 327                 padapter->HalFunc.set_bwmode_handler(padapter, Bandwidth,
 328                                                      offset);
 329 }
 330
 331 void    rtw_hal_set_chan23a(struct rtw_adapter *padapter, u8 channel)
 332 {
 333         if (padapter->HalFunc.set_channel_handler)
 334                 padapter->HalFunc.set_channel_handler(padapter, channel);
 335 }
 336
 337 void    rtw_hal_dm_watchdog23a(struct rtw_adapter *padapter)
 338 {
 339         if (padapter->HalFunc.hal_dm_watchdog)
 340                 padapter->HalFunc.hal_dm_watchdog(padapter);
 341 }
 342
 343 void rtw_hal_bcn_related_reg_setting23a(struct rtw_adapter *padapter)
 344 {
 345         if (padapter->HalFunc.SetBeaconRelatedRegistersHandler)
 346                 padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter);
 347 }
 348
 349 void    rtw_hal_sreset_init23a(struct rtw_adapter *padapter)
 350 {
 351         if (padapter->HalFunc.sreset_init_value23a)
 352                 padapter->HalFunc.sreset_init_value23a(padapter);
 353 }
 354 void rtw_hal_sreset_reset23a(struct rtw_adapter *padapter)
 355 {
 356         padapter = GET_PRIMARY_ADAPTER(padapter);
 357
 358         if (padapter->HalFunc.silentreset)
 359                 padapter->HalFunc.silentreset(padapter);
 360 }
 361
 362 void rtw_hal_sreset_reset23a_value23a(struct rtw_adapter *padapter)
 363 {
 364         if (padapter->HalFunc.sreset_reset_value23a)
 365                 padapter->HalFunc.sreset_reset_value23a(padapter);
 366 }
 367
 368 void rtw_hal_sreset_xmit_status_check23a(struct rtw_adapter *padapter)
 369 {
 370         if (padapter->HalFunc.sreset_xmit_status_check)
 371                 padapter->HalFunc.sreset_xmit_status_check(padapter);
 372 }
 373 void rtw_hal_sreset_linked_status_check23a(struct rtw_adapter *padapter)
 374 {
 375         if (padapter->HalFunc.sreset_linked_status_check)
 376                 padapter->HalFunc.sreset_linked_status_check(padapter);
 377 }
 378 u8   rtw_hal_sreset_get_wifi_status23a(struct rtw_adapter *padapter)
 379 {
 380         u8 status = 0;
 381         if (padapter->HalFunc.sreset_get_wifi_status23a)
 382                 status = padapter->HalFunc.sreset_get_wifi_status23a(padapter);
 383         return status;
 384 }
 385
 386 bool rtw_hal_sreset_inprogress(struct rtw_adapter *padapter)
 387 {
 388         bool inprogress = false;
 389
 390         padapter = GET_PRIMARY_ADAPTER(padapter);
 391
 392         if (padapter->HalFunc.sreset_inprogress)
 393                 inprogress = padapter->HalFunc.sreset_inprogress(padapter);
 394         return inprogress;
 395 }
 396
 397 void rtw_hal_notch_filter23a(struct rtw_adapter *adapter, bool enable)
 398 {
 399         if (adapter->HalFunc.hal_notch_filter)
 400                 adapter->HalFunc.hal_notch_filter(adapter, enable);
 401 }
 402
 403 void rtw_hal_reset_security_engine23a(struct rtw_adapter *adapter)
 404 {
 405         if (adapter->HalFunc.hal_reset_security_engine)
 406                 adapter->HalFunc.hal_reset_security_engine(adapter);
 407 }
 408
 409 s32 rtw_hal_c2h_handler23a(struct rtw_adapter *adapter, struct c2h_evt_hdr *c2h_evt)
 410 {
 411         s32 ret = _FAIL;
 412         if (adapter->HalFunc.c2h_handler)
 413                 ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
 414         return ret;
 415 }
 416
 417 c2h_id_filter rtw_hal_c2h_id_filter_ccx23a(struct rtw_adapter *adapter)
 418 {
 419         return adapter->HalFunc.c2h_id_filter_ccx;
 420 }