drivers/staging/rtl8188eu/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 #include <hal_intf.h>
  20 #include <usb_hal.h>
  21
  22 void rtw_hal_chip_configure(struct adapter *adapt)
  23 {
  24         if (adapt->HalFunc.intf_chip_configure)
  25                 adapt->HalFunc.intf_chip_configure(adapt);
  26 }
  27
  28 void rtw_hal_read_chip_info(struct adapter *adapt)
  29 {
  30         if (adapt->HalFunc.read_adapter_info)
  31                 adapt->HalFunc.read_adapter_info(adapt);
  32 }
  33
  34 void rtw_hal_read_chip_version(struct adapter *adapt)
  35 {
  36         if (adapt->HalFunc.read_chip_version)
  37                 adapt->HalFunc.read_chip_version(adapt);
  38 }
  39
  40 void rtw_hal_def_value_init(struct adapter *adapt)
  41 {
  42         if (adapt->HalFunc.init_default_value)
  43                 adapt->HalFunc.init_default_value(adapt);
  44 }
  45
  46 void rtw_hal_free_data(struct adapter *adapt)
  47 {
  48         if (adapt->HalFunc.free_hal_data)
  49                 adapt->HalFunc.free_hal_data(adapt);
  50 }
  51
  52 void rtw_hal_dm_init(struct adapter *adapt)
  53 {
  54         if (adapt->HalFunc.dm_init)
  55                 adapt->HalFunc.dm_init(adapt);
  56 }
  57
  58 void rtw_hal_sw_led_init(struct adapter *adapt)
  59 {
  60         if (adapt->HalFunc.InitSwLeds)
  61                 adapt->HalFunc.InitSwLeds(adapt);
  62 }
  63
  64 void rtw_hal_sw_led_deinit(struct adapter *adapt)
  65 {
  66         if (adapt->HalFunc.DeInitSwLeds)
  67                 adapt->HalFunc.DeInitSwLeds(adapt);
  68 }
  69
  70 u32 rtw_hal_power_on(struct adapter *adapt)
  71 {
  72         if (adapt->HalFunc.hal_power_on)
  73                 return adapt->HalFunc.hal_power_on(adapt);
  74         return _FAIL;
  75 }
  76
  77 uint     rtw_hal_init(struct adapter *adapt)
  78 {
  79         uint    status = _SUCCESS;
  80
  81         adapt->hw_init_completed = false;
  82
  83         status = adapt->HalFunc.hal_init(adapt);
  84
  85         if (status == _SUCCESS) {
  86                 adapt->hw_init_completed = true;
  87
  88                 if (adapt->registrypriv.notch_filter == 1)
  89                         rtw_hal_notch_filter(adapt, 1);
  90
  91                 rtw_hal_reset_security_engine(adapt);
  92         } else {
  93                 adapt->hw_init_completed = false;
  94                 DBG_88E("rtw_hal_init: hal__init fail\n");
  95         }
  96
  97         RT_TRACE(_module_hal_init_c_, _drv_err_,
  98                  ("-rtl871x_hal_init:status=0x%x\n", status));
  99
 100         return status;
 101 }
 102
 103 uint rtw_hal_deinit(struct adapter *adapt)
 104 {
 105         uint    status = _SUCCESS;
 106
 107         status = adapt->HalFunc.hal_deinit(adapt);
 108
 109         if (status == _SUCCESS)
 110                 adapt->hw_init_completed = false;
 111         else
 112                 DBG_88E("\n rtw_hal_deinit: hal_init fail\n");
 113
 114         return status;
 115 }
 116
 117 void rtw_hal_set_hwreg(struct adapter *adapt, u8 variable, u8 *val)
 118 {
 119         if (adapt->HalFunc.SetHwRegHandler)
 120                 adapt->HalFunc.SetHwRegHandler(adapt, variable, val);
 121 }
 122
 123 void rtw_hal_get_hwreg(struct adapter *adapt, u8 variable, u8 *val)
 124 {
 125         if (adapt->HalFunc.GetHwRegHandler)
 126                 adapt->HalFunc.GetHwRegHandler(adapt, variable, val);
 127 }
 128
 129 u8 rtw_hal_get_def_var(struct adapter *adapt,
 130                        enum hal_def_variable var, void *val)
 131 {
 132         if (adapt->HalFunc.GetHalDefVarHandler)
 133                 return adapt->HalFunc.GetHalDefVarHandler(adapt, var, val);
 134         return _FAIL;
 135 }
 136
 137 void rtw_hal_set_odm_var(struct adapter *adapt,
 138                          enum hal_odm_variable var, void *val1,
 139                          bool set)
 140 {
 141         if (adapt->HalFunc.SetHalODMVarHandler)
 142                 adapt->HalFunc.SetHalODMVarHandler(adapt, var,
 143                                                       val1, set);
 144 }
 145
 146 u32 rtw_hal_inirp_init(struct adapter *adapt)
 147 {
 148         u32 rst = _FAIL;
 149
 150         if (adapt->HalFunc.inirp_init)
 151                 rst = adapt->HalFunc.inirp_init(adapt);
 152         else
 153                 DBG_88E(" %s HalFunc.inirp_init is NULL!!!\n", __func__);
 154         return rst;
 155 }
 156
 157 u32 rtw_hal_inirp_deinit(struct adapter *adapt)
 158 {
 159         if (adapt->HalFunc.inirp_deinit)
 160                 return adapt->HalFunc.inirp_deinit(adapt);
 161
 162         return _FAIL;
 163 }
 164
 165 s32 rtw_hal_xmit(struct adapter *adapt, struct xmit_frame *pxmitframe)
 166 {
 167         if (adapt->HalFunc.hal_xmit)
 168                 return adapt->HalFunc.hal_xmit(adapt, pxmitframe);
 169
 170         return false;
 171 }
 172
 173 s32 rtw_hal_mgnt_xmit(struct adapter *adapt, struct xmit_frame *pmgntframe)
 174 {
 175         s32 ret = _FAIL;
 176
 177         if (adapt->HalFunc.mgnt_xmit)
 178                 ret = adapt->HalFunc.mgnt_xmit(adapt, pmgntframe);
 179         return ret;
 180 }
 181
 182 s32 rtw_hal_init_xmit_priv(struct adapter *adapt)
 183 {
 184         if (adapt->HalFunc.init_xmit_priv)
 185                 return adapt->HalFunc.init_xmit_priv(adapt);
 186         return _FAIL;
 187 }
 188
 189 s32 rtw_hal_init_recv_priv(struct adapter *adapt)
 190 {
 191         if (adapt->HalFunc.init_recv_priv)
 192                 return adapt->HalFunc.init_recv_priv(adapt);
 193
 194         return _FAIL;
 195 }
 196
 197 void rtw_hal_free_recv_priv(struct adapter *adapt)
 198 {
 199         if (adapt->HalFunc.free_recv_priv)
 200                 adapt->HalFunc.free_recv_priv(adapt);
 201 }
 202
 203 void rtw_hal_update_ra_mask(struct adapter *adapt, u32 mac_id, u8 rssi_level)
 204 {
 205         struct mlme_priv *pmlmepriv = &(adapt->mlmepriv);
 206
 207         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
 208 #ifdef CONFIG_88EU_AP_MODE
 209                 struct sta_info *psta = NULL;
 210                 struct sta_priv *pstapriv = &adapt->stapriv;
 211
 212                 if ((mac_id-1) > 0)
 213                         psta = pstapriv->sta_aid[(mac_id-1) - 1];
 214                 if (psta)
 215                         add_RATid(adapt, psta, 0);/* todo: based on rssi_level*/
 216 #endif
 217         } else {
 218                 if (adapt->HalFunc.UpdateRAMaskHandler)
 219                         adapt->HalFunc.UpdateRAMaskHandler(adapt, mac_id,
 220                                                               rssi_level);
 221         }
 222 }
 223
 224 void rtw_hal_add_ra_tid(struct adapter *adapt, u32 bitmap, u8 arg,
 225                         u8 rssi_level)
 226 {
 227         if (adapt->HalFunc.Add_RateATid)
 228                 adapt->HalFunc.Add_RateATid(adapt, bitmap, arg,
 229                                                rssi_level);
 230 }
 231
 232 u32 rtw_hal_read_rfreg(struct adapter *adapt, enum rf_radio_path rfpath,
 233                        u32 regaddr, u32 bitmask)
 234 {
 235         u32 data = 0;
 236
 237         if (adapt->HalFunc.read_rfreg)
 238                 data = adapt->HalFunc.read_rfreg(adapt, rfpath, regaddr,
 239                                                     bitmask);
 240         return data;
 241 }
 242
 243 void rtw_hal_set_bwmode(struct adapter *adapt,
 244                         enum ht_channel_width bandwidth, u8 offset)
 245 {
 246         if (adapt->HalFunc.set_bwmode_handler)
 247                 adapt->HalFunc.set_bwmode_handler(adapt, bandwidth,
 248                                                      offset);
 249 }
 250
 251 void rtw_hal_set_chan(struct adapter *adapt, u8 channel)
 252 {
 253         if (adapt->HalFunc.set_channel_handler)
 254                 adapt->HalFunc.set_channel_handler(adapt, channel);
 255 }
 256
 257 void rtw_hal_dm_watchdog(struct adapter *adapt)
 258 {
 259         if (adapt->HalFunc.hal_dm_watchdog)
 260                 adapt->HalFunc.hal_dm_watchdog(adapt);
 261 }
 262
 263 void rtw_hal_bcn_related_reg_setting(struct adapter *adapt)
 264 {
 265         if (adapt->HalFunc.SetBeaconRelatedRegistersHandler)
 266                 adapt->HalFunc.SetBeaconRelatedRegistersHandler(adapt);
 267 }
 268
 269 u8 rtw_hal_antdiv_before_linked(struct adapter *adapt)
 270 {
 271         if (adapt->HalFunc.AntDivBeforeLinkHandler)
 272                 return adapt->HalFunc.AntDivBeforeLinkHandler(adapt);
 273         return false;
 274 }
 275
 276 void rtw_hal_antdiv_rssi_compared(struct adapter *adapt,
 277                                   struct wlan_bssid_ex *dst,
 278                                   struct wlan_bssid_ex *src)
 279 {
 280         if (adapt->HalFunc.AntDivCompareHandler)
 281                 adapt->HalFunc.AntDivCompareHandler(adapt, dst, src);
 282 }
 283
 284 void rtw_hal_sreset_init(struct adapter *adapt)
 285 {
 286         if (adapt->HalFunc.sreset_init_value)
 287                 adapt->HalFunc.sreset_init_value(adapt);
 288 }
 289
 290 void rtw_hal_notch_filter(struct adapter *adapter, bool enable)
 291 {
 292         if (adapter->HalFunc.hal_notch_filter)
 293                 adapter->HalFunc.hal_notch_filter(adapter, enable);
 294 }
 295
 296 void rtw_hal_reset_security_engine(struct adapter *adapter)
 297 {
 298         if (adapter->HalFunc.hal_reset_security_engine)
 299                 adapter->HalFunc.hal_reset_security_engine(adapter);
 300 }