return ret;
 }
 
-void   expire_timeout_chk23a(struct rtw_adapter *padapter)
+void expire_timeout_chk23a(struct rtw_adapter *padapter)
 {
        struct list_head *phead;
        u8 updated = 0;
        int i;
 
        spin_lock_bh(&pstapriv->auth_list_lock);
-
        phead = &pstapriv->auth_list;
-
        /* check auth_queue */
        list_for_each_entry_safe(psta, ptmp, phead, auth_list) {
-
                if (psta->expire_to > 0) {
                        psta->expire_to--;
                        if (psta->expire_to == 0) {
                                spin_lock_bh(&pstapriv->auth_list_lock);
                        }
                }
-
        }
-
        spin_unlock_bh(&pstapriv->auth_list_lock);
 
        spin_lock_bh(&pstapriv->asoc_list_lock);
-
        phead = &pstapriv->asoc_list;
-
        /* check asoc_queue */
        list_for_each_entry_safe(psta, ptmp, phead, asoc_list) {
-
                if (chk_sta_is_alive(psta) || !psta->expire_to) {
                        psta->expire_to = pstapriv->expire_to;
                        psta->keep_alive_trycnt = 0;
                        }
                }
        }
-
        spin_unlock_bh(&pstapriv->asoc_list_lock);
 
        if (chk_alive_num) {
                return -1;
 
        spin_lock_bh(&pacl_node_q->lock);
-
        phead = get_list_head(pacl_node_q);
-
        list_for_each_entry(paclnode, phead, list) {
-
                if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
                        if (paclnode->valid == true) {
                                added = true;
                        }
                }
        }
-
        spin_unlock_bh(&pacl_node_q->lock);
 
        if (added)
        DBG_8723A("%s(acl_num =%d) = %pM\n", __func__, pacl_list->num, addr);
 
        spin_lock_bh(&pacl_node_q->lock);
-
        phead = get_list_head(pacl_node_q);
-
        list_for_each_entry_safe(paclnode, ptmp, phead, list) {
-
                if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
                        if (paclnode->valid) {
                                paclnode->valid = false;
                        }
                }
        }
-
        spin_unlock_bh(&pacl_node_q->lock);
 
        DBG_8723A("%s, acl_num =%d\n", __func__, pacl_list->num);
                struct sta_priv *pstapriv = &padapter->stapriv;
 
                spin_lock_bh(&pstapriv->asoc_list_lock);
-
                phead = &pstapriv->asoc_list;
-
                list_for_each_entry_safe(psta, ptmp, phead, asoc_list)
                        VCS_update23a(padapter, psta);
-
                spin_unlock_bh(&pstapriv->asoc_list_lock);
        }
 }
 
        spin_lock_bh(&pstapriv->asoc_list_lock);
        phead = &pstapriv->asoc_list;
-
        list_for_each_entry(psta, phead, asoc_list) {
-
                issue_action_spct_ch_switch23a(padapter, psta->hwaddr, new_ch, ch_offset);
                psta->expire_to = ((pstapriv->expire_to * 2) > 5) ? 5 : (pstapriv->expire_to * 2);
        }
 
        spin_lock_bh(&pstapriv->asoc_list_lock);
        phead = &pstapriv->asoc_list;
-
        list_for_each_entry_safe(psta, ptmp, phead, asoc_list) {
-
                /* Remove sta from asoc_list */
                list_del_init(&psta->asoc_list);
                pstapriv->asoc_list_cnt--;
        }
 
        spin_lock_bh(&pstapriv->asoc_list_lock);
-
        phead = &pstapriv->asoc_list;
-
        list_for_each_entry_safe(psta, ptmp, phead, asoc_list)
                chk_alive_list[chk_alive_num++] = psta;
-
        spin_unlock_bh(&pstapriv->asoc_list_lock);
 
        for (i = 0; i < chk_alive_num; i++) {
        /* for ACL */
        spin_lock_bh(&pacl_node_q->lock);
        phead = get_list_head(pacl_node_q);
-
        list_for_each_entry_safe(paclnode, ptmp, phead, list) {
-
                if (paclnode->valid == true) {
                        paclnode->valid = false;
-
                        list_del_init(&paclnode->list);
-
                        pacl_list->num--;
                }
        }
 
        struct rtw_queue *scanned_queue = &pmlmepriv->scanned_queue;
 
        spin_lock_bh(&scanned_queue->lock);
-
        phead = get_list_head(scanned_queue);
-
        list_for_each_entry_safe(pnetwork, ptmp, phead, list)
                _rtw_free_network23a(pmlmepriv, pnetwork);
-
        spin_unlock_bh(&scanned_queue->lock);
 }
 
        struct wlan_network *oldest = NULL;
 
        phead = get_list_head(scanned_queue);
-
        list_for_each_entry(pwlan, phead, list) {
-
                if (pwlan->fixed != true) {
                        if (!oldest || time_after(oldest->last_scanned,
                                                  pwlan->last_scanned))
 
        spin_lock_bh(&queue->lock);
        phead = get_list_head(queue);
-
        list_for_each(plist, phead) {
                pnetwork = container_of(plist, struct wlan_network, list);
 
 
        RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, "+free_scanqueue\n");
        spin_lock_bh(&scan_queue->lock);
-
        phead = get_list_head(scan_queue);
-
        list_for_each_entry_safe(pnetwork, ptemp, phead, list) {
                pnetwork->fixed = false;
                _rtw_free_network23a(pmlmepriv, pnetwork);
        }
-
        spin_unlock_bh(&scan_queue->lock);
 }
 
 
        spin_lock_bh(&pmlmepriv->scanned_queue.lock);
        phead = get_list_head(queue);
-
        list_for_each_entry_safe(pnetwork, ptmp, phead, list) {
                if (!pnetwork) {
                        RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 
                struct list_head *phead;
                struct xmit_frame *pxmitframe, *ptmp;
                struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
-               struct sta_priv  *pstapriv = &padapter->stapriv;
+               struct sta_priv *pstapriv = &padapter->stapriv;
 
                /* for BC/MC Frames */
                psta_bmc = rtw_get_bcmc_stainfo23a(padapter);
                                rtl8723au_hal_xmitframe_enqueue(padapter,
                                                                pxmitframe);
                        }
-
                        /* spin_unlock_bh(&psta_bmc->sleep_q.lock); */
                        spin_unlock_bh(&pxmitpriv->lock);
                }
 
        return res;
 }
 
-void _rtw_free_recv_priv23a (struct recv_priv *precvpriv)
+void _rtw_free_recv_priv23a(struct recv_priv *precvpriv)
 {
        struct rtw_adapter *padapter = precvpriv->adapter;
        struct recv_frame *precvframe, *ptmp;
        struct list_head *phead;
 
        spin_lock(&pframequeue->lock);
-
        phead = get_list_head(pframequeue);
-
        list_for_each_entry_safe(hdr, ptmp, phead, list)
                rtw_free_recvframe23a(hdr);
-
        spin_unlock(&pframequeue->lock);
 }
 
                                    struct rtw_queue *defrag_q)
 {
        struct list_head *plist, *phead;
-       u8      wlanhdr_offset;
-       u8      curfragnum;
+       u8 wlanhdr_offset;
+       u8 curfragnum;
        struct recv_frame *pnfhdr, *ptmp;
        struct recv_frame *prframe, *pnextrframe;
-       struct rtw_queue        *pfree_recv_queue;
+       struct rtw_queue *pfree_recv_queue;
        struct sk_buff *skb;
 
-
-
        curfragnum = 0;
        pfree_recv_queue = &adapter->recvpriv.free_recv_queue;
 
        RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
                 "Performance defrag!!!!!\n");
 
-
-
        return prframe;
 }
 
 
                spin_lock_bh(&pstapriv->sta_hash_lock);
                for (index = 0; index < NUM_STA; index++) {
                        phead = &pstapriv->sta_hash[index];
-
                        list_for_each_entry_safe(psta, ptmp, phead, hash_list) {
                                int i;
 
                return;
 
        spin_lock_bh(&pstapriv->sta_hash_lock);
-
        for (index = 0; index < NUM_STA; index++) {
                phead = &pstapriv->sta_hash[index];
-
                list_for_each_entry_safe(psta, ptmp, phead, hash_list) {
-
                        if (pbcmc_stainfo != psta)
                                rtw_free_stainfo23a(padapter, psta);
                }
 {
        struct list_head *phead;
        struct sta_info *psta = NULL;
-       u32     index;
+       u32 index;
        const u8 *addr;
 
        if (hwaddr == NULL)
        index = wifi_mac_hash(addr);
 
        spin_lock_bh(&pstapriv->sta_hash_lock);
-
        phead = &pstapriv->sta_hash[index];
-
        list_for_each_entry(psta, phead, hash_list) {
-
                /*  if found the matched address */
                if (ether_addr_equal(psta->hwaddr, addr))
                        break;
 
        spin_lock_bh(&pacl_node_q->lock);
        phead = get_list_head(pacl_node_q);
-
        list_for_each_entry(paclnode, phead, list) {
-
                if (ether_addr_equal(paclnode->addr, mac_addr)) {
                        if (paclnode->valid) {
                                match = true;
 
        goto exit;
 }
 
-void _rtw_free_xmit_priv23a (struct xmit_priv *pxmitpriv)
+void _rtw_free_xmit_priv23a(struct xmit_priv *pxmitpriv)
 {
        struct rtw_adapter *padapter = pxmitpriv->adapter;
        struct xmit_frame *pxframe, *ptmp;
        struct xmit_frame *pxmitframe, *ptmp;
 
        spin_lock_bh(&pframequeue->lock);
-
        phead = get_list_head(pframequeue);
-
        list_for_each_entry_safe(pxmitframe, ptmp, phead, list)
                rtw_free_xmitframe23a(pxmitpriv, pxmitframe);
        spin_unlock_bh(&pframequeue->lock);
                phwxmit = phwxmit_i + inx[i];
 
                sta_phead = get_list_head(phwxmit->sta_queue);
-
                list_for_each_entry_safe(ptxservq, ptmp, sta_phead,
                                         tx_pending) {
-
                        pframe_queue = &ptxservq->sta_pending;
 
                        pxmitframe = dequeue_one_xmitframe(pxmitpriv, phwxmit, ptxservq, pframe_queue);
 {
        int ret;
        struct list_head *phead;
-       u8      ac_index;
+       u8 ac_index;
        struct tx_servq *ptxservq;
-       struct pkt_attrib       *pattrib;
-       struct xmit_frame       *pxmitframe, *ptmp;
-       struct hw_xmit *phwxmits =  padapter->xmitpriv.hwxmits;
+       struct pkt_attrib *pattrib;
+       struct xmit_frame *pxmitframe, *ptmp;
+       struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
 
        phead = get_list_head(pframequeue);
-
        list_for_each_entry_safe(pxmitframe, ptmp, phead, list) {
-
                ret = xmitframe_enqueue_for_sleeping_sta23a(padapter, pxmitframe);
 
                if (ret == true) {
        struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 
        spin_lock_bh(&pxmitpriv->lock);
-
        phead = get_list_head(&psta->sleep_q);
-
        list_for_each_entry_safe(pxmitframe, ptmp, phead, list) {
                list_del_init(&pxmitframe->list);
 
 
                pstapriv->sta_dz_bitmap &= ~CHKBIT(psta->aid);
        }
-
        /* spin_unlock_bh(&psta->sleep_q.lock); */
        spin_unlock_bh(&pxmitpriv->lock);
 
        if ((pstapriv->sta_dz_bitmap&0xfffe) == 0x0) {
                /* no any sta in ps mode */
                spin_lock_bh(&pxmitpriv->lock);
-
                phead = get_list_head(&psta_bmc->sleep_q);
-
                list_for_each_entry_safe(pxmitframe, ptmp, phead, list) {
-
                        list_del_init(&pxmitframe->list);
 
                        psta_bmc->sleepq_len--;
                        /* update_BCNTIM(padapter); */
                        update_mask |= BIT(1);
                }
-
                /* spin_unlock_bh(&psta_bmc->sleep_q.lock); */
                spin_unlock_bh(&pxmitpriv->lock);
        }
 
        /* spin_lock_bh(&psta->sleep_q.lock); */
        spin_lock_bh(&pxmitpriv->lock);
-
        phead = get_list_head(&psta->sleep_q);
-
        list_for_each_entry_safe(pxmitframe, ptmp, phead, list) {
-
                switch (pxmitframe->attrib.priority) {
                case 1:
                case 2:
 
        struct wlan_network *pnetwork, *ptmp;
 
        spin_lock_bh(&pmlmepriv->scanned_queue.lock);
-
        phead = get_list_head(queue);
-
        list_for_each_entry_safe(pnetwork, ptmp, phead, list) {
-
                /* report network only if the current channel set
                   contains the channel to which this network belongs */
                if (rtw_ch_set_search_ch23a
                     pnetwork->network.DSConfig) >= 0)
                        rtw_cfg80211_inform_bss(padapter, pnetwork);
        }
-
        spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 
        /* call this after other things have been done */
                return -EINVAL;
 
        spin_lock_bh(&pstapriv->asoc_list_lock);
-
        phead = &pstapriv->asoc_list;
-
        /* check asoc_queue */
        list_for_each_entry_safe(psta, ptmp, phead, asoc_list) {
-
                if (ether_addr_equal(mac, psta->hwaddr)) {
                        if (psta->dot8021xalg == 1 &&
                            psta->bpairwise_key_installed == false) {
                        }
                }
        }
-
        spin_unlock_bh(&pstapriv->asoc_list_lock);
 
        associated_clients_update23a(padapter, updated);