/****************************************************************************** * * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA * * ******************************************************************************/ #ifndef _RTW_RECV_H_ #define _RTW_RECV_H_ #ifdef CONFIG_SINGLE_RECV_BUF #define NR_RECVBUFF (1) #else #define NR_RECVBUFF (8) #endif /* CONFIG_SINGLE_RECV_BUF */ #ifdef CONFIG_PREALLOC_RX_SKB_BUFFER #define NR_PREALLOC_RECV_SKB (rtw_rtkm_get_nr_recv_skb()>>1) #else /*!CONFIG_PREALLOC_RX_SKB_BUFFER */ #define NR_PREALLOC_RECV_SKB 8 #endif /* CONFIG_PREALLOC_RX_SKB_BUFFER */ #ifdef CONFIG_RTW_NAPI #define RTL_NAPI_WEIGHT (32) #endif #define NR_RECVFRAME 256 #define RXFRAME_ALIGN 8 #define RXFRAME_ALIGN_SZ (1<network.PhyInfo.SignalStrength); */ struct rx_raw_rssi raw_rssi_info; /* s8 rxpwdb; */ s16 noise; /* int RxSNRdB[2]; */ /* s8 RxRssi[2]; */ /* int FalseAlmCnt_all; */ #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS struct timer_list signal_stat_timer; u32 signal_stat_sampling_interval; /* u32 signal_stat_converging_constant; */ struct signal_stat signal_qual_data; struct signal_stat signal_strength_data; #else /* CONFIG_NEW_SIGNAL_STAT_PROCESS */ struct smooth_rssi_data signal_qual_data; struct smooth_rssi_data signal_strength_data; #endif /* CONFIG_NEW_SIGNAL_STAT_PROCESS */ u16 sink_udpport, pre_rtp_rxseq, cur_rtp_rxseq; bool store_law_data_flag; }; #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS #define rtw_set_signal_stat_timer(recvpriv) _set_timer(&(recvpriv)->signal_stat_timer, (recvpriv)->signal_stat_sampling_interval) #endif /* CONFIG_NEW_SIGNAL_STAT_PROCESS */ struct sta_recv_priv { _lock lock; sint option; /* _queue blk_strms[MAX_RX_NUMBLKS]; */ _queue defrag_q; /* keeping the fragment frame until defrag */ struct stainfo_rxcache rxcache; /* uint sta_rx_bytes; */ /* uint sta_rx_pkts; */ /* uint sta_rx_fail; */ }; struct recv_buf { _list list; _lock recvbuf_lock; u32 ref_cnt; PADAPTER adapter; u8 *pbuf; u8 *pallocated_buf; u32 len; u8 *phead; u8 *pdata; u8 *ptail; u8 *pend; PURB purb; dma_addr_t dma_transfer_addr; /* (in) dma addr for transfer_buffer */ u32 alloc_sz; u8 irp_pending; int transfer_len; _pkt *pskb; }; /* head -----> data -----> payload tail -----> end -----> len = (unsigned int )(tail - data); */ struct recv_frame_hdr { _list list; #ifndef CONFIG_BSD_RX_USE_MBUF struct sk_buff *pkt; struct sk_buff *pkt_newalloc; #else /* CONFIG_BSD_RX_USE_MBUF */ _pkt *pkt; _pkt *pkt_newalloc; #endif /* CONFIG_BSD_RX_USE_MBUF */ _adapter *adapter; u8 fragcnt; int frame_tag; struct rx_pkt_attrib attrib; uint len; u8 *rx_head; u8 *rx_data; u8 *rx_tail; u8 *rx_end; void *precvbuf; /* */ struct sta_info *psta; /* for A-MPDU Rx reordering buffer control */ struct recv_reorder_ctrl *preorder_ctrl; #ifdef CONFIG_WAPI_SUPPORT u8 UserPriority; u8 WapiTempPN[16]; u8 WapiSrcAddr[6]; u8 bWapiCheckPNInDecrypt; u8 bIsWaiPacket; #endif }; union recv_frame { union { _list list; struct recv_frame_hdr hdr; uint mem[RECVFRAME_HDR_ALIGN >> 2]; } u; /* uint mem[MAX_RXSZ>>2]; */ }; bool rtw_rframe_del_wfd_ie(union recv_frame *rframe, u8 ies_offset); typedef enum _RX_PACKET_TYPE { NORMAL_RX,/* Normal rx packet */ TX_REPORT1,/* CCX */ TX_REPORT2,/* TX RPT */ HIS_REPORT,/* USB HISR RPT */ C2H_PACKET } RX_PACKET_TYPE, *PRX_PACKET_TYPE; extern union recv_frame *_rtw_alloc_recvframe(_queue *pfree_recv_queue); /* get a free recv_frame from pfree_recv_queue */ extern union recv_frame *rtw_alloc_recvframe(_queue *pfree_recv_queue); /* get a free recv_frame from pfree_recv_queue */ extern void rtw_init_recvframe(union recv_frame *precvframe , struct recv_priv *precvpriv); extern int rtw_free_recvframe(union recv_frame *precvframe, _queue *pfree_recv_queue); #define rtw_dequeue_recvframe(queue) rtw_alloc_recvframe(queue) extern int _rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue); extern int rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue); extern void rtw_free_recvframe_queue(_queue *pframequeue, _queue *pfree_recv_queue); u32 rtw_free_uc_swdec_pending_queue(_adapter *adapter); sint rtw_enqueue_recvbuf_to_head(struct recv_buf *precvbuf, _queue *queue); sint rtw_enqueue_recvbuf(struct recv_buf *precvbuf, _queue *queue); struct recv_buf *rtw_dequeue_recvbuf(_queue *queue); void rtw_reordering_ctrl_timeout_handler(void *pcontext); void rx_query_phy_status(union recv_frame *rframe, u8 *phy_stat); int rtw_inc_and_chk_continual_no_rx_packet(struct sta_info *sta, int tid_index); void rtw_reset_continual_no_rx_packet(struct sta_info *sta, int tid_index); #ifdef CONFIG_RECV_THREAD_MODE thread_return rtw_recv_thread(thread_context context); #endif __inline static u8 *get_rxmem(union recv_frame *precvframe) { /* always return rx_head... */ if (precvframe == NULL) return NULL; return precvframe->u.hdr.rx_head; } __inline static u8 *get_rx_status(union recv_frame *precvframe) { return get_rxmem(precvframe); } __inline static u8 *get_recvframe_data(union recv_frame *precvframe) { /* alwasy return rx_data */ if (precvframe == NULL) return NULL; return precvframe->u.hdr.rx_data; } __inline static u8 *recvframe_push(union recv_frame *precvframe, sint sz) { /* append data before rx_data */ /* add data to the start of recv_frame * * This function extends the used data area of the recv_frame at the buffer * start. rx_data must be still larger than rx_head, after pushing. */ if (precvframe == NULL) return NULL; precvframe->u.hdr.rx_data -= sz ; if (precvframe->u.hdr.rx_data < precvframe->u.hdr.rx_head) { precvframe->u.hdr.rx_data += sz ; return NULL; } precvframe->u.hdr.len += sz; return precvframe->u.hdr.rx_data; } __inline static u8 *recvframe_pull(union recv_frame *precvframe, sint sz) { /* rx_data += sz; move rx_data sz bytes hereafter */ /* used for extract sz bytes from rx_data, update rx_data and return the updated rx_data to the caller */ if (precvframe == NULL) return NULL; precvframe->u.hdr.rx_data += sz; if (precvframe->u.hdr.rx_data > precvframe->u.hdr.rx_tail) { precvframe->u.hdr.rx_data -= sz; return NULL; } precvframe->u.hdr.len -= sz; return precvframe->u.hdr.rx_data; } __inline static u8 *recvframe_put(union recv_frame *precvframe, __le16 le_sz) { s16 sz = le16_to_cpu(le_sz); /* used for append sz bytes from ptr to rx_tail, update rx_tail and return the updated rx_tail to the caller */ /* after putting, rx_tail must be still larger than rx_end. */ unsigned char *prev_rx_tail; if (!precvframe) return NULL; prev_rx_tail = precvframe->u.hdr.rx_tail; precvframe->u.hdr.rx_tail += sz; if (precvframe->u.hdr.rx_tail > precvframe->u.hdr.rx_end) { precvframe->u.hdr.rx_tail -= sz; return NULL; } precvframe->u.hdr.len += sz; return precvframe->u.hdr.rx_tail; } __inline static u8 *recvframe_pull_tail(union recv_frame *precvframe, sint sz) { /* rmv data from rx_tail (by yitsen) */ /* used for extract sz bytes from rx_end, update rx_end and return the updated rx_end to the caller */ /* after pulling, rx_end must be still larger than rx_data. */ if (precvframe == NULL) return NULL; precvframe->u.hdr.rx_tail -= sz; if (precvframe->u.hdr.rx_tail < precvframe->u.hdr.rx_data) { precvframe->u.hdr.rx_tail += sz; return NULL; } precvframe->u.hdr.len -= sz; return precvframe->u.hdr.rx_tail; } __inline static _buffer *get_rxbuf_desc(union recv_frame *precvframe) { _buffer *buf_desc; if (precvframe == NULL) return NULL; return buf_desc; } __inline static union recv_frame *rxmem_to_recvframe(u8 *rxmem) { /* due to the design of 2048 bytes alignment of recv_frame, we can reference the union recv_frame */ /* from any given member of recv_frame. */ /* rxmem indicates the any member/address in recv_frame */ return (union recv_frame *)(((SIZE_PTR)rxmem >> RXFRAME_ALIGN) << RXFRAME_ALIGN); } __inline static union recv_frame *pkt_to_recvframe(_pkt *pkt) { u8 *buf_star; union recv_frame *precv_frame; precv_frame = rxmem_to_recvframe((unsigned char *)buf_star); return precv_frame; } __inline static u8 *pkt_to_recvmem(_pkt *pkt) { /* return the rx_head */ union recv_frame *precv_frame = pkt_to_recvframe(pkt); return precv_frame->u.hdr.rx_head; } __inline static u8 *pkt_to_recvdata(_pkt *pkt) { /* return the rx_data */ union recv_frame *precv_frame = pkt_to_recvframe(pkt); return precv_frame->u.hdr.rx_data; } __inline static sint get_recvframe_len(union recv_frame *precvframe) { return precvframe->u.hdr.len; } __inline static s32 translate_percentage_to_dbm(u32 SignalStrengthIndex) { s32 SignalPower; /* in dBm. */ #ifdef CONFIG_SIGNAL_SCALE_MAPPING /* Translate to dBm (x=0.5y-95). */ SignalPower = (s32)((SignalStrengthIndex + 1) >> 1); SignalPower -= 95; #else /* Translate to dBm (x=y-100) */ SignalPower = SignalStrengthIndex - 100; #endif return SignalPower; } struct sta_info; extern void _rtw_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv); extern void mgt_dispatcher(_adapter *padapter, union recv_frame *precv_frame); s32 pre_recv_entry(union recv_frame *precvframe, u8 *pphy_status); #endif