/****************************************************************************** * * 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 PLATFORM_OS_XP #ifdef CONFIG_SDIO_HCI #define NR_RECVBUFF 1024//512//128 #else #define NR_RECVBUFF (16) #endif #elif defined(PLATFORM_OS_CE) #ifdef CONFIG_SDIO_HCI #define NR_RECVBUFF (128) #else #define NR_RECVBUFF (4) #endif #else //PLATFORM_LINUX /PLATFORM_BSD #ifdef CONFIG_SINGLE_RECV_BUF #define NR_RECVBUFF (1) #else #if defined(CONFIG_GSPI_HCI) #define NR_RECVBUFF (32) #elif defined(CONFIG_SDIO_HCI) #define NR_RECVBUFF (8) #else #define NR_RECVBUFF (8) #endif #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 */ #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 _timer 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; BOOLEAN 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; #ifdef CONFIG_USB_HCI #if defined(PLATFORM_OS_XP)||defined(PLATFORM_LINUX)||defined(PLATFORM_FREEBSD) PURB purb; dma_addr_t dma_transfer_addr; /* (in) dma addr for transfer_buffer */ u32 alloc_sz; #endif #ifdef PLATFORM_OS_XP PIRP pirp; #endif #ifdef PLATFORM_OS_CE USB_TRANSFER usb_transfer_read_port; #endif u8 irp_pending; int transfer_len; #endif #ifdef PLATFORM_LINUX _pkt *pskb; #endif #ifdef PLATFORM_FREEBSD //skb solution struct sk_buff *pskb; #endif //PLATFORM_FREEBSD //skb solution }; /* 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]; }; 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); __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, sint sz) { // rx_tai += sz; move rx_tail sz bytes hereafter //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; /* DBG_871X("recvframe_put: len=%d\n", sz); */ if(precvframe==NULL) 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; #ifdef PLATFORM_WINDOWS NdisQueryPacket(precvframe->u.hdr.pkt, NULL, NULL, &buf_desc, NULL); #endif 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; #ifdef PLATFORM_WINDOWS _buffer * buf_desc; uint len; NdisQueryPacket(pkt, NULL, NULL, &buf_desc, &len); NdisQueryBufferSafe(buf_desc, &buf_star, &len, HighPagePriority); #endif 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); #endif