/* check auth_queue */
#ifdef DBG_EXPIRATION_CHK
- if (phead != plist) {
- }
#endif
while (phead != plist) {
psta = container_of(plist, struct sta_info, auth_list);
/* check asoc_queue */
#ifdef DBG_EXPIRATION_CHK
- if (phead != plist) {
- }
#endif
while (phead != plist) {
psta = container_of(plist, struct sta_info, asoc_list);
arg[3] = psta->init_rate;
rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, rssi_level);
- } else {
}
}
psta->state = _FW_LINKED;
spin_unlock_bh(&psta->lock);
- } else {
}
}
pmlmeinfo->SM_PS = (le16_to_cpu(
pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info
) & 0x0C) >> 2;
- if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC)
- {}
/* */
/* Config current HT Protection mode. */
update_beacon(padapter, WLAN_EID_TIM, NULL, true);
/* issue beacon frame */
- if (send_beacon(padapter) == _FAIL)
- {}
+ send_beacon(padapter);
}
/* update bc/mc sta_info */
else if (!memcmp(P2P_OUI, oui, 4))
update_bcn_p2p_ie(padapter);
-
- else
- {}
}
void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx)
psta->no_ht_set = 1;
pmlmepriv->num_sta_no_ht++;
}
- if (pmlmepriv->htpriv.ht_option == true) {
- }
}
if (rtw_ht_operation_update(padapter) > 0) {
for (i = 0; i < chk_alive_num; i++) {
psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
- if (psta == NULL) {
- } else if (psta->state & _FW_LINKED) {
+ if (psta == NULL)
+ continue;
+
+ if (psta->state & _FW_LINKED) {
rtw_sta_media_status_rpt(padapter, psta, 1);
Update_RA_Entry(padapter, psta);
/* pairwise key */
struct cmd_obj *pcmd;
u8 *pcmdbuf;
unsigned long cmd_start_time;
- unsigned long cmd_process_time;
u8 (*cmd_hdl)(struct adapter *padapter, u8 *pbuf);
void (*pcmd_callback)(struct adapter *dev, struct cmd_obj *pcmd);
struct adapter *padapter = context;
mutex_unlock(&(pcmd->padapter->cmdpriv.sctx_mutex));
}
- cmd_process_time = jiffies_to_msecs(jiffies - cmd_start_time);
- if (cmd_process_time > 1000) {
- }
-
/* call callback function for post-processed */
if (pcmd->cmdcode < ARRAY_SIZE(rtw_cmd_callback)) {
pcmd_callback = rtw_cmd_callback[pcmd->cmdcode].callback;
* OUI of the vendor. The following byte is used a vendor specific
* sub-type. */
if (elen < 4) {
- if (show_errors) {
- }
return -1;
}
left -= 2;
if (elen > left) {
- if (show_errors) {
- }
return ParseFailed;
}
int value = atomic_inc_return(&dvobj->continual_io_error);
if (value > MAX_CONTINUAL_IO_ERR) {
ret = true;
- } else {
}
+
return ret;
}
rtw_indicate_disconnect(padapter);
/* modify for CONFIG_IEEE80211W, none 11w can use it */
rtw_free_assoc_resources_cmd(padapter);
- if (_FAIL == rtw_pwr_wakeup(padapter))
- {}
+ rtw_pwr_wakeup(padapter);
}
spin_unlock_bh(&pmlmepriv->lock);
dst->Rssi = rssi_final;
#if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
- if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
- }
#endif
}
}
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
- if (!adapter->bDriverStopped && !adapter->bSurpriseRemoved)
- {}
rtw_indicate_scan_done(adapter, true);
}
pmlmeext->scan_abort = false;
if (adapter->net_closed)
return;
- if (is_primary_adapter(adapter))
- {}
-
if ((adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
&& !(hal_btcoex_IsBtControlLps(adapter))
) {
updated = true;
}
- if (updated) {
- }
-
exit:
return updated;
}
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5))
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
}
- if (phtpriv->ldpc_cap)
- {}
/* STBC */
rtw_hal_get_def_var(padapter, HAL_DEF_TX_STBC, (u8 *)&bHwSTBCSupport);
if (TEST_FLAG(pregistrypriv->stbc_cap, BIT4))
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
}
- if (phtpriv->stbc_cap)
- {}
/* Beamforming setting */
rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER, (u8 *)&bHwSupportBeamformer);
pmlmeinfo->SM_PS =
(le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) &
0x0C) >> 2;
- if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC)
- {}
/* */
/* Config current HT Protection mode. */
/* get a unique AID */
- if (pstat->aid > 0) {
- } else {
+ if (pstat->aid == 0) {
for (pstat->aid = 1; pstat->aid <= NUM_STA; pstat->aid++)
if (pstapriv->sta_aid[pstat->aid - 1] == NULL)
break;
#endif
}
- if (try_cnt && wait_ms) {
- if (da)
- {}
- else
- {}
- }
exit:
return ret;
}
if ((pmlmeinfo->network.SupportedRates[i]|IEEE80211_BASIC_RATE_MASK)
== (sta_bssrate[j]|IEEE80211_BASIC_RATE_MASK)) {
break;
- } else {
}
}
- if (j == sta_bssrate_len) {
- } else {
+ if (j != sta_bssrate_len) {
/* the rate is supported by STA */
bssrate[index++] = pmlmeinfo->network.SupportedRates[i];
}
#endif
}
- if (try_cnt && wait_ms) {
- if (da)
- {}
- else
- {}
- }
exit:
return ret;
}
#endif
}
- if (try_cnt && wait_ms) {
- if (da)
- {}
- else
- {}
- }
exit:
return ret;
}
#endif
}
- if (try_cnt && wait_ms) {
- if (da)
- {}
- else
- {}
- }
exit:
return ret;
}
u8 bxmitok = false;
int issue = 0;
int poll = 0;
- unsigned long start = jiffies;
rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
if (false == bxmitok) {
return _FAIL;
} else {
- unsigned long passing_time = jiffies_to_msecs(jiffies - start);
-
- if (passing_time > 100 || issue > 3)
- {}
- /* else */
-
return _SUCCESS;
}
}
}
#if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) & 1
- if (strcmp(bssid->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
- }
#endif
/* mark bss info receiving from nearby channel as SignalQuality 101 */
pslv = PS_STATE(pslv);
- if (pwrpriv->brpwmtimeout) {
- } else {
+ if (!pwrpriv->brpwmtimeout) {
if (pwrpriv->rpwm == pslv ||
(pwrpriv->rpwm >= PS_STATE_S2 && pslv >= PS_STATE_S2))
return;
rtw_lps_ctrl_wk_cmd(pri_padapter, LPS_CTRL_LEAVE, 0);
} else {
if (pwrpriv->rf_pwrstate == rf_off)
- if (!ips_leave(pri_padapter))
- {}
+ ips_leave(pri_padapter);
}
}
LPS_Leave_check(Adapter);
} else {
if (adapter_to_pwrctl(Adapter)->rf_pwrstate == rf_off) {
- if (!ips_leave(Adapter))
- {}
+ ips_leave(Adapter);
}
}
}
if (pwrpriv->ps_processing) {
while (pwrpriv->ps_processing && jiffies_to_msecs(jiffies - start) <= 3000)
mdelay(10);
- if (pwrpriv->ps_processing)
- {}
- else
- {}
}
if (!(pwrpriv->bInternalAutoSuspend) && pwrpriv->bInSuspend) {
) {
mdelay(10);
}
- if (pwrpriv->bInSuspend)
- {}
- else
- {}
}
/* System suspend is not allowed to wakeup */
pwrpriv = adapter_to_pwrctl(padapter);
mutex_lock(&pwrpriv->lock);
- if (pwrpriv->ps_deny & BIT(reason)) {
- }
pwrpriv->ps_deny |= BIT(reason);
mutex_unlock(&pwrpriv->lock);
}
pwrpriv = adapter_to_pwrctl(padapter);
mutex_lock(&pwrpriv->lock);
- if ((pwrpriv->ps_deny & BIT(reason)) == 0) {
- }
pwrpriv->ps_deny &= ~BIT(reason);
mutex_unlock(&pwrpriv->lock);
}
cnt++;
}
- if (cnt)
- {}
-
return cnt;
}
if ((prxattrib->bdecrypted == true) && (brpt_micerror == true)) {
rtw_handle_tkip_mic_err(adapter, (u8)IS_MCAST(prxattrib->ra));
- } else {
}
res = _FAIL;
cnt++;
recv_func_posthandle(padapter, pending_frame);
}
-
- if (cnt)
- {}
}
ret = recv_func_prehandle(padapter, rframe);
{
int offset = (((u8 *)sta) - stapriv->pstainfo_buf)/sizeof(struct sta_info);
- if (!stainfo_offset_valid(offset))
- {}
-
return offset;
}
inline struct sta_info *rtw_get_stainfo_by_offset(struct sta_priv *stapriv, int offset)
{
- if (!stainfo_offset_valid(offset))
- {}
-
return (struct sta_info *)(stapriv->pstainfo_buf + offset * sizeof(struct sta_info));
}
{
u8 center_ch, chnl_offset80 = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
- if (padapter->bNotifyChannelChange)
- {}
-
center_ch = rtw_get_center_ch(channel, bwmode, channel_offset);
if (bwmode == CHANNEL_WIDTH_80) {
break;
}
- if (addr)
- {}
- else
- {}
-
return cam_id;
}
if (pxmitbuf->sctx) {
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
- } else {
}
return pxmitbuf;
}
}
#ifdef DBG_XMIT_BUF
- else
- {}
#endif
spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
pxmitframe = rtw_alloc_xmitframe(pxmitpriv);
if (jiffies_to_msecs(jiffies - start) > 2000) {
- if (drop_cnt)
- {}
start = jiffies;
drop_cnt = 0;
}
return ret;
}
-static bool rtw_sctx_chk_warning_status(int status)
-{
- switch (status) {
- case RTW_SCTX_DONE_UNKNOWN:
- case RTW_SCTX_DONE_BUF_ALLOC:
- case RTW_SCTX_DONE_BUF_FREE:
-
- case RTW_SCTX_DONE_DRV_STOP:
- case RTW_SCTX_DONE_DEV_REMOVE:
- return true;
- default:
- return false;
- }
-}
-
void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
{
if (*sctx) {
- if (rtw_sctx_chk_warning_status(status))
- {}
(*sctx)->status = status;
complete(&((*sctx)->done));
*sctx = NULL;
if (pxmitpriv->ack_tx)
rtw_sctx_done_err(&pack_tx_ops, status);
- else
- {}
}
/* res |= (padapter->eeprompriv.EEPROMRFGainVal & 0x0f)<< 15; */
/* rtw_hal_write_rfreg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, RF_GAIN_OFFSET_MASK, res); */
res = rtw_hal_read_rfreg(padapter, RF_PATH_A, 0x7f, 0xffffffff);
- } else
- {}
- } else
- {}
+ }
+ }
}
default:
break;
}
- } else
- {}
+ }
return value;
}
default:
break;
}
- } else
- {}
+ }
}
static void
pHalData->pwrGroupCnt++;
else if (RegAddr == rTxAGC_B_Mcs15_Mcs12 && pHalData->rf_type != RF_1T1R)
pHalData->pwrGroupCnt++;
- } else
- {}
-
+ }
}
static void
pHalData->CurrentChannelBW,
Channel, vhtRates4T,
ARRAY_SIZE(vhtRates4T));
- } else
- {}
+ }
}
static bool phy_GetChnlIndex(u8 Channel, u8 *ChannelIdx)
txPower = pHalData->Index24G_CCK_Base[RFPath][chnlIdx];
else if (MGN_6M <= Rate)
txPower = pHalData->Index24G_BW40_Base[RFPath][chnlIdx];
- else
- {}
/* OFDM-1T */
if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate)) {
} else {/* 3 ============================== 5 G ============================== */
if (MGN_6M <= Rate)
txPower = pHalData->Index5G_BW40_Base[RFPath][chnlIdx];
- else
- {}
/* OFDM-1T */
if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate)) {
if (channel5G[i] == Channel)
channelIndex = i;
}
- } else
- {}
-
- if (channelIndex == -1)
- {}
+ }
return channelIndex;
}
idx_bandwidth = get_bandwidth_idx(bandwidth);
idx_rate_sctn = get_rate_sctn_idx(data_rate);
- if (band_type == BAND_ON_5G && idx_rate_sctn == 0)
- {}
-
/* workaround for wrong index combination to obtain tx power limit, */
/* OFDM only exists in BW 20M */
/* CCK table will only be given in BW 20M */
[idx_rate_sctn]
[idx_channel]
[rf_path];
- } else {
}
return pwr_lmt;
u8 regulation = 0, bandwidth = 0, rateSection = 0, channel;
s8 powerLimit = 0, prevPowerLimit, channelIndex;
- if (!GetU1ByteIntegerFromStringInDecimal((s8 *)Channel, &channel) ||
- !GetU1ByteIntegerFromStringInDecimal((s8 *)PowerLimit, &powerLimit))
- {}
+ GetU1ByteIntegerFromStringInDecimal((s8 *)Channel, &channel);
+ GetU1ByteIntegerFromStringInDecimal((s8 *)PowerLimit, &powerLimit);
powerLimit = powerLimit > MAX_POWER_INDEX ? MAX_POWER_INDEX : powerLimit;
if (status == _SUCCESS) {
padapter = dvobj->padapters;
padapter->hw_init_completed = false;
- } else {
}
+
return status;
}
{
if (padapter->HalFunc.enable_interrupt)
padapter->HalFunc.enable_interrupt(padapter);
- else
- {}
}
void rtw_hal_disable_interrupt(struct adapter *padapter)
{
if (padapter->HalFunc.disable_interrupt)
padapter->HalFunc.disable_interrupt(padapter);
- else
- {}
}
u8 rtw_hal_check_ips_status(struct adapter *padapter)
u8 val = false;
if (padapter->HalFunc.check_ips_status)
val = padapter->HalFunc.check_ips_status(padapter);
- else
- {}
return val;
}
if (padapter->HalFunc.fill_h2c_cmd)
ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
- else
- {}
return ret;
}
u8 u1H2CPwrModeParm[H2C_PWRMODE_LEN] = {0};
u8 PowerState = 0, awake_intvl = 1, byte5 = 0, rlbm = 0;
- if (pwrpriv->dtim > 0)
- {}
- else
- {}
-
if (pwrpriv->dtim > 0 && pwrpriv->dtim < 16)
awake_intvl = pwrpriv->dtim+1;/* DTIM = (awake_intvl - 1) */
else
pmlmeext->bcn_cnt = 0;
pmlmeext->adaptive_tsf_done = true;
- } else {
}
/* offload to FW if fw version > v15.10
} while (!bcn_valid && DLBcnCount <= 100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
if (padapter->bSurpriseRemoved || padapter->bDriverStopped) {
- } else if (!bcn_valid)
- {}
- else {
+ } else {
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
pwrctl->fw_psmode_iface_id = padapter->iface_id;
}
msleep(1);
} while (count++ < 100);
- if (count > 0)
- {}
-
/* 8051 reset */
tmp = rtw_read8(padapter, REG_MCUFWDL+2);
rtw_write8(padapter, REG_MCUFWDL+2, tmp&0xf7);
SCSettingOfDesc = VHT_DATA_SC_40_LOWER_OF_80MHZ;
else if (pHalData->nCur80MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_UPPER)
SCSettingOfDesc = VHT_DATA_SC_40_UPPER_OF_80MHZ;
- else
- {}
} else {
if ((pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER) && (pHalData->nCur80MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER))
SCSettingOfDesc = VHT_DATA_SC_20_LOWEST_OF_80MHZ;
SCSettingOfDesc = VHT_DATA_SC_20_UPPER_OF_80MHZ;
else if ((pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_UPPER) && (pHalData->nCur80MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_UPPER))
SCSettingOfDesc = VHT_DATA_SC_20_UPPERST_OF_80MHZ;
- else
- {}
}
} else if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_40) {
if (pattrib->bwmode == CHANNEL_WIDTH_40) {
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
- if (Adapter->bNotifyChannelChange) {
- }
-
if (Adapter->bDriverStopped || Adapter->bSurpriseRemoved)
return;
alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
}
-
- if (!precvbuf->pskb) {
- }
}
list_add_tail(&precvbuf->list, &precvpriv->free_recv_buf_queue.queue);
HalQueryTxOQTBufferStatus8723BSdio(padapter);
if ((++n % 60) == 0) {
- if ((n % 300) == 0) {
- }
msleep(1);
/* yield(); */
}
cnt++;
mdelay(10);
} while (cnt < 100 && (val8 != 0xEA));
- } else {
}
adapter_to_pwrctl(padapter)->pre_ips_type = 0;
/* This part read and parse the eeprom/efuse content */
/* */
- if (sizeof(pEEPROM->efuse_eeprom_data) < HWSET_MAX_SIZE_8723B)
- {}
-
hwinfo = pEEPROM->efuse_eeprom_data;
Hal_InitPGData(padapter, hwinfo);
}
} else {
/* Error handling for malloc fail */
- if (rtw_cbuf_push(adapter->evtpriv.c2h_queue, NULL) != _SUCCESS)
- {}
+ rtw_cbuf_push(adapter->evtpriv.c2h_queue, NULL);
_set_workitem(&adapter->evtpriv.c2h_wk);
}
}
if (!hisr)
break;
} while (1);
-
- if (alloc_fail_time == 10)
- {}
-
}
}
{
DBG_8192C("ssid =%s, len =%d\n", pssid->Ssid, pssid->SsidLength);
- if (ssids[0].ssid_len == 0) {
- }
- else if (pssid->SsidLength == ssids[0].ssid_len &&
- !memcmp(pssid->Ssid, ssids[0].ssid, ssids[0].ssid_len))
- {
- }
- else
+ if (ssids[0].ssid_len != 0 &&
+ (pssid->SsidLength != ssids[0].ssid_len ||
+ memcmp(pssid->Ssid, ssids[0].ssid, ssids[0].ssid_len)))
{
if (psr)
*psr = 0; /* clear sr */
{
memcpy(&cur_network->network, pnetwork, sizeof(struct wlan_bssid_ex));
- if (!rtw_cfg80211_inform_bss(padapter, cur_network))
- {}
- else
- {}
+ rtw_cfg80211_inform_bss(padapter, cur_network);
}
else
{
if (!memcmp(&(scanned->network.Ssid), &(pnetwork->Ssid), sizeof(struct ndis_802_11_ssid))
&& !memcmp(scanned->network.MacAddress, pnetwork->MacAddress, sizeof(NDIS_802_11_MAC_ADDRESS))
) {
- if (!rtw_cfg80211_inform_bss(padapter, scanned)) {
- } else {
- }
+ rtw_cfg80211_inform_bss(padapter, scanned);
} else {
rtw_warn_on(1);
}
if (!memcmp(scanned->network.MacAddress, pnetwork->MacAddress, sizeof(NDIS_802_11_MAC_ADDRESS))
&& !memcmp(&(scanned->network.Ssid), &(pnetwork->Ssid), sizeof(struct ndis_802_11_ssid))
) {
- if (!rtw_cfg80211_inform_bss(padapter, scanned)) {
- } else {
- }
+ rtw_cfg80211_inform_bss(padapter, scanned);
} else {
rtw_warn_on(1);
}
DBG_8192C("RTW_Tx:da =%pM via "FUNC_NDEV_FMT"\n",
MAC_ARG(GetAddr1Ptr(buf)), FUNC_NDEV_ARG(ndev));
- if (category == RTW_WLAN_CATEGORY_PUBLIC)
- {}
- else
- {}
/* starting alloc mgmt frame to dump it */
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
rtw_action_frame_parse(frame, frame_len, &category, &action);
DBG_8192C("RTW_Rx:cur_ch =%d\n", channel);
- if (msg)
- {}
- else
- {}
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
}
DBG_8192C("RTW_Tx:tx_ch =%d, da =%pM\n", tx_ch, MAC_ARG(GetAddr1Ptr(buf)));
- if (category == RTW_WLAN_CATEGORY_PUBLIC)
- {}
- else
- {}
rtw_ps_deny(padapter, PS_DENY_MGNT_TX);
if (_FAIL == rtw_pwr_wakeup(padapter)) {
tx_ret = _cfg80211_rtw_mgmt_tx(padapter, tx_ch, buf, len);
} while (dump_cnt < dump_limit && tx_ret != _SUCCESS);
- if (tx_ret != _SUCCESS || dump_cnt > 1) {
- }
-
switch (type) {
case P2P_GO_NEGO_CONF:
rtw_clear_scan_deny(padapter);
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
}
- } else if (value & WLAN_AUTH_LEAP) {
} else {
ret = -EINVAL;
}
spin_unlock_bh(&pmlmepriv->lock);
- } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
}
} else if (wrqu->data.length >= WEXT_CSCAN_HEADER_SIZE
if (wrqu->essid.flags && wrqu->essid.length) {
len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? wrqu->essid.length : IW_ESSID_MAX_SIZE;
- if (wrqu->essid.length != 33)
- {}
-
memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
ndis_ssid.SsidLength = len;
memcpy(ndis_ssid.Ssid, extra, len);
struct adapter *padapter = rtw_netdev_priv(dev);
u8 channel_plan_req = (u8)(*((int *)wrqu));
- if (_SUCCESS == rtw_set_chplan_cmd(padapter, channel_plan_req, 1, 1))
- {}
- else
+ if (_SUCCESS != rtw_set_chplan_cmd(padapter, channel_plan_req, 1, 1))
return -EPERM;
return 0;
if (selector < 3 && selector >= 0) {
padapter->pid[selector] = *(pdata+1);
}
- else
- {}
exit:
for (i = 0; i < 16; i++) {
preorder_ctrl = &psta->recvreorder_ctrl[i];
- if (preorder_ctrl->enable)
- {}
}
- } else {
}
break;
case 0x06:
if (extra_arg == psta->aid) {
for (j = 0; j < 16; j++) {
preorder_ctrl = &psta->recvreorder_ctrl[j];
- if (preorder_ctrl->enable)
- {}
}
}
}
/* default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ */
if (extra_arg == 0 || extra_arg == 1 || extra_arg == 2 || extra_arg == 3) {
pregpriv->rx_stbc = extra_arg;
- } else
- {}
-
+ }
}
break;
case 0x13: /* set ampdu_enable */
/* 0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */
if (extra_arg < 3) {
pregpriv->ampdu_enable = extra_arg;
- } else
- {}
-
+ }
}
break;
case 0x14:
psta = NULL;
- } else {
- /* ret = -1; */
}
-
return ret;
}
param->u.wpa_ie.len = copy_len;
memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
- } else {
}
} else {
ret = -1;
memcpy(ssid, ssid_ie+2, ssid_len);
ssid[ssid_len] = 0x0;
- if (0)
- {}
-
memcpy(pbss_network->Ssid.Ssid, (void *)ssid, ssid_len);
pbss_network->Ssid.SsidLength = ssid_len;
memcpy(pbss_network_ext->Ssid.Ssid, (void *)ssid, ssid_len);
pbss_network_ext->Ssid.SsidLength = ssid_len;
-
- if (0)
- {}
}
return ret;
padapter->bup = false;
- } else {
}
}
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
rtw_ap_restore_network(padapter);
- } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
- } else {
}
exit:
v = sdio_f0_readb(func, addr, err);
if (claim_needed)
sdio_release_host(func);
- if (err && *err)
- {}
return v;
}
v = sdio_readb(func, addr, err);
if (claim_needed)
sdio_release_host(func);
- if (err && *err)
- {}
return v;
}
}
}
}
-
- if (i == SD_IO_TRY_CNT)
- {}
- else
- {}
-
}
return v;
}
sdio_writeb(func, v, addr, err);
if (claim_needed)
sdio_release_host(func);
- if (err && *err)
- {}
}
void sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
}
}
- if (i == SD_IO_TRY_CNT)
- {}
- else
- {}
}
}
}
err = sdio_memcpy_fromio(func, pdata, addr, cnt);
- if (err)
- {}
return err;
}
size = cnt;
err = sdio_memcpy_toio(func, addr, pdata, size);
- if (err)
- {}
return err;
}
res = rtw_mlcst2unicst(padapter, pkt);
if (res)
goto exit;
- } else {
}
}
projects / platform / kernel / linux-starfive.git / commitdiff