drivers/net/wireless/rockchip_wlan/rtl8723cs/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
  23 #include <drv_types.h>
  24 #include <hal_data.h>
  25
  26 const u32 _chip_type_to_odm_ic_type[] = {
  27         0,
  28         ODM_RTL8188E,
  29         ODM_RTL8192E,
  30         ODM_RTL8812,
  31         ODM_RTL8821,
  32         ODM_RTL8723B,
  33         ODM_RTL8814A,
  34         ODM_RTL8703B,
  35         ODM_RTL8188F,
  36         ODM_RTL8822B,
  37         ODM_RTL8723D,
  38         ODM_RTL8821C,
  39         0,
  40 };
  41
  42 void rtw_hal_chip_configure(_adapter *padapter)
  43 {
  44         padapter->hal_func.intf_chip_configure(padapter);
  45 }
  46
  47 /*
  48  * Description:
  49  *      Read chip internal ROM data
  50  *
  51  * Return:
  52  *      _SUCCESS success
  53  *      _FAIL    fail
  54  */
  55 u8 rtw_hal_read_chip_info(_adapter *padapter)
  56 {
  57         u8 rtn = _SUCCESS;
  58         u8 hci_type = rtw_get_intf_type(padapter);
  59         u32 start = rtw_get_current_time();
  60
  61         /*  before access eFuse, make sure card enable has been called */
  62         if ((hci_type == RTW_SDIO || hci_type == RTW_GSPI)
  63             && !rtw_is_hw_init_completed(padapter))
  64                 rtw_hal_power_on(padapter);
  65
  66         rtn = padapter->hal_func.read_adapter_info(padapter);
  67
  68         if ((hci_type == RTW_SDIO || hci_type == RTW_GSPI)
  69             && !rtw_is_hw_init_completed(padapter))
  70                 rtw_hal_power_off(padapter);
  71
  72         RTW_INFO("%s in %d ms\n", __func__, rtw_get_passing_time_ms(start));
  73
  74         return rtn;
  75 }
  76
  77 void rtw_hal_read_chip_version(_adapter *padapter)
  78 {
  79         padapter->hal_func.read_chip_version(padapter);
  80         rtw_odm_init_ic_type(padapter);
  81 }
  82
  83 void rtw_hal_def_value_init(_adapter *padapter)
  84 {
  85         if (is_primary_adapter(padapter)) {
  86                 padapter->hal_func.init_default_value(padapter);
  87
  88                 rtw_init_hal_com_default_value(padapter);
  89
  90                 {
  91                         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
  92                         struct hal_spec_t *hal_spec = GET_HAL_SPEC(padapter);
  93
  94                         /* hal_spec is ready here */
  95                         dvobj->macid_ctl.num = rtw_min(hal_spec->macid_num, MACID_NUM_SW_LIMIT);
  96
  97                         dvobj->cam_ctl.sec_cap = hal_spec->sec_cap;
  98                         dvobj->cam_ctl.num = rtw_min(hal_spec->sec_cam_ent_num, SEC_CAM_ENT_NUM_SW_LIMIT);
  99                 }
 100         }
 101 }
 102
 103 u8 rtw_hal_data_init(_adapter *padapter)
 104 {
 105         if (is_primary_adapter(padapter)) {
 106                 padapter->hal_data_sz = sizeof(HAL_DATA_TYPE);
 107                 padapter->HalData = rtw_zvmalloc(padapter->hal_data_sz);
 108                 if (padapter->HalData == NULL) {
 109                         RTW_INFO("cant not alloc memory for HAL DATA\n");
 110                         return _FAIL;
 111                 }
 112         }
 113         return _SUCCESS;
 114 }
 115
 116 void rtw_hal_data_deinit(_adapter *padapter)
 117 {
 118         if (is_primary_adapter(padapter)) {
 119                 if (padapter->HalData) {
 120 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
 121                         phy_free_filebuf(padapter);
 122 #endif
 123                         rtw_vmfree(padapter->HalData, padapter->hal_data_sz);
 124                         padapter->HalData = NULL;
 125                         padapter->hal_data_sz = 0;
 126                 }
 127         }
 128 }
 129
 130 void    rtw_hal_free_data(_adapter *padapter)
 131 {
 132         /* free HAL Data         */
 133         rtw_hal_data_deinit(padapter);
 134 }
 135 void rtw_hal_dm_init(_adapter *padapter)
 136 {
 137         if (is_primary_adapter(padapter)) {
 138                 PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
 139
 140                 padapter->hal_func.dm_init(padapter);
 141
 142                 _rtw_spinlock_init(&pHalData->IQKSpinLock);
 143
 144                 phy_load_tx_power_ext_info(padapter, 1);
 145         }
 146 }
 147 void rtw_hal_dm_deinit(_adapter *padapter)
 148 {
 149         if (is_primary_adapter(padapter)) {
 150                 PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
 151
 152                 padapter->hal_func.dm_deinit(padapter);
 153
 154                 _rtw_spinlock_free(&pHalData->IQKSpinLock);
 155         }
 156 }
 157 void    rtw_hal_sw_led_init(_adapter *padapter)
 158 {
 159         if (padapter->hal_func.InitSwLeds)
 160                 padapter->hal_func.InitSwLeds(padapter);
 161 }
 162
 163 void rtw_hal_sw_led_deinit(_adapter *padapter)
 164 {
 165         if (padapter->hal_func.DeInitSwLeds)
 166                 padapter->hal_func.DeInitSwLeds(padapter);
 167 }
 168
 169 u32 rtw_hal_power_on(_adapter *padapter)
 170 {
 171         return padapter->hal_func.hal_power_on(padapter);
 172 }
 173 void rtw_hal_power_off(_adapter *padapter)
 174 {
 175         struct macid_ctl_t *macid_ctl = &padapter->dvobj->macid_ctl;
 176
 177         _rtw_memset(macid_ctl->h2c_msr, 0, MACID_NUM_SW_LIMIT);
 178
 179 #ifdef CONFIG_BT_COEXIST
 180         rtw_btcoex_PowerOffSetting(padapter);
 181 #endif
 182
 183         padapter->hal_func.hal_power_off(padapter);
 184 }
 185
 186
 187 void rtw_hal_init_opmode(_adapter *padapter)
 188 {
 189         NDIS_802_11_NETWORK_INFRASTRUCTURE networkType = Ndis802_11InfrastructureMax;
 190         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 191         sint fw_state;
 192
 193         fw_state = get_fwstate(pmlmepriv);
 194
 195         if (fw_state & WIFI_ADHOC_STATE)
 196                 networkType = Ndis802_11IBSS;
 197         else if (fw_state & WIFI_STATION_STATE)
 198                 networkType = Ndis802_11Infrastructure;
 199         else if (fw_state & WIFI_AP_STATE)
 200                 networkType = Ndis802_11APMode;
 201         else
 202                 return;
 203
 204         rtw_setopmode_cmd(padapter, networkType, _FALSE);
 205 }
 206
 207 uint     rtw_hal_init(_adapter *padapter)
 208 {
 209         uint    status = _SUCCESS;
 210         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 211         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
 212         int i;
 213
 214         status = padapter->hal_func.hal_init(padapter);
 215
 216         if (status == _SUCCESS) {
 217                 pHalData->hw_init_completed = _TRUE;
 218                 rtw_restore_mac_addr(padapter);
 219
 220                 if (padapter->registrypriv.notch_filter == 1)
 221                         rtw_hal_notch_filter(padapter, 1);
 222
 223                 for (i = 0; i < dvobj->iface_nums; i++)
 224                         rtw_sec_restore_wep_key(dvobj->padapters[i]);
 225
 226                 rtw_led_control(padapter, LED_CTL_POWER_ON);
 227
 228                 init_hw_mlme_ext(padapter);
 229
 230                 rtw_hal_init_opmode(padapter);
 231
 232 #ifdef CONFIG_RF_POWER_TRIM
 233                 rtw_bb_rf_gain_offset(padapter);
 234 #endif /*CONFIG_RF_POWER_TRIM*/
 235
 236         } else {
 237                 pHalData->hw_init_completed = _FALSE;
 238                 RTW_INFO("rtw_hal_init: hal_init fail\n");
 239         }
 240
 241
 242         return status;
 243
 244 }
 245
 246 uint rtw_hal_deinit(_adapter *padapter)
 247 {
 248         uint    status = _SUCCESS;
 249         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 250         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
 251         int i;
 252
 253         status = padapter->hal_func.hal_deinit(padapter);
 254
 255         if (status == _SUCCESS) {
 256                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
 257                 pHalData->hw_init_completed = _FALSE;
 258         } else
 259                 RTW_INFO("\n rtw_hal_deinit: hal_init fail\n");
 260
 261
 262         return status;
 263 }
 264
 265 void rtw_hal_set_hwreg(_adapter *padapter, u8 variable, u8 *val)
 266 {
 267         padapter->hal_func.set_hw_reg_handler(padapter, variable, val);
 268 }
 269
 270 void rtw_hal_get_hwreg(_adapter *padapter, u8 variable, u8 *val)
 271 {
 272         padapter->hal_func.GetHwRegHandler(padapter, variable, val);
 273 }
 274
 275 u8 rtw_hal_set_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
 276 {
 277         return padapter->hal_func.SetHalDefVarHandler(padapter, eVariable, pValue);
 278 }
 279 u8 rtw_hal_get_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue)
 280 {
 281         return padapter->hal_func.get_hal_def_var_handler(padapter, eVariable, pValue);
 282 }
 283
 284 void rtw_hal_set_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1, BOOLEAN bSet)
 285 {
 286         padapter->hal_func.SetHalODMVarHandler(padapter, eVariable, pValue1, bSet);
 287 }
 288 void    rtw_hal_get_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1, PVOID pValue2)
 289 {
 290         padapter->hal_func.GetHalODMVarHandler(padapter, eVariable, pValue1, pValue2);
 291 }
 292
 293 /* FOR SDIO & PCIE */
 294 void rtw_hal_enable_interrupt(_adapter *padapter)
 295 {
 296 #if defined(CONFIG_PCI_HCI) || defined(CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
 297         padapter->hal_func.enable_interrupt(padapter);
 298 #endif /* #if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI) */
 299 }
 300
 301 /* FOR SDIO & PCIE */
 302 void rtw_hal_disable_interrupt(_adapter *padapter)
 303 {
 304 #if defined(CONFIG_PCI_HCI) || defined(CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
 305         padapter->hal_func.disable_interrupt(padapter);
 306 #endif /* #if defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI) */
 307 }
 308
 309
 310 u8 rtw_hal_check_ips_status(_adapter *padapter)
 311 {
 312         u8 val = _FALSE;
 313         if (padapter->hal_func.check_ips_status)
 314                 val = padapter->hal_func.check_ips_status(padapter);
 315         else
 316                 RTW_INFO("%s: hal_func.check_ips_status is NULL!\n", __FUNCTION__);
 317
 318         return val;
 319 }
 320
 321 s32 rtw_hal_fw_dl(_adapter *padapter, u8 wowlan)
 322 {
 323         return padapter->hal_func.fw_dl(padapter, wowlan);
 324 }
 325
 326 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
 327 void rtw_hal_clear_interrupt(_adapter *padapter)
 328 {
 329 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
 330         padapter->hal_func.clear_interrupt(padapter);
 331 #endif
 332 }
 333 #endif
 334
 335 #if defined(CONFIG_USB_HCI) || defined(CONFIG_PCI_HCI)
 336 u32     rtw_hal_inirp_init(_adapter *padapter)
 337 {
 338         if (is_primary_adapter(padapter))
 339                 return padapter->hal_func.inirp_init(padapter);
 340         return _SUCCESS;
 341 }
 342 u32     rtw_hal_inirp_deinit(_adapter *padapter)
 343 {
 344
 345         if (is_primary_adapter(padapter))
 346                 return padapter->hal_func.inirp_deinit(padapter);
 347
 348         return _SUCCESS;
 349 }
 350 #endif /* #if defined(CONFIG_USB_HCI) || defined (CONFIG_PCI_HCI) */
 351
 352 #if defined(CONFIG_PCI_HCI)
 353 void    rtw_hal_irp_reset(_adapter *padapter)
 354 {
 355         padapter->hal_func.irp_reset(GET_PRIMARY_ADAPTER(padapter));
 356 }
 357 #endif /* #if defined(CONFIG_PCI_HCI) */
 358
 359 /* for USB Auto-suspend */
 360 u8      rtw_hal_intf_ps_func(_adapter *padapter, HAL_INTF_PS_FUNC efunc_id, u8 *val)
 361 {
 362         if (padapter->hal_func.interface_ps_func)
 363                 return padapter->hal_func.interface_ps_func(padapter, efunc_id, val);
 364         return _FAIL;
 365 }
 366
 367 s32     rtw_hal_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
 368 {
 369         return padapter->hal_func.hal_xmitframe_enqueue(padapter, pxmitframe);
 370 }
 371
 372 s32     rtw_hal_xmit(_adapter *padapter, struct xmit_frame *pxmitframe)
 373 {
 374         return padapter->hal_func.hal_xmit(padapter, pxmitframe);
 375 }
 376
 377 /*
 378  * [IMPORTANT] This function would be run in interrupt context.
 379  */
 380 s32     rtw_hal_mgnt_xmit(_adapter *padapter, struct xmit_frame *pmgntframe)
 381 {
 382         s32 ret = _FAIL;
 383         u8      *pframe, subtype;
 384         struct rtw_ieee80211_hdr        *pwlanhdr;
 385         struct sta_info *psta;
 386         struct sta_priv         *pstapriv = &padapter->stapriv;
 387
 388         update_mgntframe_attrib_addr(padapter, pmgntframe);
 389         pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
 390         subtype = get_frame_sub_type(pframe); /* bit(7)~bit(2) */
 391
 392         /* pwlanhdr = (struct rtw_ieee80211_hdr *)pframe; */
 393         /* _rtw_memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN); */
 394
 395 #ifdef CONFIG_IEEE80211W
 396         if (padapter->securitypriv.binstallBIPkey == _TRUE && (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC ||
 397                         subtype == WIFI_ACTION)) {
 398                 if (IS_MCAST(pmgntframe->attrib.ra) && pmgntframe->attrib.key_type != IEEE80211W_NO_KEY) {
 399                         pmgntframe->attrib.encrypt = _BIP_;
 400                         /* pmgntframe->attrib.bswenc = _TRUE; */
 401                 } else if (pmgntframe->attrib.key_type != IEEE80211W_NO_KEY) {
 402                         psta = rtw_get_stainfo(pstapriv, pmgntframe->attrib.ra);
 403                         if (psta && psta->bpairwise_key_installed == _TRUE) {
 404                                 pmgntframe->attrib.encrypt = _AES_;
 405                                 pmgntframe->attrib.bswenc = _TRUE;
 406                         } else {
 407                                 RTW_INFO("%s, %d, bpairwise_key_installed is FALSE\n", __func__, __LINE__);
 408                                 goto no_mgmt_coalesce;
 409                         }
 410                 }
 411                 RTW_INFO("encrypt=%d, bswenc=%d\n", pmgntframe->attrib.encrypt, pmgntframe->attrib.bswenc);
 412                 rtw_mgmt_xmitframe_coalesce(padapter, pmgntframe->pkt, pmgntframe);
 413         }
 414 #endif /* CONFIG_IEEE80211W */
 415 no_mgmt_coalesce:
 416         ret = padapter->hal_func.mgnt_xmit(padapter, pmgntframe);
 417         return ret;
 418 }
 419
 420 s32     rtw_hal_init_xmit_priv(_adapter *padapter)
 421 {
 422         return padapter->hal_func.init_xmit_priv(padapter);
 423 }
 424 void    rtw_hal_free_xmit_priv(_adapter *padapter)
 425 {
 426         padapter->hal_func.free_xmit_priv(padapter);
 427 }
 428
 429 s32     rtw_hal_init_recv_priv(_adapter *padapter)
 430 {
 431         return padapter->hal_func.init_recv_priv(padapter);
 432 }
 433 void    rtw_hal_free_recv_priv(_adapter *padapter)
 434 {
 435         padapter->hal_func.free_recv_priv(padapter);
 436 }
 437
 438 void rtw_update_ramask(_adapter *padapter, struct sta_info *psta, u32 mac_id, u8 rssi_level, u8 is_update_bw)
 439 {
 440         struct macid_cfg h2c_macid_cfg;
 441         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 442         struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
 443         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 444         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 445         HAL_DATA_TYPE   *hal_data = GET_HAL_DATA(padapter);
 446         u8 disable_cck_rate = FALSE, MimoPs_enable = FALSE;
 447         u32 ratr_bitmap_msb = 0, ratr_bitmap_lsb = 0;
 448         u64     mask = 0, rate_bitmap = 0;
 449         u8 bw, short_gi;
 450
 451         if (psta == NULL) {
 452                 RTW_ERR(FUNC_ADPT_FMT" macid:%u, sta is NULL\n", FUNC_ADPT_ARG(padapter), mac_id);
 453                 rtw_warn_on(1);
 454                 return;
 455         }
 456         _rtw_memset(&h2c_macid_cfg, 0, sizeof(struct macid_cfg));
 457
 458         bw =  rtw_get_tx_bw_mode(padapter, psta);
 459         short_gi = query_ra_short_GI(psta, bw);
 460
 461         ratr_bitmap_msb = (u32)(psta->ra_mask >> 32);
 462         ratr_bitmap_lsb = (u32)(psta->ra_mask);
 463
 464         phydm_update_hal_ra_mask(&hal_data->odmpriv, psta->wireless_mode, hal_data->rf_type, bw, MimoPs_enable, disable_cck_rate, &ratr_bitmap_msb, &ratr_bitmap_lsb, rssi_level);
 465         mask = (((u64)ratr_bitmap_msb) << 32) | ((u64)ratr_bitmap_lsb);
 466
 467
 468 #ifdef CONFIG_BT_COEXIST
 469         if (hal_data->EEPROMBluetoothCoexist == 1) {
 470                 rate_bitmap = rtw_btcoex_GetRaMask(padapter);
 471                 mask &= ~rate_bitmap;
 472         }
 473 #endif /* CONFIG_BT_COEXIST */
 474
 475 #ifdef CONFIG_CMCC_TEST
 476 #ifdef CONFIG_BT_COEXIST
 477         if (pmlmeext->cur_wireless_mode & WIRELESS_11G) {
 478                 if (mac_id == 0) {
 479                         RTW_INFO("CMCC_BT update raid entry, mask=0x%x\n", mask);
 480                         /*mask &=0xffffffc0; //disable CCK & <12M OFDM rate for 11G mode for CMCC */
 481                         mask &= 0xffffff00; /*disable CCK & <24M OFDM rate for 11G mode for CMCC */
 482                         RTW_INFO("CMCC_BT update raid entry, mask=0x%x\n", mask);
 483                 }
 484         }
 485 #endif
 486 #endif
 487
 488         /*set correct initial date rate for each mac_id */
 489         hal_data->INIDATA_RATE[mac_id] = psta->init_rate;
 490
 491
 492         RTW_INFO("%s => mac_id:%d, networkType:0x%02x, mask:0x%016llx\n\t ==> rssi_level:%d, rate_bitmap:0x%016llx, shortGIrate=%d\n\t ==> bw:%d, ignore_bw:0x%d\n",
 493                         __func__, mac_id, psta->wireless_mode, mask, rssi_level, rate_bitmap, short_gi, bw, (!is_update_bw));
 494
 495         rtw_macid_ctl_set_bw(macid_ctl, mac_id, bw);
 496         rtw_macid_ctl_set_vht_en(macid_ctl, mac_id, is_supported_vht(psta->wireless_mode));
 497         rtw_macid_ctl_set_rate_bmp0(macid_ctl, mac_id, mask);
 498         rtw_macid_ctl_set_rate_bmp1(macid_ctl, mac_id, mask >> 32);
 499         rtw_update_tx_rate_bmp(adapter_to_dvobj(padapter));
 500
 501         h2c_macid_cfg.mac_id = mac_id;
 502         h2c_macid_cfg.rate_id = psta->raid;
 503         h2c_macid_cfg.bandwidth = bw;
 504         h2c_macid_cfg.ignore_bw = (!is_update_bw);
 505         h2c_macid_cfg.short_gi = short_gi;
 506         h2c_macid_cfg.ra_mask = mask;
 507
 508         padapter->hal_func.update_ra_mask_handler(padapter, psta, &h2c_macid_cfg);
 509 }
 510
 511 void rtw_hal_update_ra_mask(struct sta_info *psta, u8 rssi_level, u8 is_update_bw)
 512 {
 513         _adapter *padapter;
 514         struct mlme_priv *pmlmepriv;
 515
 516         if (!psta)
 517                 return;
 518
 519         padapter = psta->padapter;
 520
 521         pmlmepriv = &(padapter->mlmepriv);
 522
 523         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
 524                 add_RATid(padapter, psta, rssi_level, is_update_bw);
 525         else {
 526                 psta->raid = rtw_hal_networktype_to_raid(padapter, psta);
 527                 rtw_update_ramask(padapter, psta, psta->mac_id, rssi_level, is_update_bw);
 528         }
 529 }
 530
 531 /*      Start specifical interface thread               */
 532 void    rtw_hal_start_thread(_adapter *padapter)
 533 {
 534 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
 535 #ifndef CONFIG_SDIO_TX_TASKLET
 536         padapter->hal_func.run_thread(padapter);
 537 #endif
 538 #endif
 539 }
 540 /*      Start specifical interface thread               */
 541 void    rtw_hal_stop_thread(_adapter *padapter)
 542 {
 543 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
 544 #ifndef CONFIG_SDIO_TX_TASKLET
 545
 546         padapter->hal_func.cancel_thread(padapter);
 547
 548 #endif
 549 #endif
 550 }
 551
 552 u32     rtw_hal_read_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask)
 553 {
 554         u32 data = 0;
 555         if (padapter->hal_func.read_bbreg)
 556                 data = padapter->hal_func.read_bbreg(padapter, RegAddr, BitMask);
 557         return data;
 558 }
 559 void    rtw_hal_write_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
 560 {
 561         if (padapter->hal_func.write_bbreg)
 562                 padapter->hal_func.write_bbreg(padapter, RegAddr, BitMask, Data);
 563 }
 564
 565 u32 rtw_hal_read_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
 566 {
 567         u32 data = 0;
 568
 569         if (padapter->hal_func.read_rfreg) {
 570                 data = padapter->hal_func.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
 571
 572                 if (match_rf_read_sniff_ranges(eRFPath, RegAddr, BitMask)) {
 573                         RTW_INFO("DBG_IO rtw_hal_read_rfreg(%u, 0x%04x, 0x%08x) read:0x%08x(0x%08x)\n"
 574                                 , eRFPath, RegAddr, BitMask, (data << PHY_CalculateBitShift(BitMask)), data);
 575                 }
 576         }
 577
 578         return data;
 579 }
 580
 581 void rtw_hal_write_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
 582 {
 583         if (padapter->hal_func.write_rfreg) {
 584
 585                 if (match_rf_write_sniff_ranges(eRFPath, RegAddr, BitMask)) {
 586                         RTW_INFO("DBG_IO rtw_hal_write_rfreg(%u, 0x%04x, 0x%08x) write:0x%08x(0x%08x)\n"
 587                                 , eRFPath, RegAddr, BitMask, (Data << PHY_CalculateBitShift(BitMask)), Data);
 588                 }
 589
 590                 padapter->hal_func.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
 591
 592 #ifdef CONFIG_PCI_HCI
 593                 if (!IS_HARDWARE_TYPE_JAGUAR_AND_JAGUAR2(padapter)) /*For N-Series IC, suggest by Jenyu*/
 594                         rtw_udelay_os(2);
 595 #endif
 596         }
 597 }
 598
 599 #if defined(CONFIG_PCI_HCI)
 600 s32     rtw_hal_interrupt_handler(_adapter *padapter)
 601 {
 602         s32 ret = _FAIL;
 603         ret = padapter->hal_func.interrupt_handler(padapter);
 604         return ret;
 605 }
 606 #endif
 607 #if defined(CONFIG_USB_HCI) && defined(CONFIG_SUPPORT_USB_INT)
 608 void    rtw_hal_interrupt_handler(_adapter *padapter, u16 pkt_len, u8 *pbuf)
 609 {
 610         padapter->hal_func.interrupt_handler(padapter, pkt_len, pbuf);
 611 }
 612 #endif
 613
 614 void    rtw_hal_set_chnl_bw(_adapter *padapter, u8 channel, CHANNEL_WIDTH Bandwidth, u8 Offset40, u8 Offset80)
 615 {
 616         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
 617         struct PHY_DM_STRUCT            *pDM_Odm = &(pHalData->odmpriv);
 618         u8 cch_160 = Bandwidth == CHANNEL_WIDTH_160 ? channel : 0;
 619         u8 cch_80 = Bandwidth == CHANNEL_WIDTH_80 ? channel : 0;
 620         u8 cch_40 = Bandwidth == CHANNEL_WIDTH_40 ? channel : 0;
 621         u8 cch_20 = Bandwidth == CHANNEL_WIDTH_20 ? channel : 0;
 622
 623         odm_acquire_spin_lock(pDM_Odm, RT_IQK_SPINLOCK);
 624         if (pDM_Odm->rf_calibrate_info.is_iqk_in_progress == _TRUE)
 625                 RTW_ERR("%s, %d, IQK may race condition\n", __func__, __LINE__);
 626         odm_release_spin_lock(pDM_Odm, RT_IQK_SPINLOCK);
 627
 628         /* MP mode channel don't use secondary channel */
 629         if (rtw_mi_mp_mode_check(padapter) == _FALSE) {
 630                 #if 0
 631                 if (cch_160 != 0)
 632                         cch_80 = rtw_get_scch_by_cch_offset(cch_160, CHANNEL_WIDTH_160, Offset80);
 633                 #endif
 634                 if (cch_80 != 0)
 635                         cch_40 = rtw_get_scch_by_cch_offset(cch_80, CHANNEL_WIDTH_80, Offset80);
 636                 if (cch_40 != 0)
 637                         cch_20 = rtw_get_scch_by_cch_offset(cch_40, CHANNEL_WIDTH_40, Offset40);
 638         }
 639
 640         pHalData->cch_80 = cch_80;
 641         pHalData->cch_40 = cch_40;
 642         pHalData->cch_20 = cch_20;
 643
 644         if (0)
 645                 RTW_INFO("%s cch:%u, %s, offset40:%u, offset80:%u (%u, %u, %u)\n", __func__
 646                         , channel, ch_width_str(Bandwidth), Offset40, Offset80
 647                         , pHalData->cch_80, pHalData->cch_40, pHalData->cch_20);
 648
 649         padapter->hal_func.set_chnl_bw_handler(padapter, channel, Bandwidth, Offset40, Offset80);
 650 }
 651
 652 void    rtw_hal_set_tx_power_level(_adapter *padapter, u8 channel)
 653 {
 654         if (padapter->hal_func.set_tx_power_level_handler)
 655                 padapter->hal_func.set_tx_power_level_handler(padapter, channel);
 656 }
 657
 658 void    rtw_hal_get_tx_power_level(_adapter *padapter, s32 *powerlevel)
 659 {
 660         if (padapter->hal_func.get_tx_power_level_handler)
 661                 padapter->hal_func.get_tx_power_level_handler(padapter, powerlevel);
 662 }
 663
 664 void    rtw_hal_dm_watchdog(_adapter *padapter)
 665 {
 666 #ifdef CONFIG_MCC_MODE
 667         if (MCC_EN(padapter)) {
 668                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC))
 669                         return;
 670         }
 671 #endif /* CONFIG_MCC_MODE */
 672
 673         padapter->hal_func.hal_dm_watchdog(padapter);
 674
 675 }
 676
 677 #ifdef CONFIG_LPS_LCLK_WD_TIMER
 678 void    rtw_hal_dm_watchdog_in_lps(_adapter *padapter)
 679 {
 680 #if defined(CONFIG_CONCURRENT_MODE)
 681 #ifndef CONFIG_FW_MULTI_PORT_SUPPORT
 682         if (padapter->hw_port != HW_PORT0)
 683                 return;
 684 #endif
 685 #endif
 686
 687         if (adapter_to_pwrctl(padapter)->bFwCurrentInPSMode == _TRUE) {
 688                 padapter->hal_func.hal_dm_watchdog_in_lps(padapter);/* this function caller is in interrupt context                                      */
 689         }
 690 }
 691 #endif
 692
 693 void rtw_hal_bcn_related_reg_setting(_adapter *padapter)
 694 {
 695         padapter->hal_func.SetBeaconRelatedRegistersHandler(padapter);
 696 }
 697
 698 #ifdef CONFIG_HOSTAPD_MLME
 699 s32     rtw_hal_hostap_mgnt_xmit_entry(_adapter *padapter, _pkt *pkt)
 700 {
 701         if (padapter->hal_func.hostap_mgnt_xmit_entry)
 702                 return padapter->hal_func.hostap_mgnt_xmit_entry(padapter, pkt);
 703         return _FAIL;
 704 }
 705 #endif /* CONFIG_HOSTAPD_MLME */
 706
 707 #ifdef DBG_CONFIG_ERROR_DETECT
 708 void    rtw_hal_sreset_init(_adapter *padapter)
 709 {
 710         padapter->hal_func.sreset_init_value(padapter);
 711 }
 712 void rtw_hal_sreset_reset(_adapter *padapter)
 713 {
 714         padapter = GET_PRIMARY_ADAPTER(padapter);
 715         padapter->hal_func.silentreset(padapter);
 716 }
 717
 718 void rtw_hal_sreset_reset_value(_adapter *padapter)
 719 {
 720         padapter->hal_func.sreset_reset_value(padapter);
 721 }
 722
 723 void rtw_hal_sreset_xmit_status_check(_adapter *padapter)
 724 {
 725         padapter->hal_func.sreset_xmit_status_check(padapter);
 726 }
 727 void rtw_hal_sreset_linked_status_check(_adapter *padapter)
 728 {
 729         padapter->hal_func.sreset_linked_status_check(padapter);
 730 }
 731 u8   rtw_hal_sreset_get_wifi_status(_adapter *padapter)
 732 {
 733         return padapter->hal_func.sreset_get_wifi_status(padapter);
 734 }
 735
 736 bool rtw_hal_sreset_inprogress(_adapter *padapter)
 737 {
 738         padapter = GET_PRIMARY_ADAPTER(padapter);
 739         return padapter->hal_func.sreset_inprogress(padapter);
 740 }
 741 #endif /* DBG_CONFIG_ERROR_DETECT */
 742
 743 #ifdef CONFIG_IOL
 744 int rtw_hal_iol_cmd(ADAPTER *adapter, struct xmit_frame *xmit_frame, u32 max_waiting_ms, u32 bndy_cnt)
 745 {
 746         if (adapter->hal_func.IOL_exec_cmds_sync)
 747                 return adapter->hal_func.IOL_exec_cmds_sync(adapter, xmit_frame, max_waiting_ms, bndy_cnt);
 748         return _FAIL;
 749 }
 750 #endif
 751
 752 #ifdef CONFIG_XMIT_THREAD_MODE
 753 s32 rtw_hal_xmit_thread_handler(_adapter *padapter)
 754 {
 755         return padapter->hal_func.xmit_thread_handler(padapter);
 756 }
 757 #endif
 758
 759 #ifdef CONFIG_RECV_THREAD_MODE
 760 s32 rtw_hal_recv_hdl(_adapter *adapter)
 761 {
 762         return adapter->hal_func.recv_hdl(adapter);
 763 }
 764 #endif
 765
 766 void rtw_hal_notch_filter(_adapter *adapter, bool enable)
 767 {
 768         if (adapter->hal_func.hal_notch_filter)
 769                 adapter->hal_func.hal_notch_filter(adapter, enable);
 770 }
 771
 772 #ifdef CONFIG_FW_C2H_REG
 773 inline bool rtw_hal_c2h_valid(_adapter *adapter, u8 *buf)
 774 {
 775         HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
 776         HAL_VERSION *hal_ver = &HalData->version_id;
 777         bool ret = _FAIL;
 778
 779         ret = C2H_ID_88XX(buf) || C2H_PLEN_88XX(buf);
 780
 781         return ret;
 782 }
 783
 784 inline s32 rtw_hal_c2h_evt_read(_adapter *adapter, u8 *buf)
 785 {
 786         HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
 787         HAL_VERSION *hal_ver = &HalData->version_id;
 788         s32 ret = _FAIL;
 789
 790         ret = c2h_evt_read_88xx(adapter, buf);
 791
 792         return ret;
 793 }
 794
 795 bool rtw_hal_c2h_reg_hdr_parse(_adapter *adapter, u8 *buf, u8 *id, u8 *seq, u8 *plen, u8 **payload)
 796 {
 797         HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
 798         HAL_VERSION *hal_ver = &HalData->version_id;
 799         bool ret = _FAIL;
 800
 801         *id = C2H_ID_88XX(buf);
 802         *seq = C2H_SEQ_88XX(buf);
 803         *plen = C2H_PLEN_88XX(buf);
 804         *payload = C2H_PAYLOAD_88XX(buf);
 805         ret = _SUCCESS;
 806
 807         return ret;
 808 }
 809 #endif /* CONFIG_FW_C2H_REG */
 810
 811 #ifdef CONFIG_FW_C2H_PKT
 812 bool rtw_hal_c2h_pkt_hdr_parse(_adapter *adapter, u8 *buf, u16 len, u8 *id, u8 *seq, u8 *plen, u8 **payload)
 813 {
 814         HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
 815         HAL_VERSION *hal_ver = &HalData->version_id;
 816         bool ret = _FAIL;
 817
 818         if (!buf || len > 256 || len < 3)
 819                 goto exit;
 820
 821         *id = C2H_ID_88XX(buf);
 822         *seq = C2H_SEQ_88XX(buf);
 823         *plen = len - 2;
 824         *payload = C2H_PAYLOAD_88XX(buf);
 825         ret = _SUCCESS;
 826
 827 exit:
 828         return ret;
 829 }
 830 #endif /* CONFIG_FW_C2H_PKT */
 831
 832 #if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_RTL8723B)
 833 #include <rtw_bt_mp.h> /* for MPTBT_FwC2hBtMpCtrl */
 834 #endif
 835 s32 c2h_handler(_adapter *adapter, u8 id, u8 seq, u8 plen, u8 *payload)
 836 {
 837         HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
 838         struct PHY_DM_STRUCT *odm = &hal_data->odmpriv;
 839         u8 sub_id = 0;
 840         s32 ret = _SUCCESS;
 841
 842         switch (id) {
 843         case C2H_FW_SCAN_COMPLETE:
 844                 RTW_INFO("[C2H], FW Scan Complete\n");
 845                 break;
 846
 847 #ifdef CONFIG_BT_COEXIST
 848         case C2H_BT_INFO:
 849                 rtw_btcoex_BtInfoNotify(adapter, plen, payload);
 850                 break;
 851         case C2H_BT_MP_INFO:
 852                 #if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_RTL8723B)
 853                 MPTBT_FwC2hBtMpCtrl(adapter, payload, plen);
 854                 #endif
 855                 rtw_btcoex_BtMpRptNotify(adapter, plen, payload);
 856                 break;
 857         case C2H_MAILBOX_STATUS:
 858                 RTW_INFO_DUMP("C2H_MAILBOX_STATUS: ", payload, plen);
 859                 break;
 860 #endif /* CONFIG_BT_COEXIST */
 861
 862         case C2H_IQK_FINISH:
 863                 c2h_iqk_offload(adapter, payload, plen);
 864                 break;
 865
 866 #if defined(CONFIG_TDLS) && defined(CONFIG_TDLS_CH_SW)
 867         case C2H_FW_CHNL_SWITCH_COMPLETE:
 868                 rtw_tdls_chsw_oper_done(adapter);
 869                 break;
 870         case C2H_BCN_EARLY_RPT:
 871                 rtw_tdls_ch_sw_back_to_base_chnl(adapter);
 872                 break;
 873 #endif
 874
 875 #ifdef CONFIG_MCC_MODE
 876         case C2H_MCC:
 877                 rtw_hal_mcc_c2h_handler(adapter, plen, payload);
 878                 break;
 879 #endif
 880
 881 #ifdef CONFIG_RTW_MAC_HIDDEN_RPT
 882         case C2H_MAC_HIDDEN_RPT:
 883                 c2h_mac_hidden_rpt_hdl(adapter, payload, plen);
 884                 break;
 885         case C2H_MAC_HIDDEN_RPT_2:
 886                 c2h_mac_hidden_rpt_2_hdl(adapter, payload, plen);
 887                 break;
 888 #endif
 889
 890         case C2H_DEFEATURE_DBG:
 891                 c2h_defeature_dbg_hdl(adapter, payload, plen);
 892                 break;
 893
 894 #ifdef CONFIG_RTW_CUSTOMER_STR
 895         case C2H_CUSTOMER_STR_RPT:
 896                 c2h_customer_str_rpt_hdl(adapter, payload, plen);
 897                 break;
 898         case C2H_CUSTOMER_STR_RPT_2:
 899                 c2h_customer_str_rpt_2_hdl(adapter, payload, plen);
 900                 break;
 901 #endif
 902
 903         case C2H_EXTEND:
 904                 sub_id = payload[0];
 905                 /* no handle, goto default */
 906
 907         default:
 908                 if (phydm_c2H_content_parsing(odm, id, plen, payload) != TRUE)
 909                         ret = _FAIL;
 910                 break;
 911         }
 912
 913 exit:
 914         if (ret != _SUCCESS) {
 915                 if (id == C2H_EXTEND)
 916                         RTW_WARN("%s: unknown C2H(0x%02x, 0x%02x)\n", __func__, id, sub_id);
 917                 else
 918                         RTW_WARN("%s: unknown C2H(0x%02x)\n", __func__, id);
 919         }
 920
 921         return ret;
 922 }
 923
 924 #ifndef RTW_HALMAC
 925 s32 rtw_hal_c2h_handler(_adapter *adapter, u8 id, u8 seq, u8 plen, u8 *payload)
 926 {
 927         s32 ret = _FAIL;
 928
 929         ret = adapter->hal_func.c2h_handler(adapter, id, seq, plen, payload);
 930         if (ret != _SUCCESS)
 931                 ret = c2h_handler(adapter, id, seq, plen, payload);
 932
 933         return ret;
 934 }
 935
 936 s32 rtw_hal_c2h_id_handle_directly(_adapter *adapter, u8 id, u8 seq, u8 plen, u8 *payload)
 937 {
 938         switch (id) {
 939         case C2H_CCX_TX_RPT:
 940         case C2H_BT_MP_INFO:
 941         case C2H_FW_CHNL_SWITCH_COMPLETE:
 942         case C2H_IQK_FINISH:
 943         case C2H_MCC:
 944         case C2H_BCN_EARLY_RPT:
 945         case C2H_AP_REQ_TXRPT:
 946         case C2H_SPC_STAT:
 947                 return _TRUE;
 948         default:
 949                 return _FALSE;
 950         }
 951 }
 952 #endif /* !RTW_HALMAC */
 953
 954 s32 rtw_hal_is_disable_sw_channel_plan(PADAPTER padapter)
 955 {
 956         return GET_HAL_DATA(padapter)->bDisableSWChannelPlan;
 957 }
 958
 959 s32 rtw_hal_macid_sleep(PADAPTER padapter, u8 macid)
 960 {
 961         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 962         struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
 963         u8 support;
 964
 965         support = _FALSE;
 966         rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
 967         if (_FALSE == support)
 968                 return _FAIL;
 969
 970         if (macid >= macid_ctl->num) {
 971                 RTW_ERR(FUNC_ADPT_FMT": Invalid macid(%u)\n",
 972                         FUNC_ADPT_ARG(padapter), macid);
 973                 return _FAIL;
 974         }
 975
 976         rtw_hal_set_hwreg(padapter, HW_VAR_MACID_SLEEP, &macid);
 977
 978         return _SUCCESS;
 979 }
 980
 981 s32 rtw_hal_macid_wakeup(PADAPTER padapter, u8 macid)
 982 {
 983         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 984         struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
 985         u8 support;
 986
 987         support = _FALSE;
 988         rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
 989         if (_FALSE == support)
 990                 return _FAIL;
 991
 992         if (macid >= macid_ctl->num) {
 993                 RTW_ERR(FUNC_ADPT_FMT": Invalid macid(%u)\n",
 994                         FUNC_ADPT_ARG(padapter), macid);
 995                 return _FAIL;
 996         }
 997
 998         rtw_hal_set_hwreg(padapter, HW_VAR_MACID_WAKEUP, &macid);
 999
1000         return _SUCCESS;
1001 }
1002
1003 s32 rtw_hal_fill_h2c_cmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
1004 {
1005         _adapter *pri_adapter = GET_PRIMARY_ADAPTER(padapter);
1006
1007         if (pri_adapter->bFWReady == _TRUE)
1008                 return padapter->hal_func.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
1009         else if (padapter->registrypriv.mp_mode == 0)
1010                 RTW_PRINT(FUNC_ADPT_FMT" FW doesn't exit when no MP mode, by pass H2C id:0x%02x\n"
1011                           , FUNC_ADPT_ARG(padapter), ElementID);
1012         return _FAIL;
1013 }
1014
1015 void rtw_hal_fill_fake_txdesc(_adapter *padapter, u8 *pDesc, u32 BufferLen,
1016                               u8 IsPsPoll, u8 IsBTQosNull, u8 bDataFrame)
1017 {
1018         padapter->hal_func.fill_fake_txdesc(padapter, pDesc, BufferLen, IsPsPoll, IsBTQosNull, bDataFrame);
1019
1020 }
1021 u8 rtw_hal_get_txbuff_rsvd_page_num(_adapter *adapter, bool wowlan)
1022 {
1023         return adapter->hal_func.hal_get_tx_buff_rsvd_page_num(adapter, wowlan);
1024 }
1025
1026 #ifdef CONFIG_GPIO_API
1027 void rtw_hal_update_hisr_hsisr_ind(_adapter *padapter, u32 flag)
1028 {
1029         if (padapter->hal_func.update_hisr_hsisr_ind)
1030                 padapter->hal_func.update_hisr_hsisr_ind(padapter, flag);
1031 }
1032
1033 int rtw_hal_gpio_func_check(_adapter *padapter, u8 gpio_num)
1034 {
1035         int ret = _SUCCESS;
1036
1037         if (padapter->hal_func.hal_gpio_func_check)
1038                 ret = padapter->hal_func.hal_gpio_func_check(padapter, gpio_num);
1039
1040         return ret;
1041 }
1042
1043 void rtw_hal_gpio_multi_func_reset(_adapter *padapter, u8 gpio_num)
1044 {
1045         if (padapter->hal_func.hal_gpio_multi_func_reset)
1046                 padapter->hal_func.hal_gpio_multi_func_reset(padapter, gpio_num);
1047 }
1048 #endif
1049
1050 void rtw_hal_fw_correct_bcn(_adapter *padapter)
1051 {
1052         if (padapter->hal_func.fw_correct_bcn)
1053                 padapter->hal_func.fw_correct_bcn(padapter);
1054 }
1055
1056 void rtw_hal_set_tx_power_index(PADAPTER padapter, u32 powerindex, u8 rfpath, u8 rate)
1057 {
1058         return padapter->hal_func.set_tx_power_index_handler(padapter, powerindex, rfpath, rate);
1059 }
1060
1061 u8 rtw_hal_get_tx_power_index(PADAPTER padapter, u8 rfpath, u8 rate, u8 bandwidth, u8 channel, struct txpwr_idx_comp *tic)
1062 {
1063         return padapter->hal_func.get_tx_power_index_handler(padapter, rfpath, rate, bandwidth, channel, tic);
1064 }
1065
1066 #ifdef RTW_HALMAC
1067 /*
1068  * Description:
1069  *      Initialize MAC registers
1070  *
1071  * Return:
1072  *      _TRUE   success
1073  *      _FALSE  fail
1074  */
1075 u8 rtw_hal_init_mac_register(PADAPTER adapter)
1076 {
1077         return adapter->hal_func.init_mac_register(adapter);
1078 }
1079
1080 /*
1081  * Description:
1082  *      Initialize PHY(BB/RF) related functions
1083  *
1084  * Return:
1085  *      _TRUE   success
1086  *      _FALSE  fail
1087  */
1088 u8 rtw_hal_init_phy(PADAPTER adapter)
1089 {
1090         return adapter->hal_func.init_phy(adapter);
1091 }
1092 #endif /* RTW_HALMAC */
1093
1094 #define rtw_hal_error_msg(ops_fun)              \
1095         RTW_PRINT("### %s - Error : Please hook hal_func.%s ###\n", __FUNCTION__, ops_fun)
1096
1097 u8 rtw_hal_ops_check(_adapter *padapter)
1098 {
1099         u8 ret = _SUCCESS;
1100 #if 1
1101         /*** initialize section ***/
1102         if (NULL == padapter->hal_func.read_chip_version) {
1103                 rtw_hal_error_msg("read_chip_version");
1104                 ret = _FAIL;
1105         }
1106         if (NULL == padapter->hal_func.init_default_value) {
1107                 rtw_hal_error_msg("init_default_value");
1108                 ret = _FAIL;
1109         }
1110         if (NULL == padapter->hal_func.intf_chip_configure) {
1111                 rtw_hal_error_msg("intf_chip_configure");
1112                 ret = _FAIL;
1113         }
1114         if (NULL == padapter->hal_func.read_adapter_info) {
1115                 rtw_hal_error_msg("read_adapter_info");
1116                 ret = _FAIL;
1117         }
1118
1119         if (NULL == padapter->hal_func.hal_power_on) {
1120                 rtw_hal_error_msg("hal_power_on");
1121                 ret = _FAIL;
1122         }
1123         if (NULL == padapter->hal_func.hal_power_off) {
1124                 rtw_hal_error_msg("hal_power_off");
1125                 ret = _FAIL;
1126         }
1127
1128         if (NULL == padapter->hal_func.hal_init) {
1129                 rtw_hal_error_msg("hal_init");
1130                 ret = _FAIL;
1131         }
1132         if (NULL == padapter->hal_func.hal_deinit) {
1133                 rtw_hal_error_msg("hal_deinit");
1134                 ret = _FAIL;
1135         }
1136
1137         /*** xmit section ***/
1138         if (NULL == padapter->hal_func.init_xmit_priv) {
1139                 rtw_hal_error_msg("init_xmit_priv");
1140                 ret = _FAIL;
1141         }
1142         if (NULL == padapter->hal_func.free_xmit_priv) {
1143                 rtw_hal_error_msg("free_xmit_priv");
1144                 ret = _FAIL;
1145         }
1146         if (NULL == padapter->hal_func.hal_xmit) {
1147                 rtw_hal_error_msg("hal_xmit");
1148                 ret = _FAIL;
1149         }
1150         if (NULL == padapter->hal_func.mgnt_xmit) {
1151                 rtw_hal_error_msg("mgnt_xmit");
1152                 ret = _FAIL;
1153         }
1154 #ifdef CONFIG_XMIT_THREAD_MODE
1155         if (NULL == padapter->hal_func.xmit_thread_handler) {
1156                 rtw_hal_error_msg("xmit_thread_handler");
1157                 ret = _FAIL;
1158         }
1159 #endif
1160         if (NULL == padapter->hal_func.hal_xmitframe_enqueue) {
1161                 rtw_hal_error_msg("hal_xmitframe_enqueue");
1162                 ret = _FAIL;
1163         }
1164 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
1165 #ifndef CONFIG_SDIO_TX_TASKLET
1166         if (NULL == padapter->hal_func.run_thread) {
1167                 rtw_hal_error_msg("run_thread");
1168                 ret = _FAIL;
1169         }
1170         if (NULL == padapter->hal_func.cancel_thread) {
1171                 rtw_hal_error_msg("cancel_thread");
1172                 ret = _FAIL;
1173         }
1174 #endif
1175 #endif
1176
1177         /*** recv section ***/
1178         if (NULL == padapter->hal_func.init_recv_priv) {
1179                 rtw_hal_error_msg("init_recv_priv");
1180                 ret = _FAIL;
1181         }
1182         if (NULL == padapter->hal_func.free_recv_priv) {
1183                 rtw_hal_error_msg("free_recv_priv");
1184                 ret = _FAIL;
1185         }
1186 #ifdef CONFIG_RECV_THREAD_MODE
1187         if (NULL == padapter->hal_func.recv_hdl) {
1188                 rtw_hal_error_msg("recv_hdl");
1189                 ret = _FAIL;
1190         }
1191 #endif
1192 #if defined(CONFIG_USB_HCI) || defined(CONFIG_PCI_HCI)
1193         if (NULL == padapter->hal_func.inirp_init) {
1194                 rtw_hal_error_msg("inirp_init");
1195                 ret = _FAIL;
1196         }
1197         if (NULL == padapter->hal_func.inirp_deinit) {
1198                 rtw_hal_error_msg("inirp_deinit");
1199                 ret = _FAIL;
1200         }
1201 #endif /* #if defined(CONFIG_USB_HCI) || defined (CONFIG_PCI_HCI) */
1202
1203
1204         /*** interrupt hdl section ***/
1205 #if defined(CONFIG_PCI_HCI)
1206         if (NULL == padapter->hal_func.irp_reset) {
1207                 rtw_hal_error_msg("irp_reset");
1208                 ret = _FAIL;
1209         }
1210 #endif/*#if defined(CONFIG_PCI_HCI)*/
1211 #if (defined(CONFIG_PCI_HCI)) || (defined(CONFIG_USB_HCI) && defined(CONFIG_SUPPORT_USB_INT))
1212         if (NULL == padapter->hal_func.interrupt_handler) {
1213                 rtw_hal_error_msg("interrupt_handler");
1214                 ret = _FAIL;
1215         }
1216 #endif /*#if (defined(CONFIG_PCI_HCI)) || (defined(CONFIG_USB_HCI) && defined(CONFIG_SUPPORT_USB_INT))*/
1217
1218 #if defined(CONFIG_PCI_HCI) || defined(CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI)
1219         if (NULL == padapter->hal_func.enable_interrupt) {
1220                 rtw_hal_error_msg("enable_interrupt");
1221                 ret = _FAIL;
1222         }
1223         if (NULL == padapter->hal_func.disable_interrupt) {
1224                 rtw_hal_error_msg("disable_interrupt");
1225                 ret = _FAIL;
1226         }
1227 #endif /* defined(CONFIG_PCI_HCI) || defined (CONFIG_SDIO_HCI) || defined (CONFIG_GSPI_HCI) */
1228
1229
1230         /*** DM section ***/
1231         if (NULL == padapter->hal_func.dm_init) {
1232                 rtw_hal_error_msg("dm_init");
1233                 ret = _FAIL;
1234         }
1235         if (NULL == padapter->hal_func.dm_deinit) {
1236                 rtw_hal_error_msg("dm_deinit");
1237                 ret = _FAIL;
1238         }
1239         if (NULL == padapter->hal_func.hal_dm_watchdog) {
1240                 rtw_hal_error_msg("hal_dm_watchdog");
1241                 ret = _FAIL;
1242         }
1243 #ifdef CONFIG_LPS_LCLK_WD_TIMER
1244         if (NULL == padapter->hal_func.hal_dm_watchdog_in_lps) {
1245                 rtw_hal_error_msg("hal_dm_watchdog_in_lps");
1246                 ret = _FAIL;
1247         }
1248 #endif
1249
1250         /*** xxx section ***/
1251         if (NULL == padapter->hal_func.set_chnl_bw_handler) {
1252                 rtw_hal_error_msg("set_chnl_bw_handler");
1253                 ret = _FAIL;
1254         }
1255
1256         if (NULL == padapter->hal_func.set_hw_reg_handler) {
1257                 rtw_hal_error_msg("set_hw_reg_handler");
1258                 ret = _FAIL;
1259         }
1260         if (NULL == padapter->hal_func.GetHwRegHandler) {
1261                 rtw_hal_error_msg("GetHwRegHandler");
1262                 ret = _FAIL;
1263         }
1264         if (NULL == padapter->hal_func.get_hal_def_var_handler) {
1265                 rtw_hal_error_msg("get_hal_def_var_handler");
1266                 ret = _FAIL;
1267         }
1268         if (NULL == padapter->hal_func.SetHalDefVarHandler) {
1269                 rtw_hal_error_msg("SetHalDefVarHandler");
1270                 ret = _FAIL;
1271         }
1272         if (NULL == padapter->hal_func.GetHalODMVarHandler) {
1273                 rtw_hal_error_msg("GetHalODMVarHandler");
1274                 ret = _FAIL;
1275         }
1276         if (NULL == padapter->hal_func.SetHalODMVarHandler) {
1277                 rtw_hal_error_msg("SetHalODMVarHandler");
1278                 ret = _FAIL;
1279         }
1280         if (NULL == padapter->hal_func.update_ra_mask_handler) {
1281                 rtw_hal_error_msg("update_ra_mask_handler");
1282                 ret = _FAIL;
1283         }
1284
1285         if (NULL == padapter->hal_func.SetBeaconRelatedRegistersHandler) {
1286                 rtw_hal_error_msg("SetBeaconRelatedRegistersHandler");
1287                 ret = _FAIL;
1288         }
1289
1290         if (NULL == padapter->hal_func.fill_h2c_cmd) {
1291                 rtw_hal_error_msg("fill_h2c_cmd");
1292                 ret = _FAIL;
1293         }
1294
1295 #ifdef RTW_HALMAC
1296         if (NULL == padapter->hal_func.hal_mac_c2h_handler) {
1297                 rtw_hal_error_msg("hal_mac_c2h_handler");
1298                 ret = _FAIL;
1299         }
1300 #elif !defined(CONFIG_RTL8188E)
1301         if (NULL == padapter->hal_func.c2h_handler) {
1302                 rtw_hal_error_msg("c2h_handler");
1303                 ret = _FAIL;
1304         }
1305 #endif
1306
1307 #if defined(CONFIG_LPS) || defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
1308         if (NULL == padapter->hal_func.fill_fake_txdesc) {
1309                 rtw_hal_error_msg("fill_fake_txdesc");
1310                 ret = _FAIL;
1311         }
1312 #endif
1313         if (NULL == padapter->hal_func.hal_get_tx_buff_rsvd_page_num) {
1314                 rtw_hal_error_msg("hal_get_tx_buff_rsvd_page_num");
1315                 ret = _FAIL;
1316         }
1317
1318 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
1319 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
1320         if (NULL == padapter->hal_func.clear_interrupt) {
1321                 rtw_hal_error_msg("clear_interrupt");
1322                 ret = _FAIL;
1323         }
1324 #endif
1325 #endif /* CONFIG_WOWLAN */
1326
1327         if (NULL == padapter->hal_func.fw_dl) {
1328                 rtw_hal_error_msg("fw_dl");
1329                 ret = _FAIL;
1330         }
1331
1332         if ((IS_HARDWARE_TYPE_8814A(padapter)
1333              || IS_HARDWARE_TYPE_8822BU(padapter) || IS_HARDWARE_TYPE_8822BS(padapter))
1334             && NULL == padapter->hal_func.fw_correct_bcn) {
1335                 rtw_hal_error_msg("fw_correct_bcn");
1336                 ret = _FAIL;
1337         }
1338
1339         if (IS_HARDWARE_TYPE_8822B(padapter) || IS_HARDWARE_TYPE_8821C(padapter)) {
1340                 if (!padapter->hal_func.set_tx_power_index_handler) {
1341                         rtw_hal_error_msg("set_tx_power_index_handler");
1342                         ret = _FAIL;
1343                 }
1344         }
1345
1346         if (!padapter->hal_func.get_tx_power_index_handler) {
1347                 rtw_hal_error_msg("get_tx_power_index_handler");
1348                 ret = _FAIL;
1349         }
1350
1351         /*** SReset section ***/
1352 #ifdef DBG_CONFIG_ERROR_DETECT
1353         if (NULL == padapter->hal_func.sreset_init_value) {
1354                 rtw_hal_error_msg("sreset_init_value");
1355                 ret = _FAIL;
1356         }
1357         if (NULL == padapter->hal_func.sreset_reset_value) {
1358                 rtw_hal_error_msg("sreset_reset_value");
1359                 ret = _FAIL;
1360         }
1361         if (NULL == padapter->hal_func.silentreset) {
1362                 rtw_hal_error_msg("silentreset");
1363                 ret = _FAIL;
1364         }
1365         if (NULL == padapter->hal_func.sreset_xmit_status_check) {
1366                 rtw_hal_error_msg("sreset_xmit_status_check");
1367                 ret = _FAIL;
1368         }
1369         if (NULL == padapter->hal_func.sreset_linked_status_check) {
1370                 rtw_hal_error_msg("sreset_linked_status_check");
1371                 ret = _FAIL;
1372         }
1373         if (NULL == padapter->hal_func.sreset_get_wifi_status) {
1374                 rtw_hal_error_msg("sreset_get_wifi_status");
1375                 ret = _FAIL;
1376         }
1377         if (NULL == padapter->hal_func.sreset_inprogress) {
1378                 rtw_hal_error_msg("sreset_inprogress");
1379                 ret = _FAIL;
1380         }
1381 #endif  /* #ifdef DBG_CONFIG_ERROR_DETECT */
1382
1383 #ifdef RTW_HALMAC
1384         if (NULL == padapter->hal_func.init_mac_register) {
1385                 rtw_hal_error_msg("init_mac_register");
1386                 ret = _FAIL;
1387         }
1388         if (NULL == padapter->hal_func.init_phy) {
1389                 rtw_hal_error_msg("init_phy");
1390                 ret = _FAIL;
1391         }
1392 #endif /* RTW_HALMAC */
1393 #endif
1394         return  ret;
1395 }