Parentheses are not needed around the right hand side of an assignment.
This patch remove parenthese of such occurenses. Issue was detected and
solved using the following coccinelle script:
@rule1@
identifier x, y, z;
expression E1, E2;
@@
(
x = (y == z);
|
x = (E1 == E2);
|
 x =
-(
...
-)
 ;
)
Signed-off-by: Haneen Mohammed <hamohammed.sa@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
                                continue;
                        } else {
                                offset = ((rtemp8 & 0xF0) >> 1) | u1temp;
-                               wren = (rtemp8 & 0x0F);
+                               wren = rtemp8 & 0x0F;
                                eFuse_Addr++;
                        }
                } else {
-                       offset = ((rtemp8 >> 4) & 0x0f);
-                       wren = (rtemp8 & 0x0f);
+                       offset = (rtemp8 >> 4) & 0x0f;
+                       wren = rtemp8 & 0x0f;
                }
 
                if (offset < EFUSE_MAX_SECTION_88E) {
 
 
        /* Search required WPA or WPA2 IE and copy to sec_ie[] */
 
-       cnt = (_TIMESTAMP_ + _BEACON_ITERVAL_ + _CAPABILITY_);
+       cnt = _TIMESTAMP_ + _BEACON_ITERVAL_ + _CAPABILITY_;
 
        sec_idx = 0;
 
 
        p = rtw_get_ie(pie+sizeof(struct ndis_802_11_fixed_ie), _HT_CAPABILITY_IE_, &len, ie_len-sizeof(struct ndis_802_11_fixed_ie));
        if (p && len > 0) {
                pht_capie = (struct rtw_ieee80211_ht_cap *)(p+2);
-               max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR);
+               max_ampdu_sz = pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR;
                max_ampdu_sz = 1 << (max_ampdu_sz+3); /*  max_ampdu_sz (kbytes); */
                phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
        }
 
                        break;
                case RTW_WLAN_ACTION_ADDBA_RESP: /* ADDBA response */
                        status = get_unaligned_le16(&frame_body[3]);
-                       tid = ((frame_body[5] >> 2) & 0x7);
+                       tid = (frame_body[5] >> 2) & 0x7;
                        if (status == 0) {      /* successful */
                                DBG_88E("agg_enable for TID=%d\n", tid);
                                psta->htpriv.agg_enable_bitmap |= 1 << tid;
 
                /* setting IV for auth seq #3 */
                if ((pmlmeinfo->auth_seq == 3) && (pmlmeinfo->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1)) {
-                       val32 = ((pmlmeinfo->iv++) | (pmlmeinfo->key_index << 30));
+                       val32 = (pmlmeinfo->iv++) | (pmlmeinfo->key_index << 30);
                        le_tmp32 = cpu_to_le32(val32);
                        pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *)&le_tmp32, &(pattrib->pktlen));
 
                        } while (pmlmeinfo->dialogToken == 0);
                        pframe = rtw_set_fixed_ie(pframe, 1, &(pmlmeinfo->dialogToken), &(pattrib->pktlen));
 
-                       BA_para_set = (0x1002 | ((status & 0xf) << 2)); /* immediate ack & 64 buffer size */
+                       BA_para_set = 0x1002 | ((status & 0xf) << 2); /* immediate ack & 64 buffer size */
                        le_tmp = cpu_to_le16(BA_para_set);
                        pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(le_tmp)), &(pattrib->pktlen));
 
        if (pcmd_obj == NULL)
                return;
 
-       cmdsz = (sizeof(struct survey_event) + sizeof(struct C2HEvent_Header));
+       cmdsz = sizeof(struct survey_event) + sizeof(struct C2HEvent_Header);
        pevtcmd = kzalloc(cmdsz, GFP_ATOMIC);
        if (pevtcmd == NULL) {
                kfree(pcmd_obj);
        if (pcmd_obj == NULL)
                return;
 
-       cmdsz = (sizeof(struct surveydone_event) + sizeof(struct C2HEvent_Header));
+       cmdsz = sizeof(struct surveydone_event) + sizeof(struct C2HEvent_Header);
        pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
        if (pevtcmd == NULL) {
                kfree(pcmd_obj);
        if (pcmd_obj == NULL)
                return;
 
-       cmdsz = (sizeof(struct joinbss_event) + sizeof(struct C2HEvent_Header));
+       cmdsz = sizeof(struct joinbss_event) + sizeof(struct C2HEvent_Header);
        pevtcmd = kzalloc(cmdsz, GFP_ATOMIC);
        if (pevtcmd == NULL) {
                kfree(pcmd_obj);
        if (pcmd_obj == NULL)
                return;
 
-       cmdsz = (sizeof(struct stadel_event) + sizeof(struct C2HEvent_Header));
+       cmdsz = sizeof(struct stadel_event) + sizeof(struct C2HEvent_Header);
        pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
        if (pevtcmd == NULL) {
                kfree(pcmd_obj);
        if (psta)
                mac_id = (int)psta->mac_id;
        else
-               mac_id = (-1);
+               mac_id = -1;
 
        pdel_sta_evt->mac_id = mac_id;
 
        if (pcmd_obj == NULL)
                return;
 
-       cmdsz = (sizeof(struct stassoc_event) + sizeof(struct C2HEvent_Header));
+       cmdsz = sizeof(struct stassoc_event) + sizeof(struct C2HEvent_Header);
        pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
        if (pevtcmd == NULL) {
                kfree(pcmd_obj);
 
                psta = rtw_get_stainfo(pstapriv, pparm->addr);
                if (psta) {
-                       ctrl = (BIT(15) | ((pparm->algorithm) << 2));
+                       ctrl = BIT(15) | ((pparm->algorithm) << 2);
 
                        DBG_88E("r871x_set_stakey_hdl(): enc_algorithm=%d\n", pparm->algorithm);
 
                                return H2C_REJECTED;
                        }
 
-                       cam_id = (psta->mac_id + 3);/* 0~3 for default key, cmd_id = macid + 3, macid = aid+1; */
+                       cam_id = psta->mac_id + 3;/* 0~3 for default key, cmd_id = macid + 3, macid = aid+1; */
 
                        DBG_88E("Write CAM, mac_addr =%x:%x:%x:%x:%x:%x, cam_entry=%d\n", pparm->addr[0],
                                pparm->addr[1], pparm->addr[2], pparm->addr[3], pparm->addr[4],
 
 
                /* update value of signal_strength, rssi, signal_qual */
                if (check_fwstate(&adapter->mlmepriv, _FW_UNDER_SURVEY) == false) {
-                       tmp_s = (avg_signal_strength+(_alpha-1)*recvpriv->signal_strength);
+                       tmp_s = avg_signal_strength+(_alpha-1)*recvpriv->signal_strength;
                        if (tmp_s % _alpha)
                                tmp_s = tmp_s/_alpha + 1;
                        else
                        if (tmp_s > 100)
                                tmp_s = 100;
 
-                       tmp_q = (avg_signal_qual+(_alpha-1)*recvpriv->signal_qual);
+                       tmp_q = avg_signal_qual+(_alpha-1)*recvpriv->signal_qual;
                        if (tmp_q % _alpha)
                                tmp_q = tmp_q/_alpha + 1;
                        else
 
 
        if (WIFI_STATUS_SUCCESS != psrtpriv->Wifi_Error_Status) {
                DBG_88E("==>%s error_status(0x%x)\n", __func__, psrtpriv->Wifi_Error_Status);
-               status = (psrtpriv->Wifi_Error_Status & (~(USB_READ_PORT_FAIL|USB_WRITE_PORT_FAIL)));
+               status = psrtpriv->Wifi_Error_Status & (~(USB_READ_PORT_FAIL|USB_WRITE_PORT_FAIL));
        }
        DBG_88E("==> %s wifi_status(0x%x)\n", __func__, status);
 
 
        for (j = 5; j >= 0; j--) {
                switch (j) {
                case 0:
-                       val = (ctrl | (mac[0] << 16) | (mac[1] << 24));
+                       val = ctrl | (mac[0] << 16) | (mac[1] << 24);
                        break;
                case 1:
-                       val = (mac[2] | (mac[3] << 8) | (mac[4] << 16) | (mac[5] << 24));
+                       val = mac[2] | (mac[3] << 8) | (mac[4] << 16) | (mac[5] << 24);
                        break;
                default:
                        i = (j - 2) << 2;
-                       val = (key[i] | (key[i+1] << 8) | (key[i+2] << 16) | (key[i+3] << 24));
+                       val = key[i] | (key[i+1] << 8) | (key[i+2] << 16) | (key[i+3] << 24);
                        break;
                }
 
                /* AIFS = AIFSN * slot time + SIFS - r2t phy delay */
                AIFS = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN & 0x0f) * pmlmeinfo->slotTime + aSifsTime;
 
-               ECWMin = (pmlmeinfo->WMM_param.ac_param[i].CW & 0x0f);
+               ECWMin = pmlmeinfo->WMM_param.ac_param[i].CW & 0x0f;
                ECWMax = (pmlmeinfo->WMM_param.ac_param[i].CW & 0xf0) >> 4;
                TXOP = le16_to_cpu(pmlmeinfo->WMM_param.ac_param[i].TXOP_limit);
 
                } else {
                        /* modify from  fw by Thomas 2010/11/17 */
                        if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3) > (pIE->data[i] & 0x3))
-                               max_AMPDU_len = (pIE->data[i] & 0x3);
+                               max_AMPDU_len = pIE->data[i] & 0x3;
                        else
-                               max_AMPDU_len = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3);
+                               max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3;
 
                        if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) > (pIE->data[i] & 0x1c))
-                               min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c);
+                               min_MPDU_spacing = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c;
                        else
-                               min_MPDU_spacing = (pIE->data[i] & 0x1c);
+                               min_MPDU_spacing = pIE->data[i] & 0x1c;
 
                        pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para = max_AMPDU_len | min_MPDU_spacing;
                }
 {
        unsigned int mask = 0;
 
-       mask = ((pHT_caps->u.HT_cap_element.MCS_rate[0] << 12) | (pHT_caps->u.HT_cap_element.MCS_rate[1] << 20));
+       mask = (pHT_caps->u.HT_cap_element.MCS_rate[0] << 12) | (pHT_caps->u.HT_cap_element.MCS_rate[1] << 20);
 
        return mask;
 }
 
 
        if ((NULL == dm_odm) || (macid >= ASSOCIATE_ENTRY_NUM))
                return 0;
-       DecisionRate = (dm_odm->RAInfo[macid].DecisionRate);
+       DecisionRate = dm_odm->RAInfo[macid].DecisionRate;
        ODM_RT_TRACE(dm_odm, ODM_COMP_RATE_ADAPTIVE, ODM_DBG_TRACE,
                (" macid =%d DecisionRate = 0x%x\n", macid, DecisionRate));
        return DecisionRate;
 
        if ((NULL == dm_odm) || (macid >= ASSOCIATE_ENTRY_NUM))
                return 0;
-       PTStage = (dm_odm->RAInfo[macid].PTStage);
+       PTStage = dm_odm->RAInfo[macid].PTStage;
        ODM_RT_TRACE(dm_odm, ODM_COMP_RATE_ADAPTIVE, ODM_DBG_TRACE,
                     ("macid =%d PTStage = 0x%x\n", macid, PTStage));
        return PTStage;
 
                /* The RSSI formula should be modified according to the gain table */
                /* In 88E, cck_highpwr is always set to 1 */
                LNA_idx = (cck_agc_rpt & 0xE0) >> 5;
-               VGA_idx = (cck_agc_rpt & 0x1F);
+               VGA_idx = cck_agc_rpt & 0x1F;
                switch (LNA_idx) {
                case 7:
                        if (VGA_idx <= 27)
 
        if (bitmask != bMaskDWord) { /* if not "double word" write */
                original_value = usb_read32(adapt, regaddr);
                bit_shift = cal_bit_shift(bitmask);
-               data = ((original_value & (~bitmask)) | (data << bit_shift));
+               data = (original_value & (~bitmask)) | (data << bit_shift);
        }
 
        usb_write32(adapt, regaddr, data);
        if (bit_mask != bRFRegOffsetMask) {
                original_value = rf_serial_read(adapt, rf_path, reg_addr);
                bit_shift =  cal_bit_shift(bit_mask);
-               data = ((original_value & (~bit_mask)) | (data << bit_shift));
+               data = (original_value & (~bit_mask)) | (data << bit_shift);
        }
 
        rf_serial_write(adapt, rf_path, reg_addr, data);
 
                if (dm_odm->BbSwingIdxOfdm <= dm_odm->BbSwingIdxOfdmBase) {
                        *direction = 1;
-                       pwr_value = (dm_odm->BbSwingIdxOfdmBase -
-                                    dm_odm->BbSwingIdxOfdm);
+                       pwr_value = dm_odm->BbSwingIdxOfdmBase -
+                                    dm_odm->BbSwingIdxOfdm;
                } else {
                        *direction = 2;
-                       pwr_value = (dm_odm->BbSwingIdxOfdm -
-                                    dm_odm->BbSwingIdxOfdmBase);
+                       pwr_value = dm_odm->BbSwingIdxOfdm -
+                                    dm_odm->BbSwingIdxOfdmBase;
                }
 
        } else if (type == 1) { /* For CCK adjust. */
 
                if (dm_odm->BbSwingIdxCck <= dm_odm->BbSwingIdxCckBase) {
                        *direction = 1;
-                       pwr_value = (dm_odm->BbSwingIdxCckBase -
-                                    dm_odm->BbSwingIdxCck);
+                       pwr_value = dm_odm->BbSwingIdxCckBase -
+                                    dm_odm->BbSwingIdxCck;
                } else {
                        *direction = 2;
-                       pwr_value = (dm_odm->BbSwingIdxCck -
-                                    dm_odm->BbSwingIdxCckBase);
+                       pwr_value = dm_odm->BbSwingIdxCck -
+                                    dm_odm->BbSwingIdxCckBase;
                }
 
        }
 
                        break;
                case 2: /*  Better regulatory */
                                /*  don't increase any power diff */
-                       write_val = ((index < 2) ? powerbase0[rf] : powerbase1[rf]);
+                       write_val = (index < 2) ? powerbase0[rf] : powerbase1[rf];
                        break;
                case 3: /*  Customer defined power diff. */
                                /*  increase power diff defined by customer. */