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