qcacld: CORE/CLD_TXRX/TXRX cleanfile

Run CORE/CLD_TXRX/TXRX through kernel/scripts/cleanfile to remove
whitespace that is inconsistent with the Linux Kernel coding standard

Change-Id: I337784a1720742ba3826785748ba5a48a9ef7990
CRs-fixed: 619495

29 files changed, 292 insertions, 295 deletions

diff --git a/CORE/CLD_TXRX/TXRX/ol_cfg.c b/CORE/CLD_TXRX/TXRX/ol_cfg.c
index af6beed80f1a..7610ae7925a2 100644
--- a/CORE/CLD_TXRX/TXRX/ol_cfg.c
+++ b/CORE/CLD_TXRX/TXRX/ol_cfg.c
@@ -33,7 +33,7 @@ module_param(vow_config, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 MODULE_PARM_DESC(vow_config, "Do VoW Configuration");
 EXPORT_SYMBOL(vow_config);
 
-/* FIX THIS - 
+/* FIX THIS -
  * For now, all these configuration parameters are hardcoded.
  * Many of these should actually be determined dynamically instead.
  */
diff --git a/CORE/CLD_TXRX/TXRX/ol_ctrl_txrx_api.h b/CORE/CLD_TXRX/TXRX/ol_ctrl_txrx_api.h
index 2b9d4bef15d0..2a07a52caec4 100644
--- a/CORE/CLD_TXRX/TXRX/ol_ctrl_txrx_api.h
+++ b/CORE/CLD_TXRX/TXRX/ol_ctrl_txrx_api.h
@@ -60,7 +60,7 @@ enum ol_rx_err_type {
 #ifdef SUPPORT_HOST_STATISTICS
 /** * @brief Update tx statistics
  * @details
- *  Update tx statistics after tx complete. 
+ *  Update tx statistics after tx complete.
  *
  * @param pdev - ol_pdev_handle instance
  * @param vdev_id - ID of the virtual device that tx frame
@@ -70,7 +70,7 @@ void ol_tx_statistics(ol_pdev_handle pdev,
                       u_int16_t vdev_id,
 					  int had_error);
 #else
-#define ol_tx_statistics(pdev, vdev_id, had_error) 
+#define ol_tx_statistics(pdev, vdev_id, had_error)
 #endif
 
 /** * @brief Count on received packets for invalid peer case
diff --git a/CORE/CLD_TXRX/TXRX/ol_osif_txrx_api.h b/CORE/CLD_TXRX/TXRX/ol_osif_txrx_api.h
index 49e8c26256fc..bee1f1d4b1c6 100644
--- a/CORE/CLD_TXRX/TXRX/ol_osif_txrx_api.h
+++ b/CORE/CLD_TXRX/TXRX/ol_osif_txrx_api.h
@@ -37,10 +37,10 @@
 /**
  * @brief Call tx completion handler to release the buffers
  * @details
- * 
+ *
  * Invoke tx completion handler when the tx credit goes below low water mark.
- * This eliminate the packet drop in the host driver due to send routine not yielding 
- * the cpu when the amount of traffic pumped from the network layer is very high. 
+ * This eliminate the packet drop in the host driver due to send routine not yielding
+ * the cpu when the amount of traffic pumped from the network layer is very high.
  *
  * @param osdev
  */
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx.c b/CORE/CLD_TXRX/TXRX/ol_rx.c
index c45a5c54d7ff..a7a3e20b28d0 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx.c
@@ -711,7 +711,7 @@ ol_rx_filter(
         {
             continue;
         }
-        
+
 
         filter_type = vdev->privacy_filters[i].filter_type;
         if (filter_type == PRIVACY_FILTER_ALWAYS) {
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx.h b/CORE/CLD_TXRX/TXRX/ol_rx.h
index 081778e3d876..5fd239a0ec50 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx.h
+++ b/CORE/CLD_TXRX/TXRX/ol_rx.h
@@ -45,9 +45,9 @@ ol_rx_discard(
     unsigned tid,
     adf_nbuf_t head_msdu);
 
-void 
+void
 ol_rx_frames_free(
-    htt_pdev_handle htt_pdev, 
+    htt_pdev_handle htt_pdev,
     adf_nbuf_t frames);
 
 void
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_defrag.c b/CORE/CLD_TXRX/TXRX/ol_rx_defrag.c
index 71313664db9a..047932e48daf 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_defrag.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_defrag.c
@@ -49,23 +49,23 @@
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#include <ol_htt_api.h>       
-#include <ol_txrx_api.h>       
-#include <ol_txrx_htt_api.h>   
-#include <ol_htt_rx_api.h>     
-#include <ol_txrx_types.h>     
-#include <ol_rx_reorder.h>      
-#include <ol_rx_pn.h>  
-#include <ol_rx_fwd.h> 
+#include <ol_htt_api.h>
+#include <ol_txrx_api.h>
+#include <ol_txrx_htt_api.h>
+#include <ol_htt_rx_api.h>
+#include <ol_txrx_types.h>
+#include <ol_rx_reorder.h>
+#include <ol_rx_pn.h>
+#include <ol_rx_fwd.h>
 #include <ol_rx.h>
-#include <ol_txrx_internal.h>               
+#include <ol_txrx_internal.h>
 #include <ol_ctrl_txrx_api.h>
 #include <ol_txrx_peer_find.h>
-#include <adf_nbuf.h>  
+#include <adf_nbuf.h>
 #include <ieee80211.h>
 #include <adf_os_util.h>
 #include <athdefs.h>
-#include <adf_os_mem.h> 
+#include <adf_os_mem.h>
 #include <ol_rx_defrag.h>
 #include <adf_os_io.h>
 #include <enet.h>
@@ -85,7 +85,7 @@
 
 #define DEFRAG_IEEE80211_QOS_GET_TID(_x) \
     ((_x)->i_qos[0] & IEEE80211_QOS_TID)
-      
+
 const struct ol_rx_defrag_cipher f_ccmp = {
     "AES-CCM",
     IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN + IEEE80211_WEP_EXTIVLEN,
@@ -122,20 +122,20 @@ ol_rx_frag_indication_handler(
 
     if (htt_rx_ind_flush(pdev->htt_pdev, rx_frag_ind_msg) && peer) {
         htt_rx_frag_ind_flush_seq_num_range(
-            pdev->htt_pdev, rx_frag_ind_msg, &seq_num_start, &seq_num_end);  
-        /* 
-         * Assuming flush indication for frags sent from target is seperate 
-         * from normal frames 
+            pdev->htt_pdev, rx_frag_ind_msg, &seq_num_start, &seq_num_end);
+        /*
+         * Assuming flush indication for frags sent from target is seperate
+         * from normal frames
          */
          ol_rx_reorder_flush_frag(htt_pdev, peer, tid, seq_num_start);
     }
-    if (peer) { 
+    if (peer) {
         htt_rx_amsdu_pop(htt_pdev, rx_frag_ind_msg, &head_msdu, &tail_msdu);
         adf_os_assert(head_msdu == tail_msdu);
         rx_mpdu_desc = htt_rx_mpdu_desc_list_next(htt_pdev, rx_frag_ind_msg);
         seq_num = htt_rx_mpdu_desc_seq_num(htt_pdev, rx_mpdu_desc);
         OL_RX_ERR_STATISTICS_1(pdev, peer->vdev, peer, rx_mpdu_desc, OL_RX_ERR_NONE_FRAG);
-        ol_rx_reorder_store_frag(pdev, peer, tid, seq_num, head_msdu);                                  
+        ol_rx_reorder_store_frag(pdev, peer, tid, seq_num, head_msdu);
     } else {
         /* invalid frame - discard it */
         htt_rx_amsdu_pop(htt_pdev, rx_frag_ind_msg, &head_msdu, &tail_msdu);
@@ -186,12 +186,12 @@ ol_rx_reorder_store_frag(
     htt_pdev_handle htt_pdev = pdev->htt_pdev;
 
     seq = seq_num & peer->tids_rx_reorder[tid].win_sz_mask;
-    adf_os_assert(seq == 0); 
+    adf_os_assert(seq == 0);
     rx_reorder_array_elem = &peer->tids_rx_reorder[tid].array[seq];
 
     mac_hdr = (struct ieee80211_frame *) adf_nbuf_data(frag);
     rxseq = adf_os_le16_to_cpu(*(u_int16_t *) mac_hdr->i_seq) >>
-        IEEE80211_SEQ_SEQ_SHIFT; 
+        IEEE80211_SEQ_SEQ_SHIFT;
     fragno = adf_os_le16_to_cpu(*(u_int16_t *) mac_hdr->i_seq) &
         IEEE80211_SEQ_FRAG_MASK;
     more_frag = mac_hdr->i_fc[1] & IEEE80211_FC1_MORE_FRAG;
@@ -211,9 +211,9 @@ ol_rx_reorder_store_frag(
         frxseq = adf_os_le16_to_cpu(*(u_int16_t *) fmac_hdr->i_seq) >>
             IEEE80211_SEQ_SEQ_SHIFT;
         if (rxseq != frxseq ||
-            !DEFRAG_IEEE80211_ADDR_EQ(mac_hdr->i_addr1, fmac_hdr->i_addr1) || 
-            !DEFRAG_IEEE80211_ADDR_EQ(mac_hdr->i_addr2, fmac_hdr->i_addr2)) 
-        {                      
+            !DEFRAG_IEEE80211_ADDR_EQ(mac_hdr->i_addr1, fmac_hdr->i_addr1) ||
+            !DEFRAG_IEEE80211_ADDR_EQ(mac_hdr->i_addr2, fmac_hdr->i_addr2))
+        {
             ol_rx_frames_free(htt_pdev, rx_reorder_array_elem->head);
             rx_reorder_array_elem->head = NULL;
             rx_reorder_array_elem->tail = NULL;
@@ -221,8 +221,8 @@ ol_rx_reorder_store_frag(
                 "\n ol_rx_reorder_store:  %s mismatch \n",
                 (rxseq == frxseq) ? "address" : "seq number");
         }
-    }    
-    ol_rx_fraglist_insert(htt_pdev, &rx_reorder_array_elem->head, 
+    }
+    ol_rx_fraglist_insert(htt_pdev, &rx_reorder_array_elem->head,
         &rx_reorder_array_elem->tail, frag, &all_frag_present);
 
     if (pdev->rx.flags.defrag_timeout_check) {
@@ -246,12 +246,12 @@ ol_rx_reorder_store_frag(
 /*
  * Insert and store fragments
  */
-void 
+void
 ol_rx_fraglist_insert(
     htt_pdev_handle htt_pdev,
-    adf_nbuf_t *head_addr, 
-    adf_nbuf_t *tail_addr, 
-    adf_nbuf_t frag, 
+    adf_nbuf_t *head_addr,
+    adf_nbuf_t *tail_addr,
+    adf_nbuf_t frag,
     u_int8_t *all_frag_present)
 {
     adf_nbuf_t next, prev = NULL, cur = *head_addr;
@@ -269,17 +269,17 @@ ol_rx_fraglist_insert(
         *tail_addr = frag;
         adf_nbuf_set_next(*tail_addr, NULL);
         return;
-    } 
+    }
     /* For efficiency, compare with tail first */
     lmac_hdr = (struct ieee80211_frame *) adf_nbuf_data(*tail_addr);
     lfragno = adf_os_le16_to_cpu(*(u_int16_t *) lmac_hdr->i_seq) &
         IEEE80211_SEQ_FRAG_MASK;
     if (fragno > lfragno) {
         adf_nbuf_set_next(*tail_addr, frag);
-        *tail_addr = frag; 
-        adf_nbuf_set_next(*tail_addr, NULL);      
+        *tail_addr = frag;
+        adf_nbuf_set_next(*tail_addr, NULL);
     } else {
-        do {	
+        do {
             cmac_hdr = (struct ieee80211_frame *) adf_nbuf_data(cur);
             cur_fragno = adf_os_le16_to_cpu(*(u_int16_t *) cmac_hdr->i_seq) &
                 IEEE80211_SEQ_FRAG_MASK;
@@ -295,9 +295,9 @@ ol_rx_fraglist_insert(
             adf_nbuf_set_next(prev, frag);
             adf_nbuf_set_next(frag, cur);
         }
-    }	
+    }
     next = adf_nbuf_next(*head_addr);
-    lmac_hdr = (struct ieee80211_frame *) adf_nbuf_data(*tail_addr);  
+    lmac_hdr = (struct ieee80211_frame *) adf_nbuf_data(*tail_addr);
     last_morefrag = lmac_hdr->i_fc[1] & IEEE80211_FC1_MORE_FRAG;
     if (!last_morefrag) {
         do {
@@ -307,14 +307,14 @@ ol_rx_fraglist_insert(
             count++;
             if (next_fragno != count) {
                 break;
-            }  
-            next = adf_nbuf_next(next);  
+            }
+            next = adf_nbuf_next(next);
         } while (next);
-        
+
         if (!next) {
             *all_frag_present = 1;
             return;
-        }        
+        }
     }
     *all_frag_present = 0;
 }
@@ -394,7 +394,7 @@ ol_rx_defrag_waitlist_flush(
 /*
  * Handling security checking and processing fragments
  */
-void 
+void
 ol_rx_defrag(
     ol_txrx_pdev_handle pdev,
     struct ol_txrx_peer_t *peer,
@@ -402,10 +402,10 @@ ol_rx_defrag(
     adf_nbuf_t frag_list)
 {
     struct ol_txrx_vdev_t *vdev = NULL;
-    adf_nbuf_t tmp_next, msdu, prev = NULL, cur = frag_list; 
+    adf_nbuf_t tmp_next, msdu, prev = NULL, cur = frag_list;
     u_int8_t index, tkip_demic = 0;
-    u_int16_t hdr_space; 
-    void *rx_desc; 
+    u_int16_t hdr_space;
+    void *rx_desc;
     struct ieee80211_frame *wh;
     u_int8_t key[DEFRAG_IEEE80211_KEY_LEN];
 
@@ -417,48 +417,48 @@ ol_rx_defrag(
         ol_rx_deliver(vdev, peer, tid, frag_list);
         return;
     }
-    
+
     while (cur) {
         tmp_next = adf_nbuf_next(cur);
         adf_nbuf_set_next(cur, NULL);
         if (!ol_rx_pn_check_base(vdev, peer, tid, cur)) {
-            /* PN check failed,discard frags */ 
+            /* PN check failed,discard frags */
             if (prev) {
                 adf_nbuf_set_next(prev, NULL);
                 ol_rx_frames_free(htt_pdev, frag_list);
-            }     
-            ol_rx_frames_free(htt_pdev, tmp_next);  
+            }
+            ol_rx_frames_free(htt_pdev, tmp_next);
             TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "ol_rx_defrag: PN Check failed\n");
             return;
         }
         /* remove FCS from each fragment */
         adf_nbuf_trim_tail(cur, DEFRAG_IEEE80211_FCS_LEN);
-        prev = cur; 
-        adf_nbuf_set_next(cur, tmp_next); 
+        prev = cur;
+        adf_nbuf_set_next(cur, tmp_next);
         cur = tmp_next;
     }
     cur = frag_list;
     wh = (struct ieee80211_frame *) adf_nbuf_data(cur);
-    hdr_space = ol_rx_frag_hdrsize(wh);  
+    hdr_space = ol_rx_frag_hdrsize(wh);
     rx_desc = htt_rx_msdu_desc_retrieve(htt_pdev, frag_list);
     adf_os_assert(htt_rx_msdu_has_wlan_mcast_flag(htt_pdev, rx_desc));
     index = htt_rx_msdu_is_wlan_mcast(htt_pdev, rx_desc) ?
         txrx_sec_mcast : txrx_sec_ucast;
-    
+
     switch (peer->security[index].sec_type) {
     case htt_sec_type_tkip:
         tkip_demic = 1;
         /* fall-through to rest of tkip ops */
-    case htt_sec_type_tkip_nomic: 
+    case htt_sec_type_tkip_nomic:
         while (cur) {
             tmp_next = adf_nbuf_next(cur);
-            if (!ol_rx_frag_tkip_decap(cur, hdr_space)) { 
+            if (!ol_rx_frag_tkip_decap(cur, hdr_space)) {
                 /* TKIP decap failed, discard frags */
-                ol_rx_frames_free(htt_pdev, frag_list); 
+                ol_rx_frames_free(htt_pdev, frag_list);
                 TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
                     "\n ol_rx_defrag: TKIP decap failed\n");
                 return;
-            } 
+            }
             cur = tmp_next;
         }
         break;
@@ -475,7 +475,7 @@ ol_rx_defrag(
             }
             if (!ol_rx_frag_ccmp_decap(cur, hdr_space)) {
                 /* CCMP decap failed, discard frags */
-                ol_rx_frames_free(htt_pdev, frag_list); 
+                ol_rx_frames_free(htt_pdev, frag_list);
                 TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
                     "\n ol_rx_defrag: CCMP decap failed\n");
                 return;
@@ -495,8 +495,8 @@ ol_rx_defrag(
 
     if (tkip_demic) {
         adf_os_mem_copy(
-            key, 
-            peer->security[index].michael_key, 
+            key,
+            peer->security[index].michael_key,
             sizeof(peer->security[index].michael_key));
         if (!ol_rx_frag_tkip_demic(key, msdu, hdr_space)) {
             htt_rx_desc_frame_free(htt_pdev, msdu);
@@ -514,8 +514,8 @@ ol_rx_defrag(
         ol_rx_defrag_qos_decap(msdu, hdr_space);
     }
     if (ol_cfg_frame_type(pdev->ctrl_pdev) == wlan_frm_fmt_802_3) {
-       ol_rx_defrag_nwifi_to_8023(msdu);   
-    } 
+       ol_rx_defrag_nwifi_to_8023(msdu);
+    }
     ol_rx_fwd_check(vdev, peer, tid, msdu);
 }
 
@@ -551,19 +551,19 @@ ol_rx_frag_tkip_demic(const u_int8_t *key, adf_nbuf_t msdu, u_int16_t hdrlen)
     u_int8_t mic[IEEE80211_WEP_MICLEN];
     u_int8_t mic0[IEEE80211_WEP_MICLEN];
 
-    pktlen = ol_rx_defrag_len(msdu);   
+    pktlen = ol_rx_defrag_len(msdu);
     status = ol_rx_defrag_mic(
         key, msdu, hdrlen, pktlen - (hdrlen + f_tkip.ic_miclen), mic);
-    if (status != OL_RX_DEFRAG_OK) {  
+    if (status != OL_RX_DEFRAG_OK) {
         return OL_RX_DEFRAG_ERR;
     }
     ol_rx_defrag_copydata(
         msdu, pktlen - f_tkip.ic_miclen, f_tkip.ic_miclen, (caddr_t) mic0);
     if (adf_os_mem_cmp(mic, mic0, f_tkip.ic_miclen)) {
         return OL_RX_DEFRAG_ERR;
-    }    
+    }
     adf_nbuf_trim_tail(msdu, f_tkip.ic_miclen);
-  
+
     return OL_RX_DEFRAG_OK;
 }
 
@@ -572,7 +572,7 @@ ol_rx_frag_tkip_demic(const u_int8_t *key, adf_nbuf_t msdu, u_int16_t hdrlen)
  */
 int
 ol_rx_frag_ccmp_decap(
-    adf_nbuf_t nbuf, 
+    adf_nbuf_t nbuf,
     u_int16_t hdrlen)
 {
     u_int8_t *ivp, *origHdr;
@@ -593,7 +593,7 @@ ol_rx_frag_ccmp_decap(
  */
 int
 ol_rx_frag_ccmp_demic(
-    adf_nbuf_t wbuf, 
+    adf_nbuf_t wbuf,
     u_int16_t hdrlen)
 {
     u_int8_t *ivp, *origHdr;
@@ -603,7 +603,7 @@ ol_rx_frag_ccmp_demic(
     if (!(ivp[IEEE80211_WEP_IVLEN] & IEEE80211_WEP_EXTIV)) {
         return OL_RX_DEFRAG_ERR;
     }
-    adf_nbuf_trim_tail(wbuf, f_ccmp.ic_trailer);  
+    adf_nbuf_trim_tail(wbuf, f_ccmp.ic_trailer);
 
     return OL_RX_DEFRAG_OK;
 }
@@ -613,7 +613,7 @@ ol_rx_frag_ccmp_demic(
  */
 void
 ol_rx_defrag_michdr(
-    const struct ieee80211_frame *wh0, 
+    const struct ieee80211_frame *wh0,
     u_int8_t hdr[])
 {
     const struct ieee80211_frame_addr4 *wh =
@@ -639,7 +639,7 @@ ol_rx_defrag_michdr(
     }
     /*
      * Bit 7 is IEEE80211_FC0_SUBTYPE_QOS for data frame, but
-     * it could also be set for deauth, disassoc, action, etc. for 
+     * it could also be set for deauth, disassoc, action, etc. for
      * a mgt type frame. It comes into picture for MFP.
      */
     if (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
@@ -658,7 +658,7 @@ ol_rx_defrag_michdr(
 int
 ol_rx_defrag_mic(
     const u_int8_t *key,
-    adf_nbuf_t wbuf, 
+    adf_nbuf_t wbuf,
     u_int16_t off,
     u_int16_t data_len,
     u_int8_t mic[])
@@ -693,7 +693,7 @@ ol_rx_defrag_mic(
         while (space >= sizeof(u_int32_t)) {
             l ^= get_le32(data);
             michael_block(l, r);
-            data += sizeof(u_int32_t); 
+            data += sizeof(u_int32_t);
             space -= sizeof(u_int32_t);
             data_len -= sizeof(u_int32_t);
         }
@@ -701,7 +701,7 @@ ol_rx_defrag_mic(
             break;
         }
         wbuf = adf_nbuf_next(wbuf);
-        if (wbuf == NULL) {    
+        if (wbuf == NULL) {
             return OL_RX_DEFRAG_ERR;
         }
         if (space != 0) {
@@ -777,7 +777,7 @@ ol_rx_frag_hdrsize(const void *data)
 
     if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) {
         size += IEEE80211_ADDR_LEN;
-    }   
+    }
     if (DEFRAG_IEEE80211_QOS_HAS_SEQ(wh)) {
         size += sizeof(u_int16_t);
         if (wh->i_fc[1] & IEEE80211_FC1_ORDER) {
@@ -790,10 +790,10 @@ ol_rx_frag_hdrsize(const void *data)
 /*
  * Recombine and decap fragments
  */
-adf_nbuf_t 
+adf_nbuf_t
 ol_rx_defrag_decap_recombine(
-    htt_pdev_handle htt_pdev, 
-    adf_nbuf_t frag_list, 
+    htt_pdev_handle htt_pdev,
+    adf_nbuf_t frag_list,
     u_int16_t hdrsize)
 {
     adf_nbuf_t tmp;
@@ -810,16 +810,16 @@ ol_rx_defrag_decap_recombine(
         adf_nbuf_pull_head(msdu, hdrsize);
         if (!ol_rx_defrag_concat(rx_nbuf, msdu)) {
             ol_rx_frames_free(htt_pdev, tmp);
-            htt_rx_desc_frame_free(htt_pdev, rx_nbuf); 
+            htt_rx_desc_frame_free(htt_pdev, rx_nbuf);
             adf_nbuf_free(msdu); /* msdu rx desc already freed above */
             return NULL;
         }
-        msdu = tmp;     
+        msdu = tmp;
     }
-    wh = (struct ieee80211_frame *) adf_nbuf_data(rx_nbuf);  
-    wh->i_fc[1] &= ~IEEE80211_FC1_MORE_FRAG; 
-    *(u_int16_t *) wh->i_seq &= ~IEEE80211_SEQ_FRAG_MASK; 
-   
+    wh = (struct ieee80211_frame *) adf_nbuf_data(rx_nbuf);
+    wh->i_fc[1] &= ~IEEE80211_FC1_MORE_FRAG;
+    *(u_int16_t *) wh->i_seq &= ~IEEE80211_SEQ_FRAG_MASK;
+
     return rx_nbuf;
 }
 
@@ -839,11 +839,11 @@ ol_rx_defrag_nwifi_to_8023(adf_nbuf_t msdu)
     adf_os_mem_copy(&llchdr, ((a_uint8_t *) adf_nbuf_data(msdu)) + hdrsize,
         sizeof(struct llc_snap_hdr_t));
 
-    /* 
-     * Now move the data pointer to the beginning of the mac header : 
-     * new-header = old-hdr + (wifhdrsize + llchdrsize - ethhdrsize) 
+    /*
+     * Now move the data pointer to the beginning of the mac header :
+     * new-header = old-hdr + (wifhdrsize + llchdrsize - ethhdrsize)
      */
-    adf_nbuf_pull_head(msdu, (hdrsize + 
+    adf_nbuf_pull_head(msdu, (hdrsize +
         sizeof(struct llc_snap_hdr_t) - sizeof(struct ethernet_hdr_t)));
     eth_hdr = (struct ethernet_hdr_t *)(adf_nbuf_data(msdu));
     switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
@@ -868,10 +868,10 @@ ol_rx_defrag_nwifi_to_8023(adf_nbuf_t msdu)
 
 /*
  * Handling QOS for defragmentation
- */       
+ */
 void
 ol_rx_defrag_qos_decap(
-    adf_nbuf_t nbuf, 
+    adf_nbuf_t nbuf,
     u_int16_t hdrlen)
 {
     struct ieee80211_frame *wh;
@@ -890,14 +890,14 @@ ol_rx_defrag_qos_decap(
         adf_os_mem_move((u_int8_t *) wh + qoslen, wh, hdrlen);
         wh = (struct ieee80211_frame *) adf_nbuf_pull_head(nbuf, qoslen);
         /* clear QoS bit */
-        /* 
+        /*
          * KW# 6154 'adf_nbuf_pull_head' in turn calls __adf_nbuf_pull_head, which returns NULL if there is not sufficient data to pull.
          *  It's guaranteed that adf_nbuf_pull_head will succeed rather than returning NULL, since the entire rx frame is already present in the rx buffer.
          *  However, to make it obvious to static analyzers that this code is safe, add an explicit check that adf_nbuf_pull_head returns a non-NULL value.
          *  Since this part of the code is not performance-critical, adding this explicit check is okay.
-         */	
+         */
         if (wh) {
             wh->i_fc[0] &= ~IEEE80211_FC0_SUBTYPE_QOS;
-        } 
+        }
     }
 }
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_defrag.h b/CORE/CLD_TXRX/TXRX/ol_rx_defrag.h
index ba9ae1567cbd..2a99b32db752 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_defrag.h
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_defrag.h
@@ -28,7 +28,7 @@
 #ifndef _OL_RX_DEFRAG_H_
 #define _OL_RX_DEFRAG_H_
 
-#include <adf_nbuf.h> 
+#include <adf_nbuf.h>
 #include <ieee80211_common.h>
 #include <adf_os_util.h>
 #include <adf_os_types.h>
@@ -42,12 +42,12 @@
 #define DEFRAG_IEEE80211_FCS_LEN     4
 
 struct ol_rx_defrag_cipher {
-    const char *ic_name;				
-    u_int16_t	ic_header;		
+    const char *ic_name;
+    u_int16_t	ic_header;
     u_int8_t	ic_trailer;
-    u_int8_t    ic_miclen;		
-}; 
-       
+    u_int8_t    ic_miclen;
+};
+
 enum {
     OL_RX_DEFRAG_ERR,
     OL_RX_DEFRAG_OK,
@@ -60,12 +60,12 @@ enum {
 #define ol_rx_defrag_len(buf) \
     adf_nbuf_len(buf)
 
-void 
+void
 ol_rx_fraglist_insert(
     htt_pdev_handle htt_pdev,
-    adf_nbuf_t *head_addr, 
-    adf_nbuf_t *tail_addr, 
-    adf_nbuf_t frag, 
+    adf_nbuf_t *head_addr,
+    adf_nbuf_t *tail_addr,
+    adf_nbuf_t frag,
     u_int8_t *all_frag_present);
 
 void
@@ -82,7 +82,7 @@ void
 ol_rx_defrag_waitlist_flush(
     struct ol_txrx_pdev_t *pdev);
 
-void 
+void
 ol_rx_defrag(
     ol_txrx_pdev_handle pdev,
     struct ol_txrx_peer_t *peer,
@@ -91,7 +91,7 @@ ol_rx_defrag(
 
 int
 ol_rx_frag_tkip_decap(
-    adf_nbuf_t msdu, 
+    adf_nbuf_t msdu,
     u_int16_t hdrlen);
 
 void
@@ -99,23 +99,23 @@ ol_rx_defrag_nwifi_to_8023(adf_nbuf_t msdu);
 
 void
 ol_rx_defrag_qos_decap(
-    adf_nbuf_t nbuf, 
+    adf_nbuf_t nbuf,
     u_int16_t hdrlen);
 
 int
 ol_rx_frag_tkip_demic(
-    const u_int8_t *key, 
-    adf_nbuf_t msdu, 
+    const u_int8_t *key,
+    adf_nbuf_t msdu,
     u_int16_t hdrlen);
 
 int
 ol_rx_frag_ccmp_decap(
-    adf_nbuf_t nbuf, 
+    adf_nbuf_t nbuf,
     u_int16_t hdrlen);
 
 int
 ol_rx_frag_ccmp_demic(
-    adf_nbuf_t wbuf, 
+    adf_nbuf_t wbuf,
     u_int16_t hdrlen);
 
 u_int16_t
@@ -123,7 +123,7 @@ ol_rx_frag_hdrsize(const void *data);
 
 void
 ol_rx_defrag_michdr(
-    const struct ieee80211_frame *wh0, 
+    const struct ieee80211_frame *wh0,
     u_int8_t hdr[]);
 
 void
@@ -134,16 +134,16 @@ ol_rx_reorder_store_frag(
     u_int16_t seq_num,
     adf_nbuf_t frag);
 
-adf_nbuf_t 
+adf_nbuf_t
 ol_rx_defrag_decap_recombine(
-    htt_pdev_handle htt_pdev, 
-    adf_nbuf_t frag_list, 
+    htt_pdev_handle htt_pdev,
+    adf_nbuf_t frag_list,
     u_int16_t hdrsize);
 
 int
 ol_rx_defrag_mic(
     const u_int8_t *key,
-    adf_nbuf_t wbuf, 
+    adf_nbuf_t wbuf,
     u_int16_t off,
     u_int16_t data_len,
     u_int8_t mic[]);
@@ -157,8 +157,8 @@ ol_rx_reorder_flush_frag(
 
 static inline void
 xor_block(
-    u_int8_t *b, 
-    const u_int8_t *a, 
+    u_int8_t *b,
+    const u_int8_t *a,
     adf_os_size_t len)
 {
     adf_os_size_t i;
@@ -168,47 +168,47 @@ xor_block(
     }
 }
 
-static inline u_int32_t 
+static inline u_int32_t
 rotl(
-    u_int32_t val, 
+    u_int32_t val,
     int bits)
 {
     return (val << bits) | (val >> (32 - bits));
 }
 
-static inline u_int32_t 
+static inline u_int32_t
 rotr(
-    u_int32_t val, 
+    u_int32_t val,
     int bits)
 {
     return (val >> bits) | (val << (32 - bits));
 }
 
-static inline u_int32_t 
+static inline u_int32_t
 xswap(u_int32_t val)
 {
     return ((val & 0x00ff00ff) << 8) | ((val & 0xff00ff00) >> 8);
 }
 
-static inline u_int32_t 
+static inline u_int32_t
 get_le32_split(
-    u_int8_t b0, 
-    u_int8_t b1, 
-    u_int8_t b2, 
+    u_int8_t b0,
+    u_int8_t b1,
+    u_int8_t b2,
     u_int8_t b3)
 {
     return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
 }
 
-static inline u_int32_t 
+static inline u_int32_t
 get_le32(const u_int8_t *p)
 {
     return get_le32_split(p[0], p[1], p[2], p[3]);
 }
 
-static inline void 
+static inline void
 put_le32(
-    u_int8_t *p, 
+    u_int8_t *p,
     u_int32_t v)
 {
     p[0] = (v) & 0xff;
@@ -219,7 +219,7 @@ put_le32(
 
 static inline u_int8_t
 ol_rx_defrag_concat(
-    adf_nbuf_t dst, 
+    adf_nbuf_t dst,
     adf_nbuf_t src)
 {
     /*
@@ -230,7 +230,7 @@ ol_rx_defrag_concat(
      * contains the rx desc.)
      */
     if (adf_nbuf_cat(dst, src)) {
-        return OL_RX_DEFRAG_ERR; 
+        return OL_RX_DEFRAG_ERR;
     }
 
     return OL_RX_DEFRAG_OK;
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c b/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c
index 12916dd761f8..c77a7ea5fd1a 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c
@@ -65,7 +65,7 @@ ol_ap_fwd_check(struct ol_txrx_vdev_t *vdev, adf_nbuf_t msdu)
     type    = mac_header->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
     subtype = mac_header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
     tods    = mac_header->i_fc[1] & IEEE80211_FC1_DIR_TODS;
-    fromds  = mac_header->i_fc[1] & IEEE80211_FC1_DIR_FROMDS; 
+    fromds  = mac_header->i_fc[1] & IEEE80211_FC1_DIR_FROMDS;
 
 	/*
      * Make sure no QOS or any other non-data subtype
@@ -74,7 +74,7 @@ ol_ap_fwd_check(struct ol_txrx_vdev_t *vdev, adf_nbuf_t msdu)
      * These packets should come up through the normal rx path and not forwarded.
      */
     if (type != IEEE80211_FC0_TYPE_DATA ||
-        subtype != 0x0 || 
+        subtype != 0x0 ||
         ((tods != 1) || (fromds != 0)) ||
         (adf_os_mem_cmp(
             mac_header->i_addr3, vdev->mac_addr.raw, IEEE80211_ADDR_LEN) == 0))
@@ -119,7 +119,7 @@ void
 ol_rx_fwd_to_tx(struct ol_txrx_vdev_t *vdev, adf_nbuf_t msdu)
 {
     struct ol_txrx_pdev_t *pdev = vdev->pdev;
-    
+
     if (pdev->frame_format == wlan_frm_fmt_native_wifi)
     {
         ol_ap_fwd_check(vdev, msdu);
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_pn.c b/CORE/CLD_TXRX/TXRX/ol_rx_pn.c
index 42c2b60cd96b..e4eb9cdc674a 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_pn.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_pn.c
@@ -37,14 +37,14 @@
 #include <ol_rx.h>            /* ol_rx_deliver */
 
 /* add the MSDUs from this MPDU to the list of good frames */
-#define ADD_MPDU_TO_LIST(head, tail, mpdu, mpdu_tail) do { 	\
+#define ADD_MPDU_TO_LIST(head, tail, mpdu, mpdu_tail) do {	\
         if (!head) {                                        \
-            head = mpdu;                                	\
+            head = mpdu;					\
         } else {                                            \
-            adf_nbuf_set_next(tail, mpdu);    				\
+            adf_nbuf_set_next(tail, mpdu);				\
         }                                                   \
-        tail = mpdu_tail;                               	\
-    } while(0);                                          
+        tail = mpdu_tail;					\
+    } while(0);
 
 int ol_rx_pn_cmp24(
     union htt_rx_pn_t *new_pn,
@@ -343,6 +343,6 @@ ol_rx_pn_trace_display(ol_txrx_pdev_handle pdev, int just_once)
         cnt++;
         i++;
         i &= pdev->rx_pn_trace.mask;
-    } while (i != end); 
+    } while (i != end);
 }
 #endif /* ENABLE_RX_PN_TRACE */
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_reorder.c b/CORE/CLD_TXRX/TXRX/ol_rx_reorder.c
index e2630af4f49d..a54ff598c1af 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_reorder.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_reorder.c
@@ -131,7 +131,7 @@ OL_RX_REORDER_IDX_START_SELF_SELECT(
             tail_msdu = rx_reorder_array_elem->tail; \
         } \
     } while (0)
-    
+
 #else
 
 /* reorder array elements are known to be non-NULL */
@@ -186,7 +186,7 @@ ol_rx_reorder_seq_num_check(
 
     if (seq_num_delta > (IEEE80211_SEQ_MAX >> 1)) {
          return htt_rx_status_err_replay; /* or maybe htt_rx_status_err_dup */
-    } 
+    }
     return htt_rx_status_ok;
 }
 
@@ -337,7 +337,7 @@ ol_rx_reorder_flush(
     idx_end   &= win_sz_mask;
 
     do {
-        rx_reorder_array_elem = 
+        rx_reorder_array_elem =
             &peer->tids_rx_reorder[tid].array[idx_start];
         idx_start = (idx_start + 1);
         OL_RX_REORDER_IDX_WRAP(idx_start, win_sz, win_sz_mask);
@@ -561,13 +561,13 @@ ol_rx_flush_handler(
         vdev = peer->vdev;
     } else {
         return;
-    } 
+    }
 
     OL_RX_REORDER_TIMEOUT_MUTEX_LOCK(pdev);
 
     idx = idx_start & peer->tids_rx_reorder[tid].win_sz_mask;
     rx_reorder_array_elem = &peer->tids_rx_reorder[tid].array[idx];
-    if (rx_reorder_array_elem->head) {    
+    if (rx_reorder_array_elem->head) {
         rx_desc =
             htt_rx_msdu_desc_retrieve(htt_pdev, rx_reorder_array_elem->head);
         if (htt_rx_msdu_is_frag(htt_pdev, rx_desc)) {
@@ -575,7 +575,7 @@ ol_rx_flush_handler(
             /*
              * Assuming flush message sent seperately for frags
              * and for normal frames
-             */ 
+             */
             OL_RX_REORDER_TIMEOUT_MUTEX_UNLOCK(pdev);
             return;
         }
@@ -680,7 +680,7 @@ ol_rx_pn_ind_handler(
             }
             rx_reorder_array_elem->head = NULL;
             rx_reorder_array_elem->tail = NULL;
-        } 
+        }
         seq_num = (seq_num + 1) & win_sz_mask;
     } while (seq_num != seq_num_end);
 
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_reorder_timeout.c b/CORE/CLD_TXRX/TXRX/ol_rx_reorder_timeout.c
index 8ec4200ec1af..ea7e6ecc310e 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_reorder_timeout.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_reorder_timeout.c
@@ -187,7 +187,7 @@ ol_rx_reorder_timeout_init(struct ol_txrx_pdev_t *pdev)
         rx_reorder_timeout_ac = &pdev->rx.reorder_timeout.access_cats[i];
         /* init the per-AC timers */
         adf_os_timer_init(
-            pdev->osdev, &rx_reorder_timeout_ac->timer, 
+            pdev->osdev, &rx_reorder_timeout_ac->timer,
             ol_rx_reorder_timeout, rx_reorder_timeout_ac);
         /* init the virtual timer list */
         TAILQ_INIT(&rx_reorder_timeout_ac->virtual_timer_list);
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx.c b/CORE/CLD_TXRX/TXRX/ol_tx.c
index 72d40c2b1922..2dc7dc6a4fe4 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx.c
@@ -56,8 +56,8 @@
 #define ol_tx_prepare_ll(tx_desc, vdev, msdu, msdu_info) \
     do {                                                                      \
         struct ol_txrx_pdev_t *pdev = vdev->pdev;                             \
-        /* 
-         * The TXRX module doesn't accept tx frames unless the target has 
+        /*
+         * The TXRX module doesn't accept tx frames unless the target has
          * enough descriptors for them.
          * For LL, the TXRX descriptor pool is sized to match the target's
          * descriptor pool.  Hence, if the descriptor allocation in TXRX
@@ -81,7 +81,7 @@ ol_tx_ll(ol_txrx_vdev_handle vdev, adf_nbuf_t msdu_list)
 
     msdu_info.htt.info.l2_hdr_type = vdev->pdev->htt_pkt_type;
     /*
-     * The msdu_list variable could be used instead of the msdu var, 
+     * The msdu_list variable could be used instead of the msdu var,
      * but just to clarify which operations are done on a single MSDU
      * vs. a list of MSDUs, use a distinct variable for single MSDUs
      * within the list.
@@ -382,7 +382,7 @@ ol_tx_non_std_ll(
     msdu_info.htt.info.l2_hdr_type = vdev->pdev->htt_pkt_type;
 
     /*
-     * The msdu_list variable could be used instead of the msdu var, 
+     * The msdu_list variable could be used instead of the msdu var,
      * but just to clarify which operations are done on a single MSDU
      * vs. a list of MSDUs, use a distinct variable for single MSDUs
      * within the list.
@@ -843,7 +843,7 @@ ol_txrx_mgmt_send(
     TXRX_STATS_MSDU_INCR(pdev, tx.mgmt, tx_mgmt_frm);
     TXRX_ASSERT1(type < OL_TXRX_MGMT_NUM_TYPES);
     tx_desc->pkt_type = type + OL_TXRX_MGMT_TYPE_BASE;
-    
+
     if (pdev->cfg.is_high_latency) {
 	struct ol_tx_frms_queue_t *txq;
         /*
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx.h b/CORE/CLD_TXRX/TXRX/ol_tx.h
index f76c38c4519c..e53439f49c4e 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx.h
+++ b/CORE/CLD_TXRX/TXRX/ol_tx.h
@@ -67,7 +67,7 @@ ol_tx_non_std_hl(
     enum ol_tx_spec tx_spec,
     adf_nbuf_t msdu_list);
 
-adf_nbuf_t 
+adf_nbuf_t
 ol_tx_reinject(struct ol_txrx_vdev_t *vdev, adf_nbuf_t msdu, u_int16_t peer_id);
 
 void
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_classify.c b/CORE/CLD_TXRX/TXRX/ol_tx_classify.c
index 28712d47b38d..10bc31ef6db4 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_classify.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_classify.c
@@ -152,7 +152,7 @@ ol_tx_tid_by_ether_type(
         typeorlength = (ptr[0] << 8) | ptr[1];
         l3_data_ptr += ETHERTYPE_VLAN_LEN;
     }
-    
+
     if (!IS_ETHERTYPE(typeorlength)) { // 802.3 header
         struct llc_snap_hdr_t *llc_hdr = (struct llc_snap_hdr_t *) l3_data_ptr;
         typeorlength = (llc_hdr->ethertype[0] << 8) | llc_hdr->ethertype[1];
@@ -160,7 +160,7 @@ ol_tx_tid_by_ether_type(
     }
     tx_msdu_info->htt.info.l3_hdr_offset = (A_UINT8)(l3_data_ptr - datap);
     tx_msdu_info->htt.info.ethertype = typeorlength;
-    
+
     /* IP packet, do packet inspection for TID */
     if (typeorlength == ETHERTYPE_IPV4) {
         tid = ol_tx_tid_by_ipv4(l3_data_ptr);
@@ -226,8 +226,8 @@ ol_tx_tid_by_raw_type(
 
 static A_UINT8
 ol_tx_tid(
-    struct ol_txrx_pdev_t *pdev, 
-    adf_nbuf_t tx_nbuf, 
+    struct ol_txrx_pdev_t *pdev,
+    adf_nbuf_t tx_nbuf,
     struct ol_txrx_msdu_info_t *tx_msdu_info)
 {
     A_UINT8 *datap = adf_nbuf_data(tx_nbuf);
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_classify.h b/CORE/CLD_TXRX/TXRX/ol_tx_classify.h
index 63fedc21c8e5..bb0b740a705f 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_classify.h
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_classify.h
@@ -75,15 +75,15 @@ ol_tx_dest_addr_find(
  */
 struct ol_tx_frms_queue_t *
 ol_tx_classify(
-    struct ol_txrx_vdev_t *vdev, 
-    struct ol_tx_desc_t *tx_desc, 
+    struct ol_txrx_vdev_t *vdev,
+    struct ol_tx_desc_t *tx_desc,
     adf_nbuf_t netbuf,
     struct ol_txrx_msdu_info_t *tx_msdu_info);
 
 struct ol_tx_frms_queue_t *
 ol_tx_classify_mgmt(
-    struct ol_txrx_vdev_t *vdev, 
-    struct ol_tx_desc_t *tx_desc, 
+    struct ol_txrx_vdev_t *vdev,
+    struct ol_tx_desc_t *tx_desc,
     adf_nbuf_t netbuf,
     struct ol_txrx_msdu_info_t *tx_msdu_info);
 
@@ -96,4 +96,3 @@ ol_tx_classify_mgmt(
 
 
 #endif /* _OL_TX_CLASSIFY__H_ */
-
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_desc.c b/CORE/CLD_TXRX/TXRX/ol_tx_desc.c
index e2a65256936c..2ca6b8bd5339 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_desc.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_desc.c
@@ -282,11 +282,11 @@ void ol_tx_desc_frame_free_nonstd(
 {
     int mgmt_type;
     ol_txrx_mgmt_tx_cb ota_ack_cb;
-	
+
     adf_os_atomic_init(&tx_desc->ref_cnt); /* clear the ref cnt */
 #ifdef QCA_SUPPORT_SW_TXRX_ENCAP
     OL_TX_RESTORE_HDR(tx_desc, (tx_desc->netbuf)); /* restore original hdr offset */
-#endif 
+#endif
     if (tx_desc->pkt_type == ol_tx_frm_no_free) {
         /* free the tx desc but don't unmap or free the frame */
         if (pdev->tx_data_callback.func) {
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_desc.h b/CORE/CLD_TXRX/TXRX/ol_tx_desc.h
index 542479700bd6..a31095464c9d 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_desc.h
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_desc.h
@@ -104,7 +104,7 @@ ol_tx_desc_find(struct ol_txrx_pdev_t *pdev, u_int16_t tx_desc_id);
  *  Irregular tx frames like TSO or managment frames that require
  *  special handling are processed by the ol_tx_desc_frame_free_nonstd
  *  function rather than this function.
- *  
+ *
  * @param pdev - the data physical device that sent the data
  * @param tx_descs - a list of SW tx descriptors for the tx frames
  * @param had_error - boolean indication of whether the transmission failed.
@@ -126,7 +126,7 @@ void ol_tx_desc_frame_list_free(
  *  After performing any special steps based on tx frame type, free the
  *  tx descriptor, i.e. return it to the freelist, and unmap and
  *  free the netbuf referenced by the tx descriptor.
- *  
+ *
  * @param pdev - the data physical device that sent the data
  * @param tx_desc - the SW tx descriptor for the tx frame that was sent
  * @param had_error - boolean indication of whether the transmission failed.
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_queue.h b/CORE/CLD_TXRX/TXRX/ol_tx_queue.h
index a114cba50f27..5d80f7f14499 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_queue.h
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_queue.h
@@ -50,9 +50,9 @@
  */
 void
 ol_tx_enqueue(
-    struct ol_txrx_pdev_t *pdev, 
-    struct ol_tx_frms_queue_t *txq, 
-    struct ol_tx_desc_t *tx_desc, 
+    struct ol_txrx_pdev_t *pdev,
+    struct ol_tx_frms_queue_t *txq,
+    struct ol_tx_desc_t *tx_desc,
     struct ol_txrx_msdu_info_t *tx_msdu_info);
 
 /**
@@ -77,9 +77,9 @@ ol_tx_enqueue(
 */
 u_int16_t
 ol_tx_dequeue(
-	struct ol_txrx_pdev_t *pdev, 
-	struct ol_tx_frms_queue_t *txq, 
-	ol_tx_desc_list *head, 
+	struct ol_txrx_pdev_t *pdev,
+	struct ol_tx_frms_queue_t *txq,
+	ol_tx_desc_list *head,
 	u_int16_t num_frames,
     u_int32_t *credit,
     int *bytes);
@@ -98,7 +98,7 @@ ol_tx_dequeue(
  */
 void
 ol_tx_queue_free(
-    struct ol_txrx_pdev_t *pdev, 
+    struct ol_txrx_pdev_t *pdev,
     struct ol_tx_frms_queue_t *txq,
     int tid);
 
@@ -178,4 +178,3 @@ void ol_tx_throttle_init(struct ol_txrx_pdev_t *pdev);
 #define ol_tx_throttle_init(pdev) /*no op*/
 #endif
 #endif /* _OL_TX_QUEUE__H_ */
-
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_sched.c b/CORE/CLD_TXRX/TXRX/ol_tx_sched.c
index 95a84726df5f..605fd51d0818 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_sched.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_sched.c
@@ -35,7 +35,7 @@
 #include <ol_tx_desc.h>       /* ol_tx_desc */
 #include <ol_tx_send.h>       /* ol_tx_send */
 #include <ol_tx_sched.h>      /* OL_TX_SCHED, etc. */
-#include <ol_tx_queue.h>      
+#include <ol_tx_queue.h>
 #include <ol_txrx.h>
 #include <adf_os_types.h>     /* a_bool_t */
 
@@ -185,7 +185,7 @@ struct ol_tx_sched_rr_t {
 /*--- functions ---*/
 
 /*
- * The scheduler sync spinlock has been acquired outside this function, 
+ * The scheduler sync spinlock has been acquired outside this function,
  * so there is no need to worry about mutex within this function.
  */
 static int
@@ -717,7 +717,7 @@ ol_tx_sched_wrr_adv_credit_sanity_check(struct ol_txrx_pdev_t *pdev, u_int32_t c
 }
 
 /*
- * The scheduler sync spinlock has been acquired outside this function, 
+ * The scheduler sync spinlock has been acquired outside this function,
  * so there is no need to worry about mutex within this function.
  */
 static int
@@ -757,7 +757,7 @@ ol_tx_sched_select_batch_wrr_adv(
         if (!category->state.active) {
             /* move on to the next category */
             index++;
-            continue;        
+            continue;
         }
         if (++category->state.wrr_count < category->specs.wrr_skip_weight) {
             /* skip this cateogry (move it to the back) */
@@ -973,7 +973,7 @@ ol_tx_sched_init_wrr_adv(
         //scheduler->categories[i].state.bytes = 0;
         TAILQ_INIT(&scheduler->categories[i].state.head);
         /* init categories to not be skipped before their initial selection */
-        scheduler->categories[i].state.wrr_count = 
+        scheduler->categories[i].state.wrr_count =
             scheduler->categories[i].specs.wrr_skip_weight - 1;
     }
 
@@ -1095,7 +1095,7 @@ ol_tx_sched_discard_select(
 /*--- scheduler framework ---------------------------------------------------*/
 
 /*
- * The scheduler mutex spinlock has been acquired outside this function, 
+ * The scheduler mutex spinlock has been acquired outside this function,
  * so there is need to take locks inside this function.
  */
 void
@@ -1118,7 +1118,7 @@ ol_tx_sched_notify(
     case OL_TX_DELETE_QUEUE:
         tid = ctx->info.ext_tid;
         if (txq->flag == ol_tx_queue_active) {
-            ol_tx_sched_txq_deactivate(pdev, txq, tid); 
+            ol_tx_sched_txq_deactivate(pdev, txq, tid);
         }
         break;
     case OL_TX_PAUSE_QUEUE:
@@ -1157,7 +1157,7 @@ ol_tx_sched_dispatch(
 {
     adf_nbuf_t msdu, prev = NULL, head_msdu = NULL;
     struct ol_tx_desc_t *tx_desc;
-    
+
     u_int16_t *msdu_id_storage;
     u_int16_t msdu_id;
     int num_msdus = 0;
@@ -1244,7 +1244,7 @@ ol_tx_sched(struct ol_txrx_pdev_t *pdev)
 {
     struct ol_tx_sched_ctx sctx;
     u_int32_t credit;
-    
+
     TX_SCHED_DEBUG_PRINT("Enter %s\n", __func__);
     adf_os_spin_lock(&pdev->tx_queue_spinlock);
     if (pdev->tx_sched.tx_sched_status != ol_tx_scheduler_idle) {
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_sched.h b/CORE/CLD_TXRX/TXRX/ol_tx_sched.h
index 4034f85398f8..b01acf9965c8 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_sched.h
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_sched.h
@@ -117,4 +117,3 @@ ol_tx_sched_detach(struct ol_txrx_pdev_t *pdev);
 #endif
 
 #endif /* _OL_TX_SCHED__H_ */
-
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_send.c b/CORE/CLD_TXRX/TXRX/ol_tx_send.c
index 21a7fc28666a..0c8e6f66cabd 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_send.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_send.c
@@ -56,7 +56,7 @@
 #include <ol_tx_sched.h>
 #ifdef QCA_SUPPORT_SW_TXRX_ENCAP
 #include <ol_txrx_encap.h>    /* OL_TX_RESTORE_HDR, etc*/
-#endif 
+#endif
 
 #ifdef TX_CREDIT_RECLAIM_SUPPORT
 
@@ -380,7 +380,7 @@ ol_tx_delay_compute(
 
 #endif /*!ATH_11AC_TXCOMPACT*/
 
-#ifdef QCA_TX_SINGLE_COMPLETIONS 
+#ifdef QCA_TX_SINGLE_COMPLETIONS
     #ifdef QCA_TX_STD_PATH_ONLY
         #define ol_tx_msdu_complete(_pdev, _tx_desc, _tx_descs, _netbuf, _lcl_freelist,         \
                                         _tx_desc_last, _status)                                 \
@@ -495,7 +495,7 @@ ol_tx_completion_handler(
     if (lcl_freelist) {
         adf_os_spin_lock(&pdev->tx_mutex);
         tx_desc_last->next = pdev->tx_desc.freelist;
-        pdev->tx_desc.freelist = lcl_freelist; 
+        pdev->tx_desc.freelist = lcl_freelist;
         adf_os_spin_unlock(&pdev->tx_mutex);
         pdev->tx_desc.num_free += (u_int16_t) num_msdus;
     } else {
@@ -601,12 +601,12 @@ ol_tx_inspect_handler(
 
         /* vdev now points to the vdev for this descriptor. */
 
-#ifndef ATH_11AC_TXCOMPACT        
+#ifndef ATH_11AC_TXCOMPACT
         /* save this multicast packet to local free list */
-        if (adf_os_atomic_dec_and_test(&tx_desc->ref_cnt)) 
-#endif            
+        if (adf_os_atomic_dec_and_test(&tx_desc->ref_cnt))
+#endif
         {
-            /* for this function only, force htt status to be "htt_tx_status_ok" 
+            /* for this function only, force htt status to be "htt_tx_status_ok"
              * for graceful freeing of this multicast frame
              */
             ol_tx_msdu_complete(pdev, tx_desc, tx_descs, netbuf, lcl_freelist,
@@ -617,7 +617,7 @@ ol_tx_inspect_handler(
     if (lcl_freelist) {
         adf_os_spin_lock(&pdev->tx_mutex);
         tx_desc_last->next = pdev->tx_desc.freelist;
-        pdev->tx_desc.freelist = lcl_freelist; 
+        pdev->tx_desc.freelist = lcl_freelist;
         adf_os_spin_unlock(&pdev->tx_mutex);
     } else {
         ol_tx_desc_frame_list_free(pdev, &tx_descs, htt_tx_status_discard);
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx.c b/CORE/CLD_TXRX/TXRX/ol_txrx.c
index c48e138cdaa5..25ded5a54f1e 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx.c
@@ -512,7 +512,7 @@ ol_txrx_pdev_attach(
         goto fail8;
     }
 
-#ifdef PERE_IP_HDR_ALIGNMENT_WAR 
+#ifdef PERE_IP_HDR_ALIGNMENT_WAR
     pdev->host_80211_enable = ol_scn_host_80211_enable_get(pdev->ctrl_pdev);
 #endif
 
@@ -677,7 +677,7 @@ ol_txrx_pdev_detach(ol_txrx_pdev_handle pdev, int force)
 
     /* check that the pdev has no vdevs allocated */
     TXRX_ASSERT1(TAILQ_EMPTY(&pdev->vdev_list));
-	
+
     OL_RX_REORDER_TIMEOUT_CLEANUP(pdev);
 
     if (ol_cfg_is_high_latency(pdev->ctrl_pdev)) {
@@ -917,7 +917,7 @@ ol_txrx_vdev_detach(
 
     /* preconditions */
     TXRX_ASSERT2(vdev);
-    	
+
 #if defined(CONFIG_HL_SUPPORT)
     if (ol_cfg_is_high_latency(pdev->ctrl_pdev)) {
         struct ol_tx_frms_queue_t *txq;
@@ -1352,7 +1352,7 @@ ol_txrx_peer_unref_delete(ol_txrx_peer_handle peer)
             peer->mac_addr.raw[0], peer->mac_addr.raw[1],
             peer->mac_addr.raw[2], peer->mac_addr.raw[3],
             peer->mac_addr.raw[4], peer->mac_addr.raw[5]);
-		
+
         /* remove the reference to the peer from the hash table */
         ol_txrx_peer_find_hash_remove(pdev, peer);
 
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx_encap.c b/CORE/CLD_TXRX/TXRX/ol_txrx_encap.c
index f0f894976625..f2d5ac2b6498 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx_encap.c
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx_encap.c
@@ -76,10 +76,10 @@ ol_tx_copy_native_wifi_header(
     return A_OK;
 }
 
-static inline A_STATUS 
+static inline A_STATUS
 ol_tx_encap_from_native_wifi (
-    struct ol_txrx_vdev_t *vdev, 
-    struct ol_tx_desc_t *tx_desc, 
+    struct ol_txrx_vdev_t *vdev,
+    struct ol_tx_desc_t *tx_desc,
     adf_nbuf_t msdu,
     struct ol_txrx_msdu_info_t *tx_msdu_info
 )
@@ -112,8 +112,8 @@ ol_tx_encap_from_native_wifi (
 #if 0
         if ( wmmParam[ac].wmep_noackPolicy ) {
             qos_cntl->i_qos[0]|= 1 << IEEE80211_QOS_ACKPOLICY_S;
-        } 
-#endif 
+        }
+#endif
 
         qos_cntl->i_qos[1] = 0;
         wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_QOS;
@@ -152,10 +152,10 @@ ol_tx_encap_from_native_wifi (
 
 static inline A_STATUS
 ol_tx_encap_from_8023 (
-    struct ol_txrx_vdev_t *vdev, 
-    struct ol_tx_desc_t *tx_desc, 
+    struct ol_txrx_vdev_t *vdev,
+    struct ol_tx_desc_t *tx_desc,
     adf_nbuf_t msdu,
-    struct ol_txrx_msdu_info_t *tx_msdu_info 
+    struct ol_txrx_msdu_info_t *tx_msdu_info
 )
 {
     u_int8_t localbuf[ sizeof(struct ieee80211_qosframe_htc_addr4) \
@@ -171,7 +171,7 @@ ol_tx_encap_from_8023 (
     u_int16_t ether_type;
 
     if (tx_msdu_info->htt.info.frame_type != htt_frm_type_data)
-        return A_OK; 
+        return A_OK;
 
     /*
      * for unicast,the peer should not be NULL.
@@ -189,34 +189,34 @@ ol_tx_encap_from_8023 (
     switch (vdev->opmode) {
     case wlan_op_mode_ap:
         /* DA , BSSID , SA*/
-        adf_os_mem_copy(wh->i_addr1, eth_hdr->dest_addr,        
+        adf_os_mem_copy(wh->i_addr1, eth_hdr->dest_addr,
                         IEEE80211_ADDR_LEN);
-        adf_os_mem_copy(wh->i_addr2, &vdev->mac_addr.raw, 
+        adf_os_mem_copy(wh->i_addr2, &vdev->mac_addr.raw,
                         IEEE80211_ADDR_LEN);
-        adf_os_mem_copy(wh->i_addr3, eth_hdr->src_addr, 
+        adf_os_mem_copy(wh->i_addr3, eth_hdr->src_addr,
                         IEEE80211_ADDR_LEN);
         wh->i_fc[1] = IEEE80211_FC1_DIR_FROMDS;
         new_hdsize = sizeof(struct ieee80211_frame);
         break;
     case wlan_op_mode_ibss:
         /* DA, SA, BSSID */
-        adf_os_mem_copy(wh->i_addr1, eth_hdr->dest_addr, 
+        adf_os_mem_copy(wh->i_addr1, eth_hdr->dest_addr,
                         IEEE80211_ADDR_LEN);
-        adf_os_mem_copy(wh->i_addr2, eth_hdr->src_addr, 
+        adf_os_mem_copy(wh->i_addr2, eth_hdr->src_addr,
                         IEEE80211_ADDR_LEN);
          /* need to check the bssid behaviour for IBSS vdev */
-        adf_os_mem_copy(wh->i_addr3, &vdev->mac_addr.raw, 
+        adf_os_mem_copy(wh->i_addr3, &vdev->mac_addr.raw,
                         IEEE80211_ADDR_LEN);
         wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
         new_hdsize = sizeof(struct ieee80211_frame);
         break;
     case wlan_op_mode_sta:
         /* BSSID, SA , DA*/
-        adf_os_mem_copy(wh->i_addr1, &peer->mac_addr.raw, 
+        adf_os_mem_copy(wh->i_addr1, &peer->mac_addr.raw,
                         IEEE80211_ADDR_LEN);
-        adf_os_mem_copy(wh->i_addr2, eth_hdr->src_addr, 
+        adf_os_mem_copy(wh->i_addr2, eth_hdr->src_addr,
                         IEEE80211_ADDR_LEN);
-        adf_os_mem_copy(wh->i_addr3, eth_hdr->dest_addr, 
+        adf_os_mem_copy(wh->i_addr3, eth_hdr->dest_addr,
                         IEEE80211_ADDR_LEN);
         wh->i_fc[1] = IEEE80211_FC1_DIR_TODS;
         new_hdsize = sizeof(struct ieee80211_frame);
@@ -233,8 +233,8 @@ ol_tx_encap_from_8023 (
 #if 0
         if ( wmmParam[ac].wmep_noackPolicy ) {
             qos_cntl->i_qos[0]|= 1 << IEEE80211_QOS_ACKPOLICY_S;
-        } 
-#endif 
+        }
+#endif
         qos_cntl->i_qos[1] = 0;
         new_hdsize += sizeof(struct ieee80211_qoscntl);
 
@@ -250,8 +250,8 @@ ol_tx_encap_from_8023 (
         llc_hdr = (struct llc_snap_hdr_t *) (localbuf + new_hdsize);
         ether_type = (eth_hdr->ethertype[0]<<8) |(eth_hdr->ethertype[1]);
         if ( ether_type >= IEEE8023_MAX_LEN ) {
-            adf_os_mem_copy(llc_hdr, 
-                            ethernet_II_llc_snap_header_prefix,  
+            adf_os_mem_copy(llc_hdr,
+                            ethernet_II_llc_snap_header_prefix,
                             sizeof(ethernet_II_llc_snap_header_prefix));
             if ( ether_type == ETHERTYPE_AARP || ether_type == ETHERTYPE_IPX) {
                 llc_hdr->org_code[2] = BTEP_SNAP_ORGCODE_2;// 0xf8; bridge tunnel header
@@ -274,7 +274,7 @@ ol_tx_encap_from_8023 (
     return A_OK;
 }
 
-A_STATUS 
+A_STATUS
 ol_tx_encap(
     struct ol_txrx_vdev_t *vdev,
     struct ol_tx_desc_t *tx_desc,
@@ -293,9 +293,9 @@ ol_tx_encap(
     }
 }
 
-static inline void 
+static inline void
 ol_rx_decap_to_native_wifi(
-    struct ol_txrx_vdev_t *vdev, 
+    struct ol_txrx_vdev_t *vdev,
     adf_nbuf_t msdu,
     struct ol_rx_decap_info_t *info,
     struct ethernet_hdr_t *ethr_hdr)
@@ -303,14 +303,14 @@ ol_rx_decap_to_native_wifi(
     struct ieee80211_frame_addr4 *wh;
     u_int16_t hdsize;
 
-    /* 
+    /*
      * we need to remove Qos control field and HT control.
      * MSFT: http://msdn.microsoft.com/en-us/library/windows/hardware/ff552608(v=vs.85).aspx
      */
     wh = (struct ieee80211_frame_addr4 *)info->hdr;
     if ( (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) {
         hdsize = sizeof(struct ieee80211_frame_addr4);
-    } 
+    }
     else {
         hdsize = sizeof(struct ieee80211_frame);
     }
@@ -348,9 +348,9 @@ ol_rx_decap_to_native_wifi(
     }
 }
 
-static inline void 
+static inline void
 ol_rx_decap_to_8023 (
-    struct ol_txrx_vdev_t *vdev, 
+    struct ol_txrx_vdev_t *vdev,
     adf_nbuf_t msdu,
     struct ol_rx_decap_info_t *info,
     struct ethernet_hdr_t *ethr_hdr)
@@ -389,7 +389,7 @@ ol_rx_decap_to_8023 (
     }
     if (l2_hdr_space > ETHERNET_HDR_LEN) {
         buf = adf_nbuf_pull_head(msdu, l2_hdr_space - ETHERNET_HDR_LEN);
-    } 
+    }
     else if (l2_hdr_space <  ETHERNET_HDR_LEN) {
         buf = adf_nbuf_push_head(msdu, ETHERNET_HDR_LEN - l2_hdr_space);
     }
@@ -436,9 +436,9 @@ ol_rx_decap_to_8023 (
 
 static inline A_STATUS
 ol_rx_decap_subfrm_amsdu(
-    struct ol_txrx_vdev_t *vdev, 
+    struct ol_txrx_vdev_t *vdev,
     adf_nbuf_t msdu,
-    struct ol_rx_decap_info_t *info) 
+    struct ol_rx_decap_info_t *info)
 {
     struct ol_txrx_pdev_t *pdev = vdev->pdev;
     u_int8_t * subfrm_hdr;
@@ -459,7 +459,7 @@ ol_rx_decap_subfrm_amsdu(
     }
     else if (pdev->frame_format == wlan_frm_fmt_802_3) {
         if (pdev->sw_rx_llc_proc_enable)  {
-             /* remove llc snap hdr if it's necessary according to 
+             /* remove llc snap hdr if it's necessary according to
              * 802.11 table P-3
              */
             adf_os_mem_copy(ether_hdr,
@@ -482,14 +482,14 @@ ol_rx_decap_subfrm_amsdu(
         /* todo for othertype*/
     }
     return A_OK;
-    
+
 }
 
 static inline A_STATUS
 ol_rx_decap_msdu(
-    struct ol_txrx_vdev_t *vdev, 
+    struct ol_txrx_vdev_t *vdev,
     adf_nbuf_t msdu,
-    struct ol_rx_decap_info_t *info) 
+    struct ol_rx_decap_info_t *info)
 {
     struct ol_txrx_pdev_t *pdev = vdev->pdev;
     struct ieee80211_frame *wh;
@@ -521,7 +521,7 @@ ol_rx_decap_msdu(
                             wh,
                             info->hdr_len);
             adf_nbuf_pull_head(msdu, info->hdr_len);
-            /* remove llc snap hdr if it's necessary according to 
+            /* remove llc snap hdr if it's necessary according to
              * 802.11 table P-3
              */
             ol_rx_decap_to_8023(vdev,
@@ -540,7 +540,7 @@ ol_rx_decap_msdu(
          /* todo for othertype*/
     }
     return A_OK;
-    
+
 }
 
 A_STATUS
@@ -561,7 +561,7 @@ ol_rx_decap(
             info->is_subfrm = 1;
             info->hdr_len = 0;
             if (vdev->pdev->sw_subfrm_hdr_recovery_enable) {
-                /* we save the first subfrm mpdu hdr for subsequent 
+                /* we save the first subfrm mpdu hdr for subsequent
                  * subfrm 802.11 header recovery in certain chip(such as Riva).
                  */
                 mpdu_hdr = adf_nbuf_data(msdu);
@@ -575,9 +575,9 @@ ol_rx_decap(
 
     if (info->is_subfrm && vdev->pdev->sw_subfrm_hdr_recovery_enable) {
        /*
-        * This case is enabled for some HWs(such as Riva).The HW de-aggregate 
+        * This case is enabled for some HWs(such as Riva).The HW de-aggregate
         * doesn't have capability to generate 802.11 header for non-first subframe
-        * of A-MSDU.That means sw needs to cache the first subfrm mpdu header 
+        * of A-MSDU.That means sw needs to cache the first subfrm mpdu header
         * to generate the subsequent subfrm's 802.11 header.
         */
         TXRX_ASSERT2(info->hdr_len != 0);
@@ -587,10 +587,10 @@ ol_rx_decap(
     }
 
     if (info->is_msdu_cmpl_mpdu) {
-        info->is_subfrm = 
-        info->is_first_subfrm = 
+        info->is_subfrm =
+        info->is_first_subfrm =
         info->hdr_len = 0;
     }
     return status;
 }
-#endif 
+#endif
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx_encap.h b/CORE/CLD_TXRX/TXRX/ol_txrx_encap.h
index 1aa0e9a5f276..9d7590e329ef 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx_encap.h
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx_encap.h
@@ -39,19 +39,19 @@
 #include <ol_txrx_types.h>  /* ol_tx_desc_t, ol_txrx_msdu_info_t */
 
 /**
- * @brief Encap outgoing frm from OS dependent format to Target 
+ * @brief Encap outgoing frm from OS dependent format to Target
  *        acceptable frm format
  * @details
  *     For native wifi format, the function will add Qos control field
  *  based on peer's QOS capbabilities .
- *     For 802.3 format, the function will transform to 802.11 format 
+ *     For 802.3 format, the function will transform to 802.11 format
  *  with or without QOS control field based on peer's QOS capabilites.
  * @param vdev - handle to vdev object
  * @param tx_desc - tx desc struct,some fields will be updated.
  * @param msdu - adf_nbuf_t
  * @param msdu_info - informations from tx classification.
- * @return 
- *     A_OK: encap operation sucessful 
+ * @return
+ *     A_OK: encap operation sucessful
  *     other: operation failed,the msdu need be dropped.
  */
 A_STATUS
@@ -82,8 +82,8 @@ struct ol_rx_decap_info_t {
  * @param peer - the peer object.
  * @param msdu - adf_nbuf_t
  * @param info - ol_rx_decap_info_t: context info for decap
- * @return 
- *     A_OK: decap operation sucessful 
+ * @return
+ *     A_OK: decap operation sucessful
  *     other: operation failed,the msdu need be dropped.
  */
 A_STATUS
@@ -94,7 +94,7 @@ ol_rx_decap (
     struct ol_rx_decap_info_t *info);
 
 
-static inline A_STATUS 
+static inline A_STATUS
 OL_TX_ENCAP(
     struct ol_txrx_vdev_t *vdev,
     struct ol_tx_desc_t *tx_desc,
@@ -107,7 +107,7 @@ OL_TX_ENCAP(
     return A_OK;
 }
 
-static inline A_STATUS 
+static inline A_STATUS
 OL_RX_DECAP(
     struct ol_txrx_vdev_t *vdev,
     struct ol_txrx_peer_t *peer,
@@ -127,6 +127,6 @@ OL_RX_DECAP(
 #else
 #define OL_TX_ENCAP(vdev, tx_desc, msdu, msdu_info) A_OK
 #define OL_RX_DECAP(vdev, peer, msdu, info) A_OK
-#define OL_TX_RESTORE_HDR(__tx_desc,__msdu)  
+#define OL_TX_RESTORE_HDR(__tx_desc,__msdu)
 #endif
 #endif /* _OL_TXRX_ENCAP__H_ */
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx_event.c b/CORE/CLD_TXRX/TXRX/ol_txrx_event.c
index 04e90c8c523d..02204838f0e9 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx_event.c
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx_event.c
@@ -45,19 +45,19 @@ wdi_event_del_subs(wdi_event_subscribe *wdi_sub, int event_index)
     wdi_event_notify deallocate_sub;
     while (wdi_sub) {
         wdi_event_subscribe *next = wdi_event_next_sub(wdi_sub);
-            /* 
+            /*
              *  Context is NULL for static allocation of subs
              *  In dynamic allocation case notify the user
              */
         if (wdi_sub->context) {
-            deallocate_sub = wdi_sub->context; 
+            deallocate_sub = wdi_sub->context;
             deallocate_sub(
                 WDI_EVENT_SUB_DEALLOCATE, WDI_EVENT_BASE + event_index);
         }
         wdi_sub = next;
     }
     //adf_os_mem_free(wdi_sub);
-} 
+}
 
 static inline void
 wdi_event_iter_sub(
@@ -70,7 +70,7 @@ wdi_event_iter_sub(
 
     if (wdi_sub) {
         do {
-            wdi_sub->callback(pdev, event, data); 
+            wdi_sub->callback(pdev, event, data);
         } while ((wdi_sub = wdi_event_next_sub(wdi_sub)));
     }
 }
@@ -85,9 +85,9 @@ wdi_event_handler(
     wdi_event_subscribe *wdi_sub;
     /*
      * Input validation
-     */ 
+     */
     if (!event) {
-        adf_os_print("Invalid WDI event in %s\n", __FUNCTION__); 
+        adf_os_print("Invalid WDI event in %s\n", __FUNCTION__);
         return;
     }
     if (!txrx_pdev) {
@@ -99,7 +99,7 @@ wdi_event_handler(
      *  Subscribers must do the sanity based on the requirements
      */
     event_index = event - WDI_EVENT_BASE;
-    
+
     wdi_sub = txrx_pdev->wdi_event_list[event_index];
 
     /* Find the subscriber */
@@ -109,7 +109,7 @@ wdi_event_handler(
 A_STATUS
 wdi_event_sub(
     struct ol_txrx_pdev_t *txrx_pdev,
-    wdi_event_subscribe *event_cb_sub, 
+    wdi_event_subscribe *event_cb_sub,
     enum WDI_EVENT event)
 {
     uint32_t event_index;
@@ -127,11 +127,11 @@ wdi_event_sub(
         adf_os_print("Invalid event in %s", __FUNCTION__);
         return A_ERROR;
     } /* Input validation */
-    
+
     event_index = event - WDI_EVENT_BASE;
 
     wdi_sub = txrx_pdev->wdi_event_list[event_index];
-    /* 
+    /*
      *  Check if it is the first subscriber of the event
      */
     if (!wdi_sub) {
@@ -152,7 +152,7 @@ wdi_event_sub(
 A_STATUS
 wdi_event_unsub(
     struct ol_txrx_pdev_t *txrx_pdev,
-    wdi_event_subscribe *event_cb_sub, 
+    wdi_event_subscribe *event_cb_sub,
     enum WDI_EVENT event)
 {
     uint32_t event_index = event - WDI_EVENT_BASE;
@@ -172,7 +172,7 @@ wdi_event_unsub(
     }
     //adf_os_mem_free(event_cb_sub);
 
-    return A_OK; 
+    return A_OK;
 }
 
 A_STATUS
@@ -184,7 +184,7 @@ wdi_event_attach(struct ol_txrx_pdev_t *txrx_pdev)
             "Invalid device in %s\nWDI event attach failed", __FUNCTION__);
         return A_ERROR;
     }
-    /* Separate subscriber list for each event */ 
+    /* Separate subscriber list for each event */
     txrx_pdev->wdi_event_list = (wdi_event_subscribe **)
         adf_os_mem_alloc(
             txrx_pdev->osdev, sizeof(wdi_event_subscribe *) * WDI_NUM_EVENTS);
@@ -192,7 +192,7 @@ wdi_event_attach(struct ol_txrx_pdev_t *txrx_pdev)
         adf_os_print("Insufficient memory for the WDI event lists\n");
         return A_NO_MEMORY;
     }
-    return A_OK; 
+    return A_OK;
 }
 
 A_STATUS
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx_internal.h b/CORE/CLD_TXRX/TXRX/ol_txrx_internal.h
index 5916d9a6c6ea..3081951c7202 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx_internal.h
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx_internal.h
@@ -372,7 +372,7 @@ ol_txrx_ieee80211_hdrsize(const void *data)
         (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_CTL);
     if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) {
         size += IEEE80211_ADDR_LEN;
-    } 
+    }
     if (IEEE80211_QOS_HAS_SEQ(wh)) {
         size += sizeof(u_int16_t);
         /* Qos frame with Order bit set indicates an HTC frame */
@@ -603,9 +603,9 @@ do {
 	}                                                                                \
 } while (false)
 #else
-#define OL_RX_ERR_STATISTICS(pdev, vdev, err_type, sec_type, is_mcast) 
-#define OL_RX_ERR_STATISTICS_1(pdev, vdev, peer, rx_desc, err_type) 
-#define OL_RX_ERR_STATISTICS_2(pdev, vdev, peer, rx_desc, rx_msdu, rx_status) 
+#define OL_RX_ERR_STATISTICS(pdev, vdev, err_type, sec_type, is_mcast)
+#define OL_RX_ERR_STATISTICS_1(pdev, vdev, peer, rx_desc, err_type)
+#define OL_RX_ERR_STATISTICS_2(pdev, vdev, peer, rx_desc, rx_msdu, rx_status)
 #endif /* SUPPORT_HOST_STATISTICS */
 
 #ifdef QCA_ENABLE_OL_TXRX_PEER_STATS
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.c b/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.c
index 80081c3eec3a..8cb595167443 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.c
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.c
@@ -68,11 +68,11 @@ ol_txrx_log2_ceil(unsigned value)
     if (1U << log2 != value) {
         log2++;
     }
-    
+
     return log2;
 }
 
-static int 
+static int
 ol_txrx_peer_find_add_id_to_obj(
     struct ol_txrx_peer_t *peer,
     u_int16_t peer_id)
@@ -83,7 +83,7 @@ ol_txrx_peer_find_add_id_to_obj(
         if (peer->peer_ids[i] == HTT_INVALID_PEER) {
             peer->peer_ids[i] = peer_id;
             return 0; /* success */
-        } 
+        }
     }
     return 1; /* failure */
 }
@@ -113,7 +113,7 @@ static int
 ol_txrx_peer_find_hash_attach(struct ol_txrx_pdev_t *pdev)
 {
     int i, hash_elems, log2;
-	
+
     /* allocate the peer MAC address -> peer object hash table */
     hash_elems = ol_cfg_max_peer_id(pdev->ctrl_pdev) + 1;
     hash_elems *= TXRX_PEER_HASH_LOAD_MULT;
@@ -197,7 +197,7 @@ ol_txrx_peer_find_hash_find(
             &local_mac_addr_aligned.raw[0],
             peer_mac_addr, OL_TXRX_MAC_ADDR_LEN);
         mac_addr = &local_mac_addr_aligned;
-    } 
+    }
     index = ol_txrx_peer_find_hash_index(pdev, mac_addr);
     adf_os_spin_lock_bh(&pdev->peer_ref_mutex);
     TAILQ_FOREACH(peer, &pdev->peer_hash.bins[index], hash_list_elem) {
@@ -248,7 +248,7 @@ ol_txrx_peer_find_hash_erase(struct ol_txrx_pdev_t *pdev)
      * Not really necessary to take peer_ref_mutex lock - by this point,
      * it's known that the pdev is no longer in use.
      */
-	
+
     for (i = 0; i <= pdev->peer_hash.mask; i++) {
         if (!TAILQ_EMPTY(&pdev->peer_hash.bins[i])) {
             struct ol_txrx_peer_t *peer, *peer_next;
@@ -263,7 +263,7 @@ ol_txrx_peer_find_hash_erase(struct ol_txrx_pdev_t *pdev)
 				/*
                  * Don't remove the peer from the hash table -
                  * that would modify the list we are currently traversing,
-                 * and it's not necessary anyway. 
+                 * and it's not necessary anyway.
                  */
                 /*
                  * Artificially adjust the peer's ref count to 1, so it
@@ -447,11 +447,11 @@ ol_rx_peer_unmap_handler(
      * If the peer ID is for a vdev, then the peer pointer stored
      * in peer_id_to_obj_map will be NULL.
      */
-    if (!peer) return;	
+    if (!peer) return;
     /*
      * Remove a reference to the peer.
      * If there are no more references, delete the peer object.
-     */	
+     */
     ol_txrx_peer_unref_delete(peer);
 }
 
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.h b/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.h
index fbe1410a1f39..2e4654091efd 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.h
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx_peer_find.h
@@ -116,6 +116,6 @@ ol_txrx_assoc_peer_find(struct ol_txrx_vdev_t *vdev);
 void ol_txrx_peer_find_display(ol_txrx_pdev_handle pdev, int indent);
 #else
 #define ol_txrx_peer_find_display(pdev, indent)
-#endif /* TXRX_DEBUG_LEVEL */    
+#endif /* TXRX_DEBUG_LEVEL */
 
 #endif /* _OL_TXRX_PEER_FIND__H_ */
diff --git a/CORE/CLD_TXRX/TXRX/txrx.h b/CORE/CLD_TXRX/TXRX/txrx.h
index 5cbb87a7abcb..89645112ee8a 100644
--- a/CORE/CLD_TXRX/TXRX/txrx.h
+++ b/CORE/CLD_TXRX/TXRX/txrx.h
@@ -28,7 +28,7 @@
 #ifndef TXRX_H
 #define TXRX_H
 
-#include "vos_api.h" 
+#include "vos_api.h"
 #include "adf_nbuf.h"
 #include "csrApi.h"
 #include "sapApi.h"
@@ -36,7 +36,7 @@
 #include "ol_txrx_osif_api.h"
 #include "wlan_qct_tl.h"
 
-enum txrx_wmm_ac {  
+enum txrx_wmm_ac {
 	TXRX_WMM_AC_VO,
 	TXRX_WMM_AC_VI,
 	TXRX_WMM_AC_BK,
@@ -72,14 +72,14 @@ enum bt_frame_type {
 };
 
 enum wlan_ts_direction {
-	/* uplink */         
-	WLAN_TX_DIR = 0,          
+	/* uplink */
+	WLAN_TX_DIR = 0,
 
-	/* downlink */                                                              
-	WLAN_RX_DIR = 1,                                    
+	/* downlink */
+	WLAN_RX_DIR = 1,
 
-	/*bidirectional*/                            
-	WLAN_BI_DIR = 2,     
+	/*bidirectional*/
+	WLAN_BI_DIR = 2,
 };
 
 enum wlan_sta_state {
@@ -194,7 +194,7 @@ static inline int wlan_get_txrx_stats(void *g_vosctx, struct wlan_txrx_stats *st
 }
 
 static inline int wlan_txrx_update_rssi_bmps(void *g_vosctx, u8 sta_id,
-					     v_S7_t rssi) 
+					     v_S7_t rssi)
 {
 	return 0;
 }
@@ -234,4 +234,4 @@ static inline void wlan_txrx_mc_free_msg(void *g_vosctx, vos_msg_t *msg)
 static inline void wlan_txrx_tx_free_msg(void *g_vosctx, vos_msg_t *msg)
 {
 }
-#endif 
+#endif