if (psta->expire_to > 0) {
                        psta->expire_to--;
                        if (psta->expire_to == 0) {
-                               rtw_list_delete(&psta->auth_list);
+                               list_del_init(&psta->auth_list);
                                pstapriv->auth_list_cnt--;
 
                                DBG_88E("auth expire %6ph\n",
                                continue;
                        }
 
-                       rtw_list_delete(&psta->asoc_list);
+                       list_del_init(&psta->asoc_list);
                        pstapriv->asoc_list_cnt--;
 
                        DBG_88E("asoc expire %pM, state = 0x%x\n", (psta->hwaddr), psta->state);
 
                        DBG_88E("asoc expire %pM, state = 0x%x\n", (psta->hwaddr), psta->state);
                        spin_lock_bh(&pstapriv->asoc_list_lock);
-                       rtw_list_delete(&psta->asoc_list);
+                       list_del_init(&psta->asoc_list);
                        pstapriv->asoc_list_cnt--;
                        updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
                        spin_unlock_bh(&pstapriv->asoc_list_lock);
                        if (paclnode->valid) {
                                paclnode->valid = false;
 
-                               rtw_list_delete(&paclnode->list);
+                               list_del_init(&paclnode->list);
 
                                pacl_list->num--;
                        }
 
                plist = plist->next;
 
-               rtw_list_delete(&psta->asoc_list);
+               list_del_init(&psta->asoc_list);
                pstapriv->asoc_list_cnt--;
 
                ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
                if (paclnode->valid) {
                        paclnode->valid = false;
 
-                       rtw_list_delete(&paclnode->list);
+                       list_del_init(&paclnode->list);
 
                        pacl_list->num--;
                }
 
                obj = NULL;
        } else {
                obj = container_of((&queue->queue)->next, struct cmd_obj, list);
-               rtw_list_delete(&obj->list);
+               list_del_init(&obj->list);
        }
 
        spin_unlock_irqrestore(&queue->lock, irqL);
 
        } else {
                pnetwork = container_of((&queue->queue)->next, struct wlan_network, list);
 
-               rtw_list_delete(&(pnetwork->list));
+               list_del_init(&(pnetwork->list));
        }
 
        spin_unlock_bh(&queue->lock);
 
        pnetwork = container_of(plist , struct wlan_network, list);
 
-       rtw_list_delete(&pnetwork->list);
+       list_del_init(&pnetwork->list);
 
        RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("_rtw_alloc_network: ptr=%p\n", plist));
        pnetwork->network_type = 0;
                        return;
        }
        spin_lock_bh(&free_queue->lock);
-       rtw_list_delete(&(pnetwork->list));
+       list_del_init(&(pnetwork->list));
        list_add_tail(&(pnetwork->list), &(free_queue->queue));
        pmlmepriv->num_of_scanned--;
        spin_unlock_bh(&free_queue->lock);
                return;
        if (pnetwork->fixed)
                return;
-       rtw_list_delete(&(pnetwork->list));
+       list_del_init(&(pnetwork->list));
        list_add_tail(&(pnetwork->list), get_list_head(free_queue));
        pmlmepriv->num_of_scanned--;
 }
 
        while (plist != phead) {
                ptemp = plist->next;
-               rtw_list_delete(plist);
+               list_del_init(plist);
                list_add_tail(plist, &free_queue->queue);
                plist = ptemp;
                pmlmepriv->num_of_scanned--;
 
        } else {
                spin_lock_bh(&pstapriv->asoc_list_lock);
                if (!list_empty(&pstat->asoc_list)) {
-                       rtw_list_delete(&pstat->asoc_list);
+                       list_del_init(&pstat->asoc_list);
                        pstapriv->asoc_list_cnt--;
                }
                spin_unlock_bh(&pstapriv->asoc_list_lock);
 
        spin_lock_bh(&pstapriv->auth_list_lock);
        if (!list_empty(&pstat->auth_list)) {
-               rtw_list_delete(&pstat->auth_list);
+               list_del_init(&pstat->auth_list);
                pstapriv->auth_list_cnt--;
        }
        spin_unlock_bh(&pstapriv->auth_list_lock);
 
                        spin_lock_bh(&pstapriv->asoc_list_lock);
                        if (!list_empty(&psta->asoc_list)) {
-                               rtw_list_delete(&psta->asoc_list);
+                               list_del_init(&psta->asoc_list);
                                pstapriv->asoc_list_cnt--;
                                updated = ap_free_sta(padapter, psta, false, reason);
                        }
 
                        spin_lock_bh(&pstapriv->asoc_list_lock);
                        if (!list_empty(&psta->asoc_list)) {
-                               rtw_list_delete(&psta->asoc_list);
+                               list_del_init(&psta->asoc_list);
                                pstapriv->asoc_list_cnt--;
                                updated = ap_free_sta(padapter, psta, false, reason);
                        }
 
                                xmitframe_plist = xmitframe_plist->next;
 
-                               rtw_list_delete(&pxmitframe->list);
+                               list_del_init(&pxmitframe->list);
 
                                psta_bmc->sleepq_len--;
                                if (psta_bmc->sleepq_len > 0)
 
 
                hdr = container_of(plist, struct recv_frame, list);
 
-               rtw_list_delete(&hdr->list);
+               list_del_init(&hdr->list);
                padapter = hdr->adapter;
                if (padapter != NULL) {
                        precvpriv = &padapter->recvpriv;
 
        spin_lock_bh(&pfree_recv_queue->lock);
 
-       rtw_list_delete(&(precvframe->list));
+       list_del_init(&(precvframe->list));
 
        precvframe->len = 0;
 
        struct recv_priv *precvpriv = &padapter->recvpriv;
 
 
-       rtw_list_delete(&(precvframe->list));
+       list_del_init(&(precvframe->list));
        list_add_tail(&(precvframe->list), get_list_head(queue));
 
        if (padapter != NULL) {
 
                                xmitframe_plist = xmitframe_plist->next;
 
-                               rtw_list_delete(&pxmitframe->list);
+                               list_del_init(&pxmitframe->list);
 
                                psta->sleepq_len--;
 
        plist = phead->next;
        pfhdr = container_of(plist, struct recv_frame, list);
        prframe = (struct recv_frame *)pfhdr;
-       rtw_list_delete(&(prframe->list));
+       list_del_init(&(prframe->list));
 
        if (curfragnum != pfhdr->attrib.frag_num) {
                /* the first fragment number must be 0 */
                        break;
        }
 
-       rtw_list_delete(&(prframe->list));
+       list_del_init(&(prframe->list));
 
        list_add_tail(&(prframe->list), plist);
        return true;
                                 ("recv_indicatepkts_in_order: indicate=%d seq=%d amsdu=%d\n",
                                  preorder_ctrl->indicate_seq, pattrib->seq_num, pattrib->amsdu));
                        plist = plist->next;
-                       rtw_list_delete(&(prframe->list));
+                       list_del_init(&(prframe->list));
 
                        if (SN_EQUAL(preorder_ctrl->indicate_seq, pattrib->seq_num))
                                preorder_ctrl->indicate_seq = (preorder_ctrl->indicate_seq + 1) & 0xFFF;
 
                psta = NULL;
        } else {
                psta = container_of((&pfree_sta_queue->queue)->next, struct sta_info, list);
-               rtw_list_delete(&(psta->list));
+               list_del_init(&(psta->list));
                spin_unlock_bh(&pfree_sta_queue->lock);
                _rtw_init_stainfo(psta);
                memcpy(psta->hwaddr, hwaddr, ETH_ALEN);
 
        rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vo_q.sta_pending);
 
-       rtw_list_delete(&(pstaxmitpriv->vo_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->vo_q.tx_pending));
 
        rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vi_q.sta_pending);
 
-       rtw_list_delete(&(pstaxmitpriv->vi_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->vi_q.tx_pending));
 
        rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->bk_q.sta_pending);
 
-       rtw_list_delete(&(pstaxmitpriv->bk_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->bk_q.tx_pending));
 
        rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->be_q.sta_pending);
 
-       rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->be_q.tx_pending));
 
        spin_unlock_bh(&pxmitpriv->lock);
 
-       rtw_list_delete(&psta->hash_list);
+       list_del_init(&psta->hash_list);
        RT_TRACE(_module_rtl871x_sta_mgt_c_, _drv_err_, ("\n free number_%d stainfo  with hwaddr=0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x\n", pstapriv->asoc_sta_count , psta->hwaddr[0], psta->hwaddr[1], psta->hwaddr[2], psta->hwaddr[3], psta->hwaddr[4], psta->hwaddr[5]));
        pstapriv->asoc_sta_count--;
 
 
                        plist = plist->next;
 
-                       rtw_list_delete(&(prframe->list));
+                       list_del_init(&(prframe->list));
 
                        rtw_free_recvframe(prframe, pfree_recv_queue);
                }
 
        spin_lock_bh(&pstapriv->auth_list_lock);
        if (!list_empty(&psta->auth_list)) {
-               rtw_list_delete(&psta->auth_list);
+               list_del_init(&psta->auth_list);
                pstapriv->auth_list_cnt--;
        }
        spin_unlock_bh(&pstapriv->auth_list_lock);
 
 
                pxmitbuf = container_of(plist, struct xmit_buf, list);
 
-               rtw_list_delete(&(pxmitbuf->list));
+               list_del_init(&(pxmitbuf->list));
        }
 
        if (pxmitbuf !=  NULL) {
 
        spin_lock_irqsave(&pfree_queue->lock, irql);
 
-       rtw_list_delete(&pxmitbuf->list);
+       list_del_init(&pxmitbuf->list);
 
        list_add_tail(&(pxmitbuf->list), get_list_head(pfree_queue));
        pxmitpriv->free_xmit_extbuf_cnt++;
 
                pxmitbuf = container_of(plist, struct xmit_buf, list);
 
-               rtw_list_delete(&(pxmitbuf->list));
+               list_del_init(&(pxmitbuf->list));
        }
 
        if (pxmitbuf !=  NULL) {
        } else {
                spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irql);
 
-               rtw_list_delete(&pxmitbuf->list);
+               list_del_init(&pxmitbuf->list);
 
                list_add_tail(&(pxmitbuf->list), get_list_head(pfree_xmitbuf_queue));
 
 
                pxframe = container_of(plist, struct xmit_frame, list);
 
-               rtw_list_delete(&(pxframe->list));
+               list_del_init(&(pxframe->list));
        }
 
        if (pxframe !=  NULL) { /* default value setting */
 
        spin_lock_bh(&pfree_xmit_queue->lock);
 
-       rtw_list_delete(&pxmitframe->list);
+       list_del_init(&pxmitframe->list);
 
        if (pxmitframe->pkt) {
                pndis_pkt = pxmitframe->pkt;
 
                xmitframe_plist = xmitframe_plist->next;
 
-               rtw_list_delete(&pxmitframe->list);
+               list_del_init(&pxmitframe->list);
 
                ptxservq->qcnt--;
        }
 
                                /* Remove sta node when there are no pending packets. */
                                if (_rtw_queue_empty(pframe_queue)) /* must be done after get_next and before break */
-                                       rtw_list_delete(&ptxservq->tx_pending);
+                                       list_del_init(&ptxservq->tx_pending);
                                goto exit;
                        }
 
                spin_lock_bh(&psta->sleep_q.lock);
 
                if (pstapriv->sta_dz_bitmap) {/* if any one sta is in ps mode */
-                       rtw_list_delete(&pxmitframe->list);
+                       list_del_init(&pxmitframe->list);
 
                        list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
 
                u8 wmmps_ac = 0;
 
                if (pstapriv->sta_dz_bitmap&BIT(psta->aid)) {
-                       rtw_list_delete(&pxmitframe->list);
+                       list_del_init(&pxmitframe->list);
 
                        list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
 
        pstapriv->sta_dz_bitmap |= BIT(psta->aid);
 
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
-       rtw_list_delete(&(pstaxmitpriv->vo_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->vo_q.tx_pending));
 
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
-       rtw_list_delete(&(pstaxmitpriv->vi_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->vi_q.tx_pending));
 
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
-       rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->be_q.tx_pending));
 
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
-       rtw_list_delete(&(pstaxmitpriv->bk_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->bk_q.tx_pending));
 
        /* for BC/MC Frames */
        pstaxmitpriv = &psta_bmc->sta_xmitpriv;
        dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending);
-       rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
+       list_del_init(&(pstaxmitpriv->be_q.tx_pending));
 
        spin_unlock_bh(&pxmitpriv->lock);
 }
 
                xmitframe_plist = xmitframe_plist->next;
 
-               rtw_list_delete(&pxmitframe->list);
+               list_del_init(&pxmitframe->list);
 
                switch (pxmitframe->attrib.priority) {
                case 1:
 
                        xmitframe_plist = xmitframe_plist->next;
 
-                       rtw_list_delete(&pxmitframe->list);
+                       list_del_init(&pxmitframe->list);
 
                        psta_bmc->sleepq_len--;
                        if (psta_bmc->sleepq_len > 0)
                if (!wmmps_ac)
                        continue;
 
-               rtw_list_delete(&pxmitframe->list);
+               list_del_init(&pxmitframe->list);
 
                psta->sleepq_len--;
                psta->sleepq_ac_len--;
 
                        pxmitframe->pkt_offset = 1;
                        break;
                }
-               rtw_list_delete(&pxmitframe->list);
+               list_del_init(&pxmitframe->list);
                ptxservq->qcnt--;
                phwxmit->accnt--;
 
        } /* end while (aggregate same priority and same DA(AP or STA) frames) */
 
        if (_rtw_queue_empty(&ptxservq->sta_pending) == true)
-               rtw_list_delete(&ptxservq->tx_pending);
+               list_del_init(&ptxservq->tx_pending);
 
        spin_unlock_bh(&pxmitpriv->lock);
        if ((pfirstframe->attrib.ether_type != 0x0806) &&
 
        return ret;
 }
 
-static inline void rtw_list_delete(struct list_head *plist)
-{
-       list_del_init(plist);
-}
-
 static inline void _init_timer(struct timer_list *ptimer,
                               struct  net_device *nic_hdl,
                               void *pfunc, void *cntx)
 
 void _rtw_memcpy(void *dec, void *sour, u32 sz);
 
-void rtw_list_delete(struct list_head *plist);
-
 u32  _rtw_down_sema(struct semaphore *sema);
 
 void _rtw_init_queue(struct __queue *pqueue);
 
        if (psta) {
                spin_lock_bh(&pstapriv->asoc_list_lock);
                if (!list_empty(&psta->asoc_list)) {
-                       rtw_list_delete(&psta->asoc_list);
+                       list_del_init(&psta->asoc_list);
                        pstapriv->asoc_list_cnt--;
                        updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
                }