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