diff options
Diffstat (limited to 'drivers/staging/rtl8188eu/core/rtw_recv.c')
-rw-r--r-- | drivers/staging/rtl8188eu/core/rtw_recv.c | 502 |
1 files changed, 247 insertions, 255 deletions
diff --git a/drivers/staging/rtl8188eu/core/rtw_recv.c b/drivers/staging/rtl8188eu/core/rtw_recv.c index c9c180649c12..636ec553ae83 100644 --- a/drivers/staging/rtl8188eu/core/rtw_recv.c +++ b/drivers/staging/rtl8188eu/core/rtw_recv.c @@ -23,11 +23,12 @@ #include <drv_types.h> #include <recv_osdep.h> #include <mlme_osdep.h> -#include <ip.h> -#include <if_ether.h> -#include <ethernet.h> #include <usb_ops.h> #include <wifi.h> +#include <linux/vmalloc.h> + +#define ETHERNET_HEADER_SIZE 14 /* Ethernet Header Length */ +#define LLC_HEADER_SIZE 6 /* LLC Header Length */ static u8 SNAP_ETH_TYPE_IPX[2] = {0x81, 0x37}; static u8 SNAP_ETH_TYPE_APPLETALK_AARP[2] = {0x80, 0xf3}; @@ -45,7 +46,6 @@ void rtw_signal_stat_timer_hdl(RTW_TIMER_HDL_ARGS); void _rtw_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv) { -_func_enter_; _rtw_memset((u8 *)psta_recvpriv, 0, sizeof (struct sta_recv_priv)); @@ -53,18 +53,16 @@ _func_enter_; _rtw_init_queue(&psta_recvpriv->defrag_q); -_func_exit_; } int _rtw_init_recv_priv(struct recv_priv *precvpriv, struct adapter *padapter) { int i; - union recv_frame *precvframe; + struct recv_frame *precvframe; int res = _SUCCESS; -_func_enter_; spin_lock_init(&precvpriv->lock); _rtw_init_queue(&precvpriv->free_recv_queue); @@ -77,7 +75,7 @@ _func_enter_; rtw_os_recv_resource_init(precvpriv, padapter); - precvpriv->pallocated_frame_buf = rtw_zvmalloc(NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ); + precvpriv->pallocated_frame_buf = vzalloc(NR_RECVFRAME * sizeof(struct recv_frame) + RXFRAME_ALIGN_SZ); if (precvpriv->pallocated_frame_buf == NULL) { res = _FAIL; @@ -86,18 +84,19 @@ _func_enter_; precvpriv->precv_frame_buf = (u8 *)N_BYTE_ALIGMENT((size_t)(precvpriv->pallocated_frame_buf), RXFRAME_ALIGN_SZ); - precvframe = (union recv_frame *)precvpriv->precv_frame_buf; + precvframe = (struct recv_frame *)precvpriv->precv_frame_buf; for (i = 0; i < NR_RECVFRAME; i++) { - _rtw_init_listhead(&(precvframe->u.list)); + _rtw_init_listhead(&(precvframe->list)); - rtw_list_insert_tail(&(precvframe->u.list), &(precvpriv->free_recv_queue.queue)); + rtw_list_insert_tail(&(precvframe->list), + &(precvpriv->free_recv_queue.queue)); res = rtw_os_recv_resource_alloc(padapter, precvframe); - precvframe->u.hdr.len = 0; + precvframe->len = 0; - precvframe->u.hdr.adapter = padapter; + precvframe->adapter = padapter; precvframe++; } precvpriv->rx_pending_cnt = 1; @@ -113,7 +112,6 @@ _func_enter_; rtw_set_signal_stat_timer(precvpriv); exit: -_func_exit_; return res; } @@ -122,40 +120,37 @@ void _rtw_free_recv_priv (struct recv_priv *precvpriv) { struct adapter *padapter = precvpriv->adapter; -_func_enter_; rtw_free_uc_swdec_pending_queue(padapter); rtw_os_recv_resource_free(precvpriv); if (precvpriv->pallocated_frame_buf) { - rtw_vmfree(precvpriv->pallocated_frame_buf, NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ); + vfree(precvpriv->pallocated_frame_buf); } rtw_hal_free_recv_priv(padapter); -_func_exit_; } -union recv_frame *_rtw_alloc_recvframe (struct __queue *pfree_recv_queue) +struct recv_frame *_rtw_alloc_recvframe (struct __queue *pfree_recv_queue) { - union recv_frame *precvframe; + struct recv_frame *hdr; struct list_head *plist, *phead; struct adapter *padapter; struct recv_priv *precvpriv; -_func_enter_; if (_rtw_queue_empty(pfree_recv_queue)) { - precvframe = NULL; + hdr = NULL; } else { phead = get_list_head(pfree_recv_queue); - plist = get_next(phead); + plist = phead->next; - precvframe = LIST_CONTAINOR(plist, union recv_frame, u); + hdr = container_of(plist, struct recv_frame, list); - rtw_list_delete(&precvframe->u.hdr.list); - padapter = precvframe->u.hdr.adapter; + rtw_list_delete(&hdr->list); + padapter = hdr->adapter; if (padapter != NULL) { precvpriv = &padapter->recvpriv; if (pfree_recv_queue == &precvpriv->free_recv_queue) @@ -163,14 +158,13 @@ _func_enter_; } } -_func_exit_; - return precvframe; + return (struct recv_frame *)hdr; } -union recv_frame *rtw_alloc_recvframe (struct __queue *pfree_recv_queue) +struct recv_frame *rtw_alloc_recvframe(struct __queue *pfree_recv_queue) { - union recv_frame *precvframe; + struct recv_frame *precvframe; spin_lock_bh(&pfree_recv_queue->lock); @@ -181,36 +175,36 @@ union recv_frame *rtw_alloc_recvframe (struct __queue *pfree_recv_queue) return precvframe; } -void rtw_init_recvframe(union recv_frame *precvframe, struct recv_priv *precvpriv) +void rtw_init_recvframe(struct recv_frame *precvframe, struct recv_priv *precvpriv) { /* Perry: This can be removed */ - _rtw_init_listhead(&precvframe->u.hdr.list); + _rtw_init_listhead(&precvframe->list); - precvframe->u.hdr.len = 0; + precvframe->len = 0; } -int rtw_free_recvframe(union recv_frame *precvframe, struct __queue *pfree_recv_queue) +int rtw_free_recvframe(struct recv_frame *precvframe, + struct __queue *pfree_recv_queue) { struct adapter *padapter; struct recv_priv *precvpriv; -_func_enter_; if (!precvframe) return _FAIL; - padapter = precvframe->u.hdr.adapter; + padapter = precvframe->adapter; precvpriv = &padapter->recvpriv; - if (precvframe->u.hdr.pkt) { - dev_kfree_skb_any(precvframe->u.hdr.pkt);/* free skb by driver */ - precvframe->u.hdr.pkt = NULL; + if (precvframe->pkt) { + dev_kfree_skb_any(precvframe->pkt);/* free skb by driver */ + precvframe->pkt = NULL; } spin_lock_bh(&pfree_recv_queue->lock); - rtw_list_delete(&(precvframe->u.hdr.list)); + rtw_list_delete(&(precvframe->list)); - precvframe->u.hdr.len = 0; + precvframe->len = 0; - rtw_list_insert_tail(&(precvframe->u.hdr.list), get_list_head(pfree_recv_queue)); + rtw_list_insert_tail(&(precvframe->list), get_list_head(pfree_recv_queue)); if (padapter != NULL) { if (pfree_recv_queue == &precvpriv->free_recv_queue) @@ -219,32 +213,29 @@ _func_enter_; spin_unlock_bh(&pfree_recv_queue->lock); -_func_exit_; return _SUCCESS; } -int _rtw_enqueue_recvframe(union recv_frame *precvframe, struct __queue *queue) +int _rtw_enqueue_recvframe(struct recv_frame *precvframe, struct __queue *queue) { - struct adapter *padapter = precvframe->u.hdr.adapter; + struct adapter *padapter = precvframe->adapter; struct recv_priv *precvpriv = &padapter->recvpriv; -_func_enter_; - rtw_list_delete(&(precvframe->u.hdr.list)); - rtw_list_insert_tail(&(precvframe->u.hdr.list), get_list_head(queue)); + rtw_list_delete(&(precvframe->list)); + rtw_list_insert_tail(&(precvframe->list), get_list_head(queue)); if (padapter != NULL) { if (queue == &precvpriv->free_recv_queue) precvpriv->free_recvframe_cnt++; } -_func_exit_; return _SUCCESS; } -int rtw_enqueue_recvframe(union recv_frame *precvframe, struct __queue *queue) +int rtw_enqueue_recvframe(struct recv_frame *precvframe, struct __queue *queue) { int ret; @@ -265,32 +256,30 @@ using spinlock to protect void rtw_free_recvframe_queue(struct __queue *pframequeue, struct __queue *pfree_recv_queue) { - union recv_frame *precvframe; + struct recv_frame *hdr; struct list_head *plist, *phead; -_func_enter_; spin_lock(&pframequeue->lock); phead = get_list_head(pframequeue); - plist = get_next(phead); + plist = phead->next; while (rtw_end_of_queue_search(phead, plist) == false) { - precvframe = LIST_CONTAINOR(plist, union recv_frame, u); + hdr = container_of(plist, struct recv_frame, list); - plist = get_next(plist); + plist = plist->next; - rtw_free_recvframe(precvframe, pfree_recv_queue); + rtw_free_recvframe((struct recv_frame *)hdr, pfree_recv_queue); } spin_unlock(&pframequeue->lock); -_func_exit_; } u32 rtw_free_uc_swdec_pending_queue(struct adapter *adapter) { u32 cnt = 0; - union recv_frame *pending_frame; + struct recv_frame *pending_frame; while ((pending_frame = rtw_alloc_recvframe(&adapter->recvpriv.uc_swdec_pending_queue))) { rtw_free_recvframe(pending_frame, &adapter->recvpriv.free_recv_queue); DBG_88E("%s: dequeue uc_swdec_pending_queue\n", __func__); @@ -337,9 +326,9 @@ struct recv_buf *rtw_dequeue_recvbuf (struct __queue *queue) } else { phead = get_list_head(queue); - plist = get_next(phead); + plist = phead->next; - precvbuf = LIST_CONTAINOR(plist, struct recv_buf, list); + precvbuf = container_of(plist, struct recv_buf, list); rtw_list_delete(&precvbuf->list); } @@ -349,7 +338,8 @@ struct recv_buf *rtw_dequeue_recvbuf (struct __queue *queue) return precvbuf; } -static int recvframe_chkmic(struct adapter *adapter, union recv_frame *precvframe) +static int recvframe_chkmic(struct adapter *adapter, + struct recv_frame *precvframe) { int i, res = _SUCCESS; u32 datalen; @@ -358,12 +348,11 @@ static int recvframe_chkmic(struct adapter *adapter, union recv_frame *precvfra u8 *pframe, *payload, *pframemic; u8 *mickey; struct sta_info *stainfo; - struct rx_pkt_attrib *prxattrib = &precvframe->u.hdr.attrib; + struct rx_pkt_attrib *prxattrib = &precvframe->attrib; struct security_priv *psecuritypriv = &adapter->securitypriv; struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv; struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); -_func_enter_; stainfo = rtw_get_stainfo(&adapter->stapriv, &prxattrib->ta[0]); @@ -375,23 +364,24 @@ _func_enter_; /* calculate mic code */ if (stainfo != NULL) { if (IS_MCAST(prxattrib->ra)) { - mickey = &psecuritypriv->dot118021XGrprxmickey[prxattrib->key_index].skey[0]; - - RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("\n recvframe_chkmic: bcmc key\n")); - if (!psecuritypriv) { res = _FAIL; RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("\n recvframe_chkmic:didn't install group key!!!!!!!!!!\n")); DBG_88E("\n recvframe_chkmic:didn't install group key!!!!!!!!!!\n"); goto exit; } + mickey = &psecuritypriv->dot118021XGrprxmickey[prxattrib->key_index].skey[0]; + + RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("\n recvframe_chkmic: bcmc key\n")); } else { mickey = &stainfo->dot11tkiprxmickey.skey[0]; RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("\n recvframe_chkmic: unicast key\n")); } - datalen = precvframe->u.hdr.len-prxattrib->hdrlen-prxattrib->iv_len-prxattrib->icv_len-8;/* icv_len included the mic code */ - pframe = precvframe->u.hdr.rx_data; + /* icv_len included the mic code */ + datalen = precvframe->len-prxattrib->hdrlen - + prxattrib->iv_len-prxattrib->icv_len-8; + pframe = precvframe->rx_data; payload = pframe+prxattrib->hdrlen+prxattrib->iv_len; RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("\n prxattrib->iv_len=%d prxattrib->icv_len=%d\n", prxattrib->iv_len, prxattrib->icv_len)); @@ -424,16 +414,30 @@ _func_enter_; *(pframemic-10), *(pframemic-9))); { uint i; - RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("\n ======demp packet (len=%d)======\n", precvframe->u.hdr.len)); - for (i = 0; i < precvframe->u.hdr.len; i = i+8) { - RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x", - *(precvframe->u.hdr.rx_data+i), *(precvframe->u.hdr.rx_data+i+1), - *(precvframe->u.hdr.rx_data+i+2), *(precvframe->u.hdr.rx_data+i+3), - *(precvframe->u.hdr.rx_data+i+4), *(precvframe->u.hdr.rx_data+i+5), - *(precvframe->u.hdr.rx_data+i+6), *(precvframe->u.hdr.rx_data+i+7))); + RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, + ("\n ======demp packet (len=%d)======\n", + precvframe->len)); + for (i = 0; i < precvframe->len; i += 8) { + RT_TRACE(_module_rtl871x_recv_c_, + _drv_err_, + ("0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x", + *(precvframe->rx_data+i), + *(precvframe->rx_data+i+1), + *(precvframe->rx_data+i+2), + *(precvframe->rx_data+i+3), + *(precvframe->rx_data+i+4), + *(precvframe->rx_data+i+5), + *(precvframe->rx_data+i+6), + *(precvframe->rx_data+i+7))); } - RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("\n ====== demp packet end [len=%d]======\n", precvframe->u.hdr.len)); - RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("\n hrdlen=%d,\n", prxattrib->hdrlen)); + RT_TRACE(_module_rtl871x_recv_c_, + _drv_err_, + ("\n ====== demp packet end [len=%d]======\n", + precvframe->len)); + RT_TRACE(_module_rtl871x_recv_c_, + _drv_err_, + ("\n hrdlen=%d,\n", + prxattrib->hdrlen)); } RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, @@ -471,24 +475,23 @@ _func_enter_; exit: -_func_exit_; return res; } /* decrypt and set the ivlen, icvlen of the recv_frame */ -static union recv_frame *decryptor(struct adapter *padapter, union recv_frame *precv_frame) +static struct recv_frame *decryptor(struct adapter *padapter, + struct recv_frame *precv_frame) { - struct rx_pkt_attrib *prxattrib = &precv_frame->u.hdr.attrib; + struct rx_pkt_attrib *prxattrib = &precv_frame->attrib; struct security_priv *psecuritypriv = &padapter->securitypriv; - union recv_frame *return_packet = precv_frame; + struct recv_frame *return_packet = precv_frame; u32 res = _SUCCESS; -_func_enter_; RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("prxstat->decrypted=%x prxattrib->encrypt=0x%03x\n", prxattrib->bdecrypted, prxattrib->encrypt)); if (prxattrib->encrypt > 0) { - u8 *iv = precv_frame->u.hdr.rx_data+prxattrib->hdrlen; + u8 *iv = precv_frame->rx_data+prxattrib->hdrlen; prxattrib->key_index = (((iv[3])>>6)&0x3); if (prxattrib->key_index > WEP_KEYS) { @@ -534,34 +537,33 @@ _func_enter_; return_packet = NULL; } -_func_exit_; return return_packet; } /* set the security information in the recv_frame */ -static union recv_frame *portctrl(struct adapter *adapter, union recv_frame *precv_frame) +static struct recv_frame *portctrl(struct adapter *adapter, + struct recv_frame *precv_frame) { u8 *psta_addr = NULL, *ptr; uint auth_alg; - struct recv_frame_hdr *pfhdr; + struct recv_frame *pfhdr; struct sta_info *psta; struct sta_priv *pstapriv; - union recv_frame *prtnframe; + struct recv_frame *prtnframe; u16 ether_type = 0; u16 eapol_type = 0x888e;/* for Funia BD's WPA issue */ struct rx_pkt_attrib *pattrib; __be16 be_tmp; -_func_enter_; pstapriv = &adapter->stapriv; psta = rtw_get_stainfo(pstapriv, psta_addr); auth_alg = adapter->securitypriv.dot11AuthAlgrthm; - ptr = get_recvframe_data(precv_frame); - pfhdr = &precv_frame->u.hdr; + ptr = precv_frame->rx_data; + pfhdr = precv_frame; pattrib = &pfhdr->attrib; psta_addr = pattrib->ta; @@ -593,7 +595,9 @@ _func_enter_; /* allowed */ /* check decryption status, and decrypt the frame if needed */ RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("########portctrl:psta->ieee8021x_blocked==0\n")); - RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("portctrl:precv_frame->hdr.attrib.privacy=%x\n", precv_frame->u.hdr.attrib.privacy)); + RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, + ("portctrl:precv_frame->hdr.attrib.privacy=%x\n", + precv_frame->attrib.privacy)); if (pattrib->bdecrypted == 0) RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("portctrl:prxstat->decrypted=%x\n", pattrib->bdecrypted)); @@ -613,19 +617,18 @@ _func_enter_; prtnframe = precv_frame; } -_func_exit_; return prtnframe; } -static int recv_decache(union recv_frame *precv_frame, u8 bretry, struct stainfo_rxcache *prxcache) +static int recv_decache(struct recv_frame *precv_frame, u8 bretry, + struct stainfo_rxcache *prxcache) { - int tid = precv_frame->u.hdr.attrib.priority; + int tid = precv_frame->attrib.priority; - u16 seq_ctrl = ((precv_frame->u.hdr.attrib.seq_num&0xffff) << 4) | - (precv_frame->u.hdr.attrib.frag_num & 0xf); + u16 seq_ctrl = ((precv_frame->attrib.seq_num&0xffff) << 4) | + (precv_frame->attrib.frag_num & 0xf); -_func_enter_; if (tid > 15) { RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_, ("recv_decache, (tid>15)! seq_ctrl=0x%x, tid=0x%x\n", seq_ctrl, tid)); @@ -643,18 +646,17 @@ _func_enter_; prxcache->tid_rxseq[tid] = seq_ctrl; -_func_exit_; return _SUCCESS; } -void process_pwrbit_data(struct adapter *padapter, union recv_frame *precv_frame); -void process_pwrbit_data(struct adapter *padapter, union recv_frame *precv_frame) +void process_pwrbit_data(struct adapter *padapter, + struct recv_frame *precv_frame) { #ifdef CONFIG_88EU_AP_MODE unsigned char pwrbit; - u8 *ptr = precv_frame->u.hdr.rx_data; - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + u8 *ptr = precv_frame->rx_data; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; struct sta_priv *pstapriv = &padapter->stapriv; struct sta_info *psta = NULL; @@ -675,10 +677,11 @@ void process_pwrbit_data(struct adapter *padapter, union recv_frame *precv_frame #endif } -static void process_wmmps_data(struct adapter *padapter, union recv_frame *precv_frame) +static void process_wmmps_data(struct adapter *padapter, + struct recv_frame *precv_frame) { #ifdef CONFIG_88EU_AP_MODE - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; struct sta_priv *pstapriv = &padapter->stapriv; struct sta_info *psta = NULL; @@ -730,15 +733,17 @@ static void process_wmmps_data(struct adapter *padapter, union recv_frame *precv #endif } -static void count_rx_stats(struct adapter *padapter, union recv_frame *prframe, struct sta_info *sta) +static void count_rx_stats(struct adapter *padapter, + struct recv_frame *prframe, + struct sta_info *sta) { int sz; struct sta_info *psta = NULL; struct stainfo_stats *pstats = NULL; - struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &prframe->attrib; struct recv_priv *precvpriv = &padapter->recvpriv; - sz = get_recvframe_len(prframe); + sz = prframe->len; precvpriv->rx_bytes += sz; padapter->mlmepriv.LinkDetectInfo.NumRxOkInPeriod++; @@ -749,7 +754,7 @@ static void count_rx_stats(struct adapter *padapter, union recv_frame *prframe, if (sta) psta = sta; else - psta = prframe->u.hdr.psta; + psta = prframe->psta; if (psta) { pstats = &psta->sta_stats; @@ -761,15 +766,16 @@ static void count_rx_stats(struct adapter *padapter, union recv_frame *prframe, int sta2sta_data_frame( struct adapter *adapter, - union recv_frame *precv_frame, + struct recv_frame *precv_frame, struct sta_info **psta ); -int sta2sta_data_frame(struct adapter *adapter, union recv_frame *precv_frame, struct sta_info **psta) +int sta2sta_data_frame(struct adapter *adapter, struct recv_frame *precv_frame, + struct sta_info **psta) { - u8 *ptr = precv_frame->u.hdr.rx_data; + u8 *ptr = precv_frame->rx_data; int ret = _SUCCESS; - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; struct sta_priv *pstapriv = &adapter->stapriv; struct mlme_priv *pmlmepriv = &adapter->mlmepriv; u8 *mybssid = get_bssid(pmlmepriv); @@ -777,25 +783,24 @@ int sta2sta_data_frame(struct adapter *adapter, union recv_frame *precv_frame, s u8 *sta_addr = NULL; int bmcast = IS_MCAST(pattrib->dst); -_func_enter_; if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) || (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) { /* filter packets that SA is myself or multicast or broadcast */ - if (_rtw_memcmp(myhwaddr, pattrib->src, ETH_ALEN)) { + if (!memcmp(myhwaddr, pattrib->src, ETH_ALEN)) { RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, (" SA==myself\n")); ret = _FAIL; goto exit; } - if ((!_rtw_memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) { + if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) { ret = _FAIL; goto exit; } - if (_rtw_memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || - _rtw_memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || - !_rtw_memcmp(pattrib->bssid, mybssid, ETH_ALEN)) { + if (!memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || + !memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || + memcmp(pattrib->bssid, mybssid, ETH_ALEN)) { ret = _FAIL; goto exit; } @@ -803,7 +808,7 @@ _func_enter_; sta_addr = pattrib->src; } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { /* For Station mode, sa and bssid should always be BSSID, and DA is my mac-address */ - if (!_rtw_memcmp(pattrib->bssid, pattrib->src, ETH_ALEN)) { + if (memcmp(pattrib->bssid, pattrib->src, ETH_ALEN)) { RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("bssid!=TA under STATION_MODE; drop pkt\n")); ret = _FAIL; goto exit; @@ -818,7 +823,7 @@ _func_enter_; } } else { /* not mc-frame */ /* For AP mode, if DA is non-MCAST, then it must be BSSID, and bssid == BSSID */ - if (!_rtw_memcmp(pattrib->bssid, pattrib->dst, ETH_ALEN)) { + if (memcmp(pattrib->bssid, pattrib->dst, ETH_ALEN)) { ret = _FAIL; goto exit; } @@ -853,17 +858,16 @@ _func_enter_; } exit: -_func_exit_; return ret; } static int ap2sta_data_frame ( struct adapter *adapter, - union recv_frame *precv_frame, + struct recv_frame *precv_frame, struct sta_info **psta) { - u8 *ptr = precv_frame->u.hdr.rx_data; - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + u8 *ptr = precv_frame->rx_data; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; int ret = _SUCCESS; struct sta_priv *pstapriv = &adapter->stapriv; struct mlme_priv *pmlmepriv = &adapter->mlmepriv; @@ -871,20 +875,19 @@ static int ap2sta_data_frame ( u8 *myhwaddr = myid(&adapter->eeprompriv); int bmcast = IS_MCAST(pattrib->dst); -_func_enter_; if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) && (check_fwstate(pmlmepriv, _FW_LINKED) == true || check_fwstate(pmlmepriv, _FW_UNDER_LINKING))) { /* filter packets that SA is myself or multicast or broadcast */ - if (_rtw_memcmp(myhwaddr, pattrib->src, ETH_ALEN)) { + if (!memcmp(myhwaddr, pattrib->src, ETH_ALEN)) { RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, (" SA==myself\n")); ret = _FAIL; goto exit; } /* da should be for me */ - if ((!_rtw_memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) { + if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) { RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, (" ap2sta_data_frame: compare DA fail; DA=%pM\n", (pattrib->dst))); ret = _FAIL; @@ -892,9 +895,9 @@ _func_enter_; } /* check BSSID */ - if (_rtw_memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || - _rtw_memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || - (!_rtw_memcmp(pattrib->bssid, mybssid, ETH_ALEN))) { + if (!memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || + !memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) || + (memcmp(pattrib->bssid, mybssid, ETH_ALEN))) { RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, (" ap2sta_data_frame: compare BSSID fail ; BSSID=%pM\n", (pattrib->bssid))); RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("mybssid=%pM\n", (mybssid))); @@ -950,7 +953,7 @@ _func_enter_; ret = RTW_RX_HANDLED; goto exit; } else { - if (_rtw_memcmp(myhwaddr, pattrib->dst, ETH_ALEN) && (!bmcast)) { + if (!memcmp(myhwaddr, pattrib->dst, ETH_ALEN) && (!bmcast)) { *psta = rtw_get_stainfo(pstapriv, pattrib->bssid); /* get sta_info */ if (*psta == NULL) { DBG_88E("issue_deauth to the ap =%pM for the reason(7)\n", (pattrib->bssid)); @@ -964,27 +967,25 @@ _func_enter_; exit: -_func_exit_; return ret; } static int sta2ap_data_frame(struct adapter *adapter, - union recv_frame *precv_frame, + struct recv_frame *precv_frame, struct sta_info **psta) { - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; struct sta_priv *pstapriv = &adapter->stapriv; struct mlme_priv *pmlmepriv = &adapter->mlmepriv; - u8 *ptr = precv_frame->u.hdr.rx_data; + u8 *ptr = precv_frame->rx_data; unsigned char *mybssid = get_bssid(pmlmepriv); int ret = _SUCCESS; -_func_enter_; if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) { /* For AP mode, RA = BSSID, TX = STA(SRC_ADDR), A3 = DST_ADDR */ - if (!_rtw_memcmp(pattrib->bssid, mybssid, ETH_ALEN)) { + if (memcmp(pattrib->bssid, mybssid, ETH_ALEN)) { ret = _FAIL; goto exit; } @@ -1014,7 +1015,7 @@ _func_enter_; } } else { u8 *myhwaddr = myid(&adapter->eeprompriv); - if (!_rtw_memcmp(pattrib->ra, myhwaddr, ETH_ALEN)) { + if (memcmp(pattrib->ra, myhwaddr, ETH_ALEN)) { ret = RTW_RX_HANDLED; goto exit; } @@ -1026,25 +1027,23 @@ _func_enter_; exit: -_func_exit_; return ret; } static int validate_recv_ctrl_frame(struct adapter *padapter, - union recv_frame *precv_frame) + struct recv_frame *precv_frame) { #ifdef CONFIG_88EU_AP_MODE - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; struct sta_priv *pstapriv = &padapter->stapriv; - u8 *pframe = precv_frame->u.hdr.rx_data; - /* uint len = precv_frame->u.hdr.len; */ + u8 *pframe = precv_frame->rx_data; if (GetFrameType(pframe) != WIFI_CTRL_TYPE) return _FAIL; /* receive the frames that ra(a1) is my address */ - if (!_rtw_memcmp(GetAddr1Ptr(pframe), myid(&padapter->eeprompriv), ETH_ALEN)) + if (memcmp(GetAddr1Ptr(pframe), myid(&padapter->eeprompriv), ETH_ALEN)) return _FAIL; /* only handle ps-poll */ @@ -1098,12 +1097,12 @@ static int validate_recv_ctrl_frame(struct adapter *padapter, spin_lock_bh(&psta->sleep_q.lock); xmitframe_phead = get_list_head(&psta->sleep_q); - xmitframe_plist = get_next(xmitframe_phead); + xmitframe_plist = xmitframe_phead->next; if ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == false) { - pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list); + pxmitframe = container_of(xmitframe_plist, struct xmit_frame, list); - xmitframe_plist = get_next(xmitframe_plist); + xmitframe_plist = xmitframe_plist->next; rtw_list_delete(&pxmitframe->list); @@ -1124,7 +1123,7 @@ static int validate_recv_ctrl_frame(struct adapter *padapter, if (psta->sleepq_len == 0) { pstapriv->tim_bitmap &= ~BIT(psta->aid); - /* upate BCN for TIM IE */ + /* update BCN for TIM IE */ /* update_BCNTIM(padapter); */ update_beacon(padapter, _TIM_IE_, NULL, false); } @@ -1142,7 +1141,7 @@ static int validate_recv_ctrl_frame(struct adapter *padapter, pstapriv->tim_bitmap &= ~BIT(psta->aid); - /* upate BCN for TIM IE */ + /* update BCN for TIM IE */ /* update_BCNTIM(padapter); */ update_beacon(padapter, _TIM_IE_, NULL, false); } @@ -1157,10 +1156,11 @@ static int validate_recv_ctrl_frame(struct adapter *padapter, return _FAIL; } -union recv_frame *recvframe_chk_defrag(struct adapter *padapter, union recv_frame *precv_frame); +struct recv_frame *recvframe_chk_defrag(struct adapter *padapter, + struct recv_frame *precv_frame); static int validate_recv_mgnt_frame(struct adapter *padapter, - union recv_frame *precv_frame) + struct recv_frame *precv_frame) { struct sta_info *psta; @@ -1173,18 +1173,20 @@ static int validate_recv_mgnt_frame(struct adapter *padapter, } /* for rx pkt statistics */ - psta = rtw_get_stainfo(&padapter->stapriv, GetAddr2Ptr(precv_frame->u.hdr.rx_data)); + psta = rtw_get_stainfo(&padapter->stapriv, + GetAddr2Ptr(precv_frame->rx_data)); if (psta) { psta->sta_stats.rx_mgnt_pkts++; - if (GetFrameSubType(precv_frame->u.hdr.rx_data) == WIFI_BEACON) { + if (GetFrameSubType(precv_frame->rx_data) == WIFI_BEACON) { psta->sta_stats.rx_beacon_pkts++; - } else if (GetFrameSubType(precv_frame->u.hdr.rx_data) == WIFI_PROBEREQ) { + } else if (GetFrameSubType(precv_frame->rx_data) == WIFI_PROBEREQ) { psta->sta_stats.rx_probereq_pkts++; - } else if (GetFrameSubType(precv_frame->u.hdr.rx_data) == WIFI_PROBERSP) { - if (_rtw_memcmp(padapter->eeprompriv.mac_addr, GetAddr1Ptr(precv_frame->u.hdr.rx_data), ETH_ALEN) == true) + } else if (GetFrameSubType(precv_frame->rx_data) == WIFI_PROBERSP) { + if (!memcmp(padapter->eeprompriv.mac_addr, + GetAddr1Ptr(precv_frame->rx_data), ETH_ALEN)) psta->sta_stats.rx_probersp_pkts++; - else if (is_broadcast_mac_addr(GetAddr1Ptr(precv_frame->u.hdr.rx_data)) || - is_multicast_mac_addr(GetAddr1Ptr(precv_frame->u.hdr.rx_data))) + else if (is_broadcast_mac_addr(GetAddr1Ptr(precv_frame->rx_data)) || + is_multicast_mac_addr(GetAddr1Ptr(precv_frame->rx_data))) psta->sta_stats.rx_probersp_bm_pkts++; else psta->sta_stats.rx_probersp_uo_pkts++; @@ -1197,17 +1199,16 @@ static int validate_recv_mgnt_frame(struct adapter *padapter, } static int validate_recv_data_frame(struct adapter *adapter, - union recv_frame *precv_frame) + struct recv_frame *precv_frame) { u8 bretry; u8 *psa, *pda, *pbssid; struct sta_info *psta = NULL; - u8 *ptr = precv_frame->u.hdr.rx_data; - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; + u8 *ptr = precv_frame->rx_data; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; struct security_priv *psecuritypriv = &adapter->securitypriv; int ret = _SUCCESS; -_func_enter_; bretry = GetRetry(ptr); pda = get_da(ptr); @@ -1265,7 +1266,7 @@ _func_enter_; /* psta->rssi = prxcmd->rssi; */ /* psta->signal_quality = prxcmd->sq; */ - precv_frame->u.hdr.psta = psta; + precv_frame->psta = psta; pattrib->amsdu = 0; pattrib->ack_policy = 0; @@ -1286,7 +1287,7 @@ _func_enter_; if (pattrib->order)/* HT-CTRL 11n */ pattrib->hdrlen += 4; - precv_frame->u.hdr.preorder_ctrl = &psta->recvreorder_ctrl[pattrib->priority]; + precv_frame->preorder_ctrl = &psta->recvreorder_ctrl[pattrib->priority]; /* decache, drop duplicate recv packets */ if (recv_decache(precv_frame, bretry, &psta->sta_recvpriv.rxcache) == _FAIL) { @@ -1312,12 +1313,12 @@ _func_enter_; exit: -_func_exit_; return ret; } -static int validate_recv_frame(struct adapter *adapter, union recv_frame *precv_frame) +static int validate_recv_frame(struct adapter *adapter, + struct recv_frame *precv_frame) { /* shall check frame subtype, to / from ds, da, bssid */ @@ -1327,12 +1328,11 @@ static int validate_recv_frame(struct adapter *adapter, union recv_frame *precv_ u8 subtype; int retval = _SUCCESS; u8 bDumpRxPkt; - struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib; - u8 *ptr = precv_frame->u.hdr.rx_data; + struct rx_pkt_attrib *pattrib = &precv_frame->attrib; + u8 *ptr = precv_frame->rx_data; u8 ver = (unsigned char) (*ptr)&0x3; struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv; -_func_enter_; if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) { int ch_set_idx = rtw_ch_set_search_ch(pmlmeext->channel_set, rtw_get_oper_ch(adapter)); @@ -1422,14 +1422,13 @@ _func_enter_; exit: -_func_exit_; return retval; } /* remove the wlanhdr and add the eth_hdr */ -static int wlanhdr_to_ethhdr (union recv_frame *precvframe) +static int wlanhdr_to_ethhdr(struct recv_frame *precvframe) { int rmv_len; u16 eth_type, len; @@ -1439,13 +1438,10 @@ static int wlanhdr_to_ethhdr (union recv_frame *precvframe) struct ieee80211_snap_hdr *psnap; int ret = _SUCCESS; - struct adapter *adapter = precvframe->u.hdr.adapter; + struct adapter *adapter = precvframe->adapter; struct mlme_priv *pmlmepriv = &adapter->mlmepriv; - - u8 *ptr = get_recvframe_data(precvframe); /* point to frame_ctrl field */ - struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib; - -_func_enter_; + u8 *ptr = precvframe->rx_data; + struct rx_pkt_attrib *pattrib = &precvframe->attrib; if (pattrib->encrypt) recvframe_pull_tail(precvframe, pattrib->icv_len); @@ -1453,10 +1449,10 @@ _func_enter_; psnap = (struct ieee80211_snap_hdr *)(ptr+pattrib->hdrlen + pattrib->iv_len); psnap_type = ptr+pattrib->hdrlen + pattrib->iv_len+SNAP_SIZE; /* convert hdr + possible LLC headers into Ethernet header */ - if ((_rtw_memcmp(psnap, rtw_rfc1042_header, SNAP_SIZE) && - (_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_IPX, 2) == false) && - (_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_APPLETALK_AARP, 2) == false)) || - _rtw_memcmp(psnap, rtw_bridge_tunnel_header, SNAP_SIZE)) { + if ((!memcmp(psnap, rtw_rfc1042_header, SNAP_SIZE) && + (!memcmp(psnap_type, SNAP_ETH_TYPE_IPX, 2) == false) && + (!memcmp(psnap_type, SNAP_ETH_TYPE_APPLETALK_AARP, 2) == false)) || + !memcmp(psnap, rtw_bridge_tunnel_header, SNAP_SIZE)) { /* remove RFC1042 or Bridge-Tunnel encapsulation and replace EtherType */ bsnaphdr = true; } else { @@ -1465,7 +1461,7 @@ _func_enter_; } rmv_len = pattrib->hdrlen + pattrib->iv_len + (bsnaphdr ? SNAP_SIZE : 0); - len = precvframe->u.hdr.len - rmv_len; + len = precvframe->len - rmv_len; RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("\n===pattrib->hdrlen: %x, pattrib->iv_len:%x===\n\n", pattrib->hdrlen, pattrib->iv_len)); @@ -1496,30 +1492,29 @@ _func_enter_; memcpy(ptr+12, &be_tmp, 2); } -_func_exit_; return ret; } /* perform defrag */ -static union recv_frame *recvframe_defrag(struct adapter *adapter, struct __queue *defrag_q) +static struct recv_frame *recvframe_defrag(struct adapter *adapter, + struct __queue *defrag_q) { struct list_head *plist, *phead; u8 wlanhdr_offset; u8 curfragnum; - struct recv_frame_hdr *pfhdr, *pnfhdr; - union recv_frame *prframe, *pnextrframe; + struct recv_frame *pfhdr, *pnfhdr; + struct recv_frame *prframe, *pnextrframe; struct __queue *pfree_recv_queue; -_func_enter_; curfragnum = 0; pfree_recv_queue = &adapter->recvpriv.free_recv_queue; phead = get_list_head(defrag_q); - plist = get_next(phead); - prframe = LIST_CONTAINOR(plist, union recv_frame, u); - pfhdr = &prframe->u.hdr; - rtw_list_delete(&(prframe->u.list)); + plist = phead->next; + pfhdr = container_of(plist, struct recv_frame, list); + prframe = (struct recv_frame *)pfhdr; + rtw_list_delete(&(prframe->list)); if (curfragnum != pfhdr->attrib.frag_num) { /* the first fragment number must be 0 */ @@ -1534,11 +1529,11 @@ _func_enter_; plist = get_list_head(defrag_q); - plist = get_next(plist); + plist = plist->next; while (rtw_end_of_queue_search(phead, plist) == false) { - pnextrframe = LIST_CONTAINOR(plist, union recv_frame , u); - pnfhdr = &pnextrframe->u.hdr; + pnfhdr = container_of(plist, struct recv_frame, list); + pnextrframe = (struct recv_frame *)pnfhdr; /* check the fragment sequence (2nd ~n fragment frame) */ @@ -1568,7 +1563,7 @@ _func_enter_; recvframe_put(prframe, pnfhdr->len); pfhdr->attrib.icv_len = pnfhdr->attrib.icv_len; - plist = get_next(plist); + plist = plist->next; } /* free the defrag_q queue and return the prframe */ @@ -1576,29 +1571,28 @@ _func_enter_; RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("Performance defrag!!!!!\n")); -_func_exit_; return prframe; } /* check if need to defrag, if needed queue the frame to defrag_q */ -union recv_frame *recvframe_chk_defrag(struct adapter *padapter, union recv_frame *precv_frame) +struct recv_frame *recvframe_chk_defrag(struct adapter *padapter, + struct recv_frame *precv_frame) { u8 ismfrag; u8 fragnum; u8 *psta_addr; - struct recv_frame_hdr *pfhdr; + struct recv_frame *pfhdr; struct sta_info *psta; struct sta_priv *pstapriv; struct list_head *phead; - union recv_frame *prtnframe = NULL; + struct recv_frame *prtnframe = NULL; struct __queue *pfree_recv_queue, *pdefrag_q; -_func_enter_; pstapriv = &padapter->stapriv; - pfhdr = &precv_frame->u.hdr; + pfhdr = precv_frame; pfree_recv_queue = &padapter->recvpriv.free_recv_queue; @@ -1670,7 +1664,7 @@ _func_enter_; } } - if ((prtnframe != NULL) && (prtnframe->u.hdr.attrib.privacy)) { + if ((prtnframe != NULL) && (prtnframe->attrib.privacy)) { /* after defrag we must check tkip mic code */ if (recvframe_chkmic(padapter, prtnframe) == _FAIL) { RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("recvframe_chkmic(padapter, prtnframe)==_FAIL\n")); @@ -1679,12 +1673,11 @@ _func_enter_; } } -_func_exit_; return prtnframe; } -static int amsdu_to_msdu(struct adapter *padapter, union recv_frame *prframe) +static int amsdu_to_msdu(struct adapter *padapter, struct recv_frame *prframe) { int a_len, padding_len; u16 eth_type, nSubframe_Length; @@ -1698,16 +1691,16 @@ static int amsdu_to_msdu(struct adapter *padapter, union recv_frame *prframe) int ret = _SUCCESS; nr_subframes = 0; - pattrib = &prframe->u.hdr.attrib; + pattrib = &prframe->attrib; - recvframe_pull(prframe, prframe->u.hdr.attrib.hdrlen); + recvframe_pull(prframe, prframe->attrib.hdrlen); - if (prframe->u.hdr.attrib.iv_len > 0) - recvframe_pull(prframe, prframe->u.hdr.attrib.iv_len); + if (prframe->attrib.iv_len > 0) + recvframe_pull(prframe, prframe->attrib.iv_len); - a_len = prframe->u.hdr.len; + a_len = prframe->len; - pdata = prframe->u.hdr.rx_data; + pdata = prframe->rx_data; while (a_len > ETH_HLEN) { /* Offset 12 denote 2 mac address */ @@ -1729,7 +1722,7 @@ static int amsdu_to_msdu(struct adapter *padapter, union recv_frame *prframe) data_ptr = (u8 *)skb_put(sub_skb, nSubframe_Length); memcpy(data_ptr, pdata, nSubframe_Length); } else { - sub_skb = skb_clone(prframe->u.hdr.pkt, GFP_ATOMIC); + sub_skb = skb_clone(prframe->pkt, GFP_ATOMIC); if (sub_skb) { sub_skb->data = pdata; sub_skb->len = nSubframe_Length; @@ -1768,9 +1761,9 @@ static int amsdu_to_msdu(struct adapter *padapter, union recv_frame *prframe) /* convert hdr + possible LLC headers into Ethernet header */ eth_type = RTW_GET_BE16(&sub_skb->data[6]); if (sub_skb->len >= 8 && - ((_rtw_memcmp(sub_skb->data, rtw_rfc1042_header, SNAP_SIZE) && + ((!memcmp(sub_skb->data, rtw_rfc1042_header, SNAP_SIZE) && eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) || - _rtw_memcmp(sub_skb->data, rtw_bridge_tunnel_header, SNAP_SIZE))) { + !memcmp(sub_skb->data, rtw_bridge_tunnel_header, SNAP_SIZE))) { /* remove RFC1042 or Bridge-Tunnel encapsulation and replace EtherType */ skb_pull(sub_skb, SNAP_SIZE); memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->src, ETH_ALEN); @@ -1796,7 +1789,7 @@ static int amsdu_to_msdu(struct adapter *padapter, union recv_frame *prframe) exit: - prframe->u.hdr.len = 0; + prframe->len = 0; rtw_free_recvframe(prframe, pfree_recv_queue);/* free this recv_frame */ return ret; @@ -1832,70 +1825,72 @@ static int check_indicate_seq(struct recv_reorder_ctrl *preorder_ctrl, u16 seq_n return true; } -int enqueue_reorder_recvframe(struct recv_reorder_ctrl *preorder_ctrl, union recv_frame *prframe); -int enqueue_reorder_recvframe(struct recv_reorder_ctrl *preorder_ctrl, union recv_frame *prframe) +int enqueue_reorder_recvframe(struct recv_reorder_ctrl *preorder_ctrl, + struct recv_frame *prframe) { - struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &prframe->attrib; struct __queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue; struct list_head *phead, *plist; - union recv_frame *pnextrframe; + struct recv_frame *hdr; struct rx_pkt_attrib *pnextattrib; phead = get_list_head(ppending_recvframe_queue); - plist = get_next(phead); + plist = phead->next; while (rtw_end_of_queue_search(phead, plist) == false) { - pnextrframe = LIST_CONTAINOR(plist, union recv_frame, u); - pnextattrib = &pnextrframe->u.hdr.attrib; + hdr = container_of(plist, struct recv_frame, list); + pnextattrib = &hdr->attrib; if (SN_LESS(pnextattrib->seq_num, pattrib->seq_num)) - plist = get_next(plist); + plist = plist->next; else if (SN_EQUAL(pnextattrib->seq_num, pattrib->seq_num)) return false; else break; } - rtw_list_delete(&(prframe->u.hdr.list)); + rtw_list_delete(&(prframe->list)); - rtw_list_insert_tail(&(prframe->u.hdr.list), plist); + rtw_list_insert_tail(&(prframe->list), plist); return true; } static int recv_indicatepkts_in_order(struct adapter *padapter, struct recv_reorder_ctrl *preorder_ctrl, int bforced) { struct list_head *phead, *plist; - union recv_frame *prframe; + struct recv_frame *prframe; + struct recv_frame *prhdr; struct rx_pkt_attrib *pattrib; int bPktInBuf = false; struct recv_priv *precvpriv = &padapter->recvpriv; struct __queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue; phead = get_list_head(ppending_recvframe_queue); - plist = get_next(phead); + plist = phead->next; /* Handling some condition for forced indicate case. */ if (bforced) { if (rtw_is_list_empty(phead)) return true; - prframe = LIST_CONTAINOR(plist, union recv_frame, u); - pattrib = &prframe->u.hdr.attrib; + prhdr = container_of(plist, struct recv_frame, list); + pattrib = &prhdr->attrib; preorder_ctrl->indicate_seq = pattrib->seq_num; } /* Prepare indication list and indication. */ /* Check if there is any packet need indicate. */ while (!rtw_is_list_empty(phead)) { - prframe = LIST_CONTAINOR(plist, union recv_frame, u); - pattrib = &prframe->u.hdr.attrib; + prhdr = container_of(plist, struct recv_frame, list); + prframe = (struct recv_frame *)prhdr; + pattrib = &prframe->attrib; if (!SN_LESS(preorder_ctrl->indicate_seq, pattrib->seq_num)) { RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_, ("recv_indicatepkts_in_order: indicate=%d seq=%d amsdu=%d\n", preorder_ctrl->indicate_seq, pattrib->seq_num, pattrib->amsdu)); - plist = get_next(plist); - rtw_list_delete(&(prframe->u.hdr.list)); + plist = plist->next; + rtw_list_delete(&(prframe->list)); if (SN_EQUAL(preorder_ctrl->indicate_seq, pattrib->seq_num)) preorder_ctrl->indicate_seq = (preorder_ctrl->indicate_seq + 1) & 0xFFF; @@ -1924,11 +1919,12 @@ static int recv_indicatepkts_in_order(struct adapter *padapter, struct recv_reor return bPktInBuf; } -static int recv_indicatepkt_reorder(struct adapter *padapter, union recv_frame *prframe) +static int recv_indicatepkt_reorder(struct adapter *padapter, + struct recv_frame *prframe) { int retval = _SUCCESS; - struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib; - struct recv_reorder_ctrl *preorder_ctrl = prframe->u.hdr.preorder_ctrl; + struct rx_pkt_attrib *pattrib = &prframe->attrib; + struct recv_reorder_ctrl *preorder_ctrl = prframe->preorder_ctrl; struct __queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue; if (!pattrib->amsdu) { @@ -2001,7 +1997,7 @@ static int recv_indicatepkt_reorder(struct adapter *padapter, union recv_frame * spin_unlock_bh(&ppending_recvframe_queue->lock); } else { spin_unlock_bh(&ppending_recvframe_queue->lock); - _cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer); + del_timer_sync(&preorder_ctrl->reordering_ctrl_timer); } _success_exit: @@ -2032,17 +2028,14 @@ void rtw_reordering_ctrl_timeout_handler(void *pcontext) spin_unlock_bh(&ppending_recvframe_queue->lock); } -static int process_recv_indicatepkts(struct adapter *padapter, union recv_frame *prframe) +static int process_recv_indicatepkts(struct adapter *padapter, + struct recv_frame *prframe) { int retval = _SUCCESS; - /* struct recv_priv *precvpriv = &padapter->recvpriv; */ - /* struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib; */ struct mlme_priv *pmlmepriv = &padapter->mlmepriv; struct ht_priv *phtpriv = &pmlmepriv->htpriv; if (phtpriv->ht_option) { /* B/G/N Mode */ - /* prframe->u.hdr.preorder_ctrl = &precvpriv->recvreorder_ctrl[pattrib->priority]; */ - if (recv_indicatepkt_reorder(padapter, prframe) != _SUCCESS) { /* including perform A-MPDU Rx Ordering Buffer Control */ if ((!padapter->bDriverStopped) && @@ -2075,10 +2068,11 @@ static int process_recv_indicatepkts(struct adapter *padapter, union recv_frame return retval; } -static int recv_func_prehandle(struct adapter *padapter, union recv_frame *rframe) +static int recv_func_prehandle(struct adapter *padapter, + struct recv_frame *rframe) { int ret = _SUCCESS; - struct rx_pkt_attrib *pattrib = &rframe->u.hdr.attrib; + struct rx_pkt_attrib *pattrib = &rframe->attrib; struct __queue *pfree_recv_queue = &padapter->recvpriv.free_recv_queue; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; @@ -2110,10 +2104,11 @@ exit: return ret; } -static int recv_func_posthandle(struct adapter *padapter, union recv_frame *prframe) +static int recv_func_posthandle(struct adapter *padapter, + struct recv_frame *prframe) { int ret = _SUCCESS; - union recv_frame *orig_prframe = prframe; + struct recv_frame *orig_prframe = prframe; struct recv_priv *precvpriv = &padapter->recvpriv; struct __queue *pfree_recv_queue = &padapter->recvpriv.free_recv_queue; @@ -2155,16 +2150,16 @@ _recv_data_drop: return ret; } -static int recv_func(struct adapter *padapter, union recv_frame *rframe) +static int recv_func(struct adapter *padapter, struct recv_frame *rframe) { int ret; - struct rx_pkt_attrib *prxattrib = &rframe->u.hdr.attrib; + struct rx_pkt_attrib *prxattrib = &rframe->attrib; struct security_priv *psecuritypriv = &padapter->securitypriv; struct mlme_priv *mlmepriv = &padapter->mlmepriv; /* check if need to handle uc_swdec_pending_queue*/ if (check_fwstate(mlmepriv, WIFI_STATION_STATE) && psecuritypriv->busetkipkey) { - union recv_frame *pending_frame; + struct recv_frame *pending_frame; while ((pending_frame = rtw_alloc_recvframe(&padapter->recvpriv.uc_swdec_pending_queue))) { if (recv_func_posthandle(padapter, pending_frame) == _SUCCESS) @@ -2193,15 +2188,14 @@ exit: return ret; } -s32 rtw_recv_entry(union recv_frame *precvframe) +s32 rtw_recv_entry(struct recv_frame *precvframe) { struct adapter *padapter; struct recv_priv *precvpriv; s32 ret = _SUCCESS; -_func_enter_; - padapter = precvframe->u.hdr.adapter; + padapter = precvframe->adapter; precvpriv = &padapter->recvpriv; @@ -2213,7 +2207,6 @@ _func_enter_; precvpriv->rx_pkts++; -_func_exit_; return ret; @@ -2222,7 +2215,6 @@ _recv_entry_drop: if (padapter->registrypriv.mp_mode == 1) padapter->mppriv.rx_pktloss = precvpriv->rx_drop; -_func_exit_; return ret; } @@ -2244,13 +2236,13 @@ void rtw_signal_stat_timer_hdl(RTW_TIMER_HDL_ARGS) } else { if (recvpriv->signal_strength_data.update_req == 0) {/* update_req is clear, means we got rx */ avg_signal_strength = recvpriv->signal_strength_data.avg_val; - /* after avg_vals are accquired, we can re-stat the signal values */ + /* after avg_vals are acquired, we can re-stat the signal values */ recvpriv->signal_strength_data.update_req = 1; } if (recvpriv->signal_qual_data.update_req == 0) {/* update_req is clear, means we got rx */ avg_signal_qual = recvpriv->signal_qual_data.avg_val; - /* after avg_vals are accquired, we can re-stat the signal values */ + /* after avg_vals are acquired, we can re-stat the signal values */ recvpriv->signal_qual_data.update_req = 1; } |