#include <recv_osdep.h>
#include <mlme_osdep.h>
#include <ip.h>
-#include <if_ether.h>
+#include <linux/if_ether.h>
#include <ethernet.h>
-
-#ifdef CONFIG_USB_HCI
#include <usb_ops.h>
-#endif
-
+#include <linux/ieee80211.h>
#include <wifi.h>
#include <circ_buf.h>
memset((u8 *)psta_recvpriv, 0, sizeof (struct sta_recv_priv));
- _rtw_spinlock_init(&psta_recvpriv->lock);
+ spin_lock_init(&psta_recvpriv->lock);
/* for(i=0; i<MAX_RX_NUMBLKS; i++) */
/* _rtw_init_queue(&psta_recvpriv->blk_strms[i]); */
_func_exit_;
}
-sint _rtw_init_recv_priv(struct recv_priv *precvpriv, _adapter *padapter)
+int _rtw_init_recv_priv(struct recv_priv *precvpriv, _adapter *padapter)
{
- sint i;
+ int i;
union recv_frame *precvframe;
- sint res=_SUCCESS;
+ int res=_SUCCESS;
_func_enter_;
/* We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc(). */
/* memset((unsigned char *)precvpriv, 0, sizeof (struct recv_priv)); */
- _rtw_spinlock_init(&precvpriv->lock);
+ spin_lock_init(&precvpriv->lock);
_rtw_init_queue(&precvpriv->free_recv_queue);
_rtw_init_queue(&precvpriv->recv_pending_queue);
}
/* memset(precvpriv->pallocated_frame_buf, 0, NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ); */
- precvpriv->precv_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(precvpriv->pallocated_frame_buf), RXFRAME_ALIGN_SZ);
- /* precvpriv->precv_frame_buf = precvpriv->pallocated_frame_buf + RXFRAME_ALIGN_SZ - */
- /* ((SIZE_PTR) (precvpriv->pallocated_frame_buf) &(RXFRAME_ALIGN_SZ-1)); */
+ precvpriv->precv_frame_buf = PTR_ALIGN(precvpriv->pallocated_frame_buf, RXFRAME_ALIGN_SZ);
precvframe = (union recv_frame*) precvpriv->precv_frame_buf;
}
-#ifdef CONFIG_USB_HCI
-
precvpriv->rx_pending_cnt=1;
- _rtw_init_sema(&precvpriv->allrxreturnevt, 0);
-
-#endif
+ sema_init(&precvpriv->allrxreturnevt, 0);
res = rtw_hal_init_recv_priv(padapter);
return res;
}
-void rtw_mfree_recv_priv_lock(struct recv_priv *precvpriv);
-void rtw_mfree_recv_priv_lock(struct recv_priv *precvpriv)
-{
- _rtw_spinlock_free(&precvpriv->lock);
-#ifdef CONFIG_RECV_THREAD_MODE
- _rtw_free_sema(&precvpriv->recv_sema);
- _rtw_free_sema(&precvpriv->terminate_recvthread_sema);
-#endif
-
- _rtw_spinlock_free(&precvpriv->free_recv_queue.lock);
- _rtw_spinlock_free(&precvpriv->recv_pending_queue.lock);
-
- _rtw_spinlock_free(&precvpriv->free_recv_buf_queue.lock);
-
-#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
- _rtw_spinlock_free(&precvpriv->recv_buf_pending_queue.lock);
-#endif /* CONFIG_USE_USB_BUFFER_ALLOC_RX */
-}
-
void _rtw_free_recv_priv (struct recv_priv *precvpriv)
{
_adapter *padapter = precvpriv->adapter;
rtw_free_uc_swdec_pending_queue(padapter);
- rtw_mfree_recv_priv_lock(precvpriv);
-
rtw_os_recv_resource_free(precvpriv);
if(precvpriv->pallocated_frame_buf) {
_irqL irqL;
union recv_frame *precvframe;
- _enter_critical_bh(&pfree_recv_queue->lock, &irqL);
+ spin_lock_bh(&pfree_recv_queue->lock);
precvframe = _rtw_alloc_recvframe(pfree_recv_queue);
- _exit_critical_bh(&pfree_recv_queue->lock, &irqL);
+ spin_unlock_bh(&pfree_recv_queue->lock);
return precvframe;
}
precvframe->u.hdr.pkt = NULL;
}
- _enter_critical_bh(&pfree_recv_queue->lock, &irqL);
+ spin_lock_bh(&pfree_recv_queue->lock);
rtw_list_delete(&(precvframe->u.hdr.list));
precvpriv->free_recvframe_cnt++;
}
- _exit_critical_bh(&pfree_recv_queue->lock, &irqL);
+ spin_unlock_bh(&pfree_recv_queue->lock);
_func_exit_;
return _SUCCESS;
}
-sint _rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
+int _rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
{
_adapter *padapter=precvframe->u.hdr.adapter;
return _SUCCESS;
}
-sint rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
+int rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
{
- sint ret;
+ int ret;
_irqL irqL;
/* _spinlock(&pfree_recv_queue->lock); */
- _enter_critical_bh(&queue->lock, &irqL);
+ spin_lock_bh(&queue->lock);
ret = _rtw_enqueue_recvframe(precvframe, queue);
- /* _rtw_spinunlock(&pfree_recv_queue->lock); */
- _exit_critical_bh(&queue->lock, &irqL);
+ /* spin_unlock(&pfree_recv_queue->lock); */
+ spin_unlock_bh(&queue->lock);
return ret;
}
/*
-sint rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
+int rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
{
return rtw_free_recvframe(precvframe, queue);
}
_list *plist, *phead;
_func_enter_;
- _rtw_spinlock(&pframequeue->lock);
+ spin_lock(&pframequeue->lock);
phead = get_list_head(pframequeue);
plist = get_next(phead);
rtw_free_recvframe(precvframe, pfree_recv_queue);
}
- _rtw_spinunlock(&pframequeue->lock);
+ spin_unlock(&pframequeue->lock);
_func_exit_;
}
return cnt;
}
-sint rtw_enqueue_recvbuf_to_head(struct recv_buf *precvbuf, _queue *queue)
+int rtw_enqueue_recvbuf_to_head(struct recv_buf *precvbuf, _queue *queue)
{
_irqL irqL;
- _enter_critical_bh(&queue->lock, &irqL);
+ spin_lock_bh(&queue->lock);
rtw_list_delete(&precvbuf->list);
rtw_list_insert_head(&precvbuf->list, get_list_head(queue));
- _exit_critical_bh(&queue->lock, &irqL);
+ spin_unlock_bh(&queue->lock);
return _SUCCESS;
}
-sint rtw_enqueue_recvbuf(struct recv_buf *precvbuf, _queue *queue)
+int rtw_enqueue_recvbuf(struct recv_buf *precvbuf, _queue *queue)
{
_irqL irqL;
-#ifdef CONFIG_SDIO_HCI
- _enter_critical_bh(&queue->lock, &irqL);
-#else
- _enter_critical_ex(&queue->lock, &irqL);
-#endif/*#ifdef CONFIG_SDIO_HCI*/
+ spin_lock_irqsave(&queue->lock, irqL);
rtw_list_delete(&precvbuf->list);
rtw_list_insert_tail(&precvbuf->list, get_list_head(queue));
-#ifdef CONFIG_SDIO_HCI
- _exit_critical_bh(&queue->lock, &irqL);
-#else
- _exit_critical_ex(&queue->lock, &irqL);
-#endif/*#ifdef CONFIG_SDIO_HCI*/
+ spin_unlock_irqrestore(&queue->lock, irqL);
return _SUCCESS;
}
struct recv_buf *precvbuf;
_list *plist, *phead;
-#ifdef CONFIG_SDIO_HCI
- _enter_critical_bh(&queue->lock, &irqL);
-#else
- _enter_critical_ex(&queue->lock, &irqL);
-#endif/*#ifdef CONFIG_SDIO_HCI*/
+ spin_lock_irqsave(&queue->lock, irqL);
if(_rtw_queue_empty(queue) == _TRUE)
{
}
-#ifdef CONFIG_SDIO_HCI
- _exit_critical_bh(&queue->lock, &irqL);
-#else
- _exit_critical_ex(&queue->lock, &irqL);
-#endif/*#ifdef CONFIG_SDIO_HCI*/
+ spin_unlock_irqrestore(&queue->lock, irqL);
return precvbuf;
}
-sint recvframe_chkmic(_adapter *adapter, union recv_frame *precvframe);
-sint recvframe_chkmic(_adapter *adapter, union recv_frame *precvframe){
+int recvframe_chkmic(_adapter *adapter, union recv_frame *precvframe);
+int recvframe_chkmic(_adapter *adapter, union recv_frame *precvframe){
- sint i,res=_SUCCESS;
+ int i,res=_SUCCESS;
u32 datalen;
u8 miccode[8];
u8 bmic_err=_FALSE,brpt_micerror = _TRUE;
return prtnframe;
}
-sint recv_decache(union recv_frame *precv_frame, u8 bretry, struct stainfo_rxcache *prxcache);
-sint recv_decache(union recv_frame *precv_frame, u8 bretry, struct stainfo_rxcache *prxcache)
+int recv_decache(union recv_frame *precv_frame, u8 bretry, struct stainfo_rxcache *prxcache);
+int recv_decache(union recv_frame *precv_frame, u8 bretry, struct stainfo_rxcache *prxcache)
{
- sint tid = precv_frame->u.hdr.attrib.priority;
+ int tid = precv_frame->u.hdr.attrib.priority;
u16 seq_ctrl = ( (precv_frame->u.hdr.attrib.seq_num&0xffff) << 4) |
(precv_frame->u.hdr.attrib.frag_num & 0xf);
}
#ifdef CONFIG_TDLS
-sint OnTDLS(_adapter *adapter, union recv_frame *precv_frame)
+int OnTDLS(_adapter *adapter, union recv_frame *precv_frame)
{
struct rx_pkt_attrib *pattrib = & precv_frame->u.hdr.attrib;
- sint ret = _SUCCESS;
+ int ret = _SUCCESS;
u8 *paction = get_recvframe_data(precv_frame);
u8 category_field = 1;
#ifdef CONFIG_WFD
break;
#ifdef CONFIG_WFD
case 0x50: /* First byte of WFA OUI */
- if( _rtw_memcmp(WFA_OUI, (paction), 3) )
+ if (!memcmp(WFA_OUI, (paction), 3))
{
if( *(paction + 3) == 0x04) /* Probe request frame */
{
}
}
-sint sta2sta_data_frame(
+int sta2sta_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info**psta
);
-sint sta2sta_data_frame(
+int sta2sta_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info**psta
)
{
u8 *ptr = precv_frame->u.hdr.rx_data;
- sint ret = _SUCCESS;
+ int ret = _SUCCESS;
struct rx_pkt_attrib *pattrib = & precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u8 *mybssid = get_bssid(pmlmepriv);
u8 *myhwaddr = myid(&adapter->eeprompriv);
u8 * sta_addr = NULL;
- sint bmcast = IS_MCAST(pattrib->dst);
+ int bmcast = IS_MCAST(pattrib->dst);
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &adapter->tdlsinfo;
{
/* 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;
}
}
}
/* 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)){
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))
{
ret= _FAIL;
goto exit;
}
/* 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)) {
ret= _FAIL;
goto exit;
}
goto exit;
}
/* receive some of all TDLS management frames, process it at ON_TDLS */
- if((_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_TDLS, 2))){
- ret= OnTDLS(adapter, precv_frame);
+ if (!memcmp(psnap_type, SNAP_ETH_TYPE_TDLS, 2)){
+ ret = OnTDLS(adapter, precv_frame);
goto exit;
}
#endif /* CONFIG_TDLS */
{
/* 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;
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;
}
return ret;
}
-sint ap2sta_data_frame(
+int ap2sta_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info**psta );
-sint ap2sta_data_frame(
+int ap2sta_data_frame(
_adapter *adapter,
union 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;
- sint ret = _SUCCESS;
+ int ret = _SUCCESS;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u8 *mybssid = get_bssid(pmlmepriv);
u8 *myhwaddr = myid(&adapter->eeprompriv);
- sint bmcast = IS_MCAST(pattrib->dst);
+ int bmcast = IS_MCAST(pattrib->dst);
_func_enter_;
{
/* 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"));
#ifdef DBG_RX_DROP_FRAME
DBG_8723A("DBG_RX_DROP_FRAME %s SA="MAC_FMT", myhwaddr="MAC_FMT"\n",
}
/* 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="MAC_FMT"\n", MAC_ARG(pattrib->dst)));
}
/* 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="MAC_FMT"\n", MAC_ARG(pattrib->bssid)));
RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("mybssid="MAC_FMT"\n", MAC_ARG(mybssid)));
}
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)
return ret;
}
-sint sta2ap_data_frame(
+int sta2ap_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info**psta );
-sint sta2ap_data_frame(
+int sta2ap_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info**psta )
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
unsigned char *mybssid = get_bssid(pmlmepriv);
- sint ret=_SUCCESS;
+ 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;
}
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;
}
return ret;
}
-sint validate_recv_ctrl_frame(_adapter *padapter, union recv_frame *precv_frame);
-sint validate_recv_ctrl_frame(_adapter *padapter, union recv_frame *precv_frame)
+int validate_recv_ctrl_frame(_adapter *padapter, union recv_frame *precv_frame);
+int validate_recv_ctrl_frame(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_AP_MODE
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
}
/* 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;
}
struct xmit_frame *pxmitframe=NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
- /* _enter_critical_bh(&psta->sleep_q.lock, &irqL); */
- _enter_critical_bh(&pxmitpriv->lock, &irqL);
+ /* spin_lock_bh(&psta->sleep_q.lock); */
+ spin_lock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
update_beacon(padapter, _TIM_IE_, NULL, _FALSE);
}
- /* _exit_critical_bh(&psta->sleep_q.lock, &irqL); */
- _exit_critical_bh(&pxmitpriv->lock, &irqL);
+ /* spin_unlock_bh(&psta->sleep_q.lock); */
+ spin_unlock_bh(&pxmitpriv->lock);
}
else
{
- /* _exit_critical_bh(&psta->sleep_q.lock, &irqL); */
- _exit_critical_bh(&pxmitpriv->lock, &irqL);
+ /* spin_unlock_bh(&psta->sleep_q.lock); */
+ spin_unlock_bh(&pxmitpriv->lock);
/* DBG_8723A("no buffered packets to xmit\n"); */
if(pstapriv->tim_bitmap&BIT(psta->aid))
}
union recv_frame* recvframe_chk_defrag(PADAPTER padapter, union recv_frame *precv_frame);
-sint validate_recv_mgnt_frame(PADAPTER padapter, union recv_frame *precv_frame);
-sint validate_recv_mgnt_frame(PADAPTER padapter, union recv_frame *precv_frame)
+int validate_recv_mgnt_frame(PADAPTER padapter, union recv_frame *precv_frame);
+int validate_recv_mgnt_frame(PADAPTER padapter, union recv_frame *precv_frame)
{
/* struct mlme_priv *pmlmepriv = &adapter->mlmepriv; */
else if (GetFrameSubType(precv_frame->u.hdr.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)
+ if (!memcmp(padapter->eeprompriv.mac_addr, GetAddr1Ptr(precv_frame->u.hdr.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)))
return _SUCCESS;
}
-sint validate_recv_data_frame(_adapter *adapter, union recv_frame *precv_frame);
-sint validate_recv_data_frame(_adapter *adapter, union recv_frame *precv_frame)
+int validate_recv_data_frame(_adapter *adapter, union recv_frame *precv_frame);
+int validate_recv_data_frame(_adapter *adapter, union recv_frame *precv_frame)
{
u8 bretry;
u8 *psa, *pda, *pbssid;
struct rx_pkt_attrib *pattrib = & precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &adapter->stapriv;
struct security_priv *psecuritypriv = &adapter->securitypriv;
- sint ret = _SUCCESS;
+ int ret = _SUCCESS;
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &adapter->tdlsinfo;
#endif /* CONFIG_TDLS */
return ret;
}
-sint validate_recv_frame(_adapter *adapter, union recv_frame *precv_frame);
-sint validate_recv_frame(_adapter *adapter, union recv_frame *precv_frame)
+int validate_recv_frame(_adapter *adapter, union recv_frame *precv_frame);
+int validate_recv_frame(_adapter *adapter, union recv_frame *precv_frame)
{
/* shall check frame subtype, to / from ds, da, bssid */
u8 type;
u8 subtype;
- sint retval = _SUCCESS;
+ int retval = _SUCCESS;
struct rx_pkt_attrib *pattrib = & precv_frame->u.hdr.attrib;
/* remove the wlanhdr and add the eth_hdr */
-sint wlanhdr_to_ethhdr ( union recv_frame *precvframe)
+int wlanhdr_to_ethhdr ( union recv_frame *precvframe)
{
- sint rmv_len;
+ int rmv_len;
u16 eth_type, len;
u8 bsnaphdr;
u8 *psnap_type;
struct ieee80211_snap_hdr *psnap;
- sint ret=_SUCCESS;
+ int ret=_SUCCESS;
_adapter *adapter =precvframe->u.hdr.adapter;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
psnap_type=ptr+pattrib->hdrlen + pattrib->iv_len+SNAP_SIZE;
/* convert hdr + possible LLC headers into Ethernet header */
/* eth_type = (psnap_type[0] << 8) | psnap_type[1]; */
- 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) )||
- /* eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) || */
- _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) &&
+ memcmp(psnap_type, SNAP_ETH_TYPE_APPLETALK_AARP, 2)) ||
+ /* eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) || */
+ !memcmp(psnap, rtw_bridge_tunnel_header, SNAP_SIZE)) {
/* remove RFC1042 or Bridge-Tunnel encapsulation and replace EtherType */
bsnaphdr = _TRUE;
}
return ret;
}
-#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
-static void recvframe_expand_pkt(
- PADAPTER padapter,
- union recv_frame *prframe)
-{
- struct recv_frame_hdr *pfhdr;
- _pkt *ppkt;
- u8 shift_sz;
- u32 alloc_sz;
-
- pfhdr = &prframe->u.hdr;
-
- /* 6 is for IP header 8 bytes alignment in QoS packet case. */
- if (pfhdr->attrib.qos)
- shift_sz = 6;
- else
- shift_sz = 0;
-
- /* for first fragment packet, need to allocate */
- /* (1536 + RXDESC_SIZE + drvinfo_sz) to reassemble packet */
- /* 8 is for skb->data 8 bytes alignment. */
-/* alloc_sz = _RND(1536 + RXDESC_SIZE + pfhdr->attrib.drvinfosize + shift_sz + 8, 128); */
- alloc_sz = 1664; /* round (1536 + 24 + 32 + shift_sz + 8) to 128 bytes alignment */
-
- /* 3 1. alloc new skb */
- /* prepare extra space for 4 bytes alignment */
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) /* http:www.mail-archive.com/netdev@vger.kernel.org/msg17214.html */
- ppkt = dev_alloc_skb(alloc_sz);
- if (ppkt) ppkt->dev = padapter->pnetdev;
-#else
- ppkt = netdev_alloc_skb(padapter->pnetdev, alloc_sz);
-#endif
- if (!ppkt) return; /* no way to expand */
-
- /* 3 2. Prepare new skb to replace & release old skb */
- /* force ppkt->data at 8-byte alignment address */
- skb_reserve(ppkt, 8 - ((SIZE_PTR)ppkt->data & 7));
- /* force ip_hdr at 8-byte alignment address according to shift_sz */
- skb_reserve(ppkt, shift_sz);
-
- /* copy data to new pkt */
- memcpy(skb_put(ppkt, pfhdr->len), pfhdr->rx_data, pfhdr->len);
-
- dev_kfree_skb_any(pfhdr->pkt);
-
- /* attach new pkt to recvframe */
- pfhdr->pkt = ppkt;
- pfhdr->rx_head = ppkt->head;
- pfhdr->rx_data = ppkt->data;
- pfhdr->rx_tail = skb_tail_pointer(ppkt);
- pfhdr->rx_end = skb_end_pointer(ppkt);
-}
-#endif
-
/* perform defrag */
union recv_frame * recvframe_defrag(_adapter *adapter,_queue *defrag_q);
union recv_frame * recvframe_defrag(_adapter *adapter,_queue *defrag_q)
return NULL;
}
-#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
-#ifndef CONFIG_SDIO_RX_COPY
- recvframe_expand_pkt(adapter, prframe);
-#endif
-#endif
-
curfragnum++;
plist= get_list_head(defrag_q);
/* Then enqueue the 0~(n-1) fragment into the defrag_q */
- /* _rtw_spinlock(&pdefrag_q->lock); */
+ /* spin_lock(&pdefrag_q->lock); */
phead = get_list_head(pdefrag_q);
rtw_list_insert_tail(&pfhdr->list, phead);
- /* _rtw_spinunlock(&pdefrag_q->lock); */
+ /* spin_unlock(&pdefrag_q->lock); */
RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("Enqueuq: ismfrag = %d, fragnum= %d\n", ismfrag,fragnum));
/* enqueue the last fragment */
if(pdefrag_q != NULL)
{
- /* _rtw_spinlock(&pdefrag_q->lock); */
+ /* spin_lock(&pdefrag_q->lock); */
phead = get_list_head(pdefrag_q);
rtw_list_insert_tail(&pfhdr->list,phead);
- /* _rtw_spinunlock(&pdefrag_q->lock); */
+ /* spin_unlock(&pdefrag_q->lock); */
/* call recvframe_defrag to defrag */
RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("defrag: ismfrag = %d, fragnum= %d\n", ismfrag, fragnum));
eth_type = (sub_skb->data[6] << 8) | sub_skb->data[7];
#endif /* ENDIAN_FREE */
if (sub_skb->len >= 8 &&
- ((_rtw_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_rfc1042_header, SNAP_SIZE) &&
+ eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) ||
+ !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);
/* DbgPrint("+enqueue_reorder_recvframe()\n"); */
- /* _enter_critical_ex(&ppending_recvframe_queue->lock, &irql); */
- /* _rtw_spinlock_ex(&ppending_recvframe_queue->lock); */
+ /* spin_lock_irqsave(&ppending_recvframe_queue->lock); */
+ /* spin_lock_ex(&ppending_recvframe_queue->lock); */
phead = get_list_head(ppending_recvframe_queue);
plist = get_next(phead);
/* Duplicate entry is found!! Do not insert current entry. */
/* RT_TRACE(COMP_RX_REORDER, DBG_TRACE, ("InsertRxReorderList(): Duplicate packet is dropped!! IndicateSeq: %d, NewSeq: %d\n", pTS->RxIndicateSeq, SeqNum)); */
- /* _exit_critical_ex(&ppending_recvframe_queue->lock, &irql); */
+ /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
return _FALSE;
}
}
- /* _enter_critical_ex(&ppending_recvframe_queue->lock, &irql); */
- /* _rtw_spinlock_ex(&ppending_recvframe_queue->lock); */
+ /* spin_lock_irqsave(&ppending_recvframe_queue->lock); */
+ /* spin_lock_ex(&ppending_recvframe_queue->lock); */
rtw_list_delete(&(prframe->u.hdr.list));
rtw_list_insert_tail(&(prframe->u.hdr.list), plist);
- /* _rtw_spinunlock_ex(&ppending_recvframe_queue->lock); */
- /* _exit_critical_ex(&ppending_recvframe_queue->lock, &irql); */
+ /* spin_unlock_ex(&ppending_recvframe_queue->lock); */
+ /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
/* RT_TRACE(COMP_RX_REORDER, DBG_TRACE, ("InsertRxReorderList(): Pkt insert into buffer!! IndicateSeq: %d, NewSeq: %d\n", pTS->RxIndicateSeq, SeqNum)); */
return _TRUE;
/* DbgPrint("+recv_indicatepkts_in_order\n"); */
- /* _enter_critical_ex(&ppending_recvframe_queue->lock, &irql); */
- /* _rtw_spinlock_ex(&ppending_recvframe_queue->lock); */
+ /* spin_lock_irqsave(&ppending_recvframe_queue->lock); */
+ /* spin_lock_ex(&ppending_recvframe_queue->lock); */
phead = get_list_head(ppending_recvframe_queue);
plist = get_next(phead);
{
if(rtw_is_list_empty(phead))
{
- /* _exit_critical_ex(&ppending_recvframe_queue->lock, &irql); */
- /* _rtw_spinunlock_ex(&ppending_recvframe_queue->lock); */
+ /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
+ /* spin_unlock_ex(&ppending_recvframe_queue->lock); */
return _TRUE;
}
}
- /* _rtw_spinunlock_ex(&ppending_recvframe_queue->lock); */
- /* _exit_critical_ex(&ppending_recvframe_queue->lock, &irql); */
+ /* spin_unlock_ex(&ppending_recvframe_queue->lock); */
+ /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
return bPktInBuf;
}
}
- _enter_critical_bh(&ppending_recvframe_queue->lock, &irql);
+ spin_lock_bh(&ppending_recvframe_queue->lock);
RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
("recv_indicatepkt_reorder: indicate=%d seq=%d\n",
/* pHTInfo->RxReorderDropCounter++; */
/* ReturnRFDList(Adapter, pRfd); */
/* RT_TRACE(COMP_RX_REORDER, DBG_TRACE, ("RxReorderIndicatePacket() ==> Packet Drop!!\n")); */
- /* _exit_critical_ex(&ppending_recvframe_queue->lock, &irql); */
+ /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
/* return _FAIL; */
#ifdef DBG_RX_DROP_FRAME
if(!enqueue_reorder_recvframe(preorder_ctrl, prframe))
{
/* DbgPrint("recv_indicatepkt_reorder, enqueue_reorder_recvframe fail!\n"); */
- /* _exit_critical_ex(&ppending_recvframe_queue->lock, &irql); */
+ /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
/* return _FAIL; */
#ifdef DBG_RX_DROP_FRAME
DBG_8723A("DBG_RX_DROP_FRAME %s enqueue_reorder_recvframe fail\n", __FUNCTION__);
if(recv_indicatepkts_in_order(padapter, preorder_ctrl, _FALSE)==_TRUE)
{
_set_timer(&preorder_ctrl->reordering_ctrl_timer, REORDER_WAIT_TIME);
- _exit_critical_bh(&ppending_recvframe_queue->lock, &irql);
+ spin_unlock_bh(&ppending_recvframe_queue->lock);
}
else
{
- _exit_critical_bh(&ppending_recvframe_queue->lock, &irql);
+ spin_unlock_bh(&ppending_recvframe_queue->lock);
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
}
_err_exit:
- _exit_critical_bh(&ppending_recvframe_queue->lock, &irql);
+ spin_unlock_bh(&ppending_recvframe_queue->lock);
return _FAIL;
}
/* DBG_8723A("+rtw_reordering_ctrl_timeout_handler()=>\n"); */
- _enter_critical_bh(&ppending_recvframe_queue->lock, &irql);
+ spin_lock_bh(&ppending_recvframe_queue->lock);
if(recv_indicatepkts_in_order(padapter, preorder_ctrl, _TRUE)==_TRUE)
{
_set_timer(&preorder_ctrl->reordering_ctrl_timer, REORDER_WAIT_TIME);
}
- _exit_critical_bh(&ppending_recvframe_queue->lock, &irql);
+ spin_unlock_bh(&ppending_recvframe_queue->lock);
}
int process_recv_indicatepkts(_adapter *padapter, union recv_frame *prframe);
psnap_type+=pattrib->hdrlen + pattrib->iv_len+SNAP_SIZE;
pcategory = psnap_type + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
- if((_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_TDLS, ETH_TYPE_LEN)) &&
- ((*pcategory==RTW_WLAN_CATEGORY_TDLS) || (*pcategory==RTW_WLAN_CATEGORY_P2P))){
+ if (!memcmp(psnap_type, SNAP_ETH_TYPE_TDLS, ETH_TYPE_LEN) &&
+ ((*pcategory==RTW_WLAN_CATEGORY_TDLS) ||
+ (*pcategory==RTW_WLAN_CATEGORY_P2P))) {
ret = OnTDLS(padapter, prframe); /* all of functions will return _FAIL */
goto _exit_recv_func;
}
OSDN Git Service
