drivers/staging/rtl8712/rtl871x_recv.h - kernel/mindspeed - Git at Google

 #ifndef _RTL871X_RECV_H_
 #define _RTL871X_RECV_H_

 #include "osdep_service.h"
 #include "drv_types.h"

 #define NR_RECVFRAME 256

 #define RXFRAME_ALIGN	8
 #define RXFRAME_ALIGN_SZ	(1 << RXFRAME_ALIGN)

 #define MAX_RXFRAME_CNT	512
 #define MAX_RX_NUMBLKS		(32)
 #define RECVFRAME_HDR_ALIGN 128
 #define MAX_SUBFRAME_COUNT	64

 #define SNAP_SIZE sizeof(struct ieee80211_snap_hdr)

 /* for Rx reordering buffer control */
 struct recv_reorder_ctrl {
 	struct _adapter	*padapter;
 	u16 indicate_seq; /* =wstart_b, init_value=0xffff */
 	u16 wend_b;
 	u8 wsize_b;
 	struct  __queue pending_recvframe_queue;
 	struct timer_list reordering_ctrl_timer;
 };

 struct	stainfo_rxcache	{
 	u16	tid_rxseq[16];
 };

 #define		PHY_RSSI_SLID_WIN_MAX			100
 #define		PHY_LINKQUALITY_SLID_WIN_MAX		20


 struct smooth_rssi_data {
 	u32	elements[100];	/* array to store values */
 	u32	index;		/* index to current array to store */
 	u32	total_num;	/* num of valid elements */
 	u32	total_val;	/* sum of valid elements */
 };

 struct rx_pkt_attrib {

 	u8	amsdu;
 	u8	order;
 	u8	qos;
 	u8	to_fr_ds;
 	u8	frag_num;
 	u16	seq_num;
 	u8   pw_save;
 	u8    mfrag;
 	u8    mdata;
 	u8	privacy; /* in frame_ctrl field */
 	u8	bdecrypted;
 	int	hdrlen;	 /* the WLAN Header Len */
 	int	encrypt; /* 0 no encrypt. != 0 encrypt algorith */
 	int	iv_len;
 	int	icv_len;
 	int	priority;
 	int	ack_policy;
 	u8	crc_err;
 	u8	dst[ETH_ALEN];
 	u8	src[ETH_ALEN];
 	u8	ta[ETH_ALEN];
 	u8	ra[ETH_ALEN];
 	u8	bssid[ETH_ALEN];
 	u8	tcpchk_valid; /* 0: invalid, 1: valid */
 	u8	ip_chkrpt; /* 0: incorrect, 1: correct */
 	u8	tcp_chkrpt; /* 0: incorrect, 1: correct */
 	u8	signal_qual;
 	s8	rx_mimo_signal_qual[2];
 	u8	mcs_rate;
 	u8	htc;
 	u8	signal_strength;
 };

 /*
 accesser of recv_priv: recv_entry(dispatch / passive level);
 recv_thread(passive) ; returnpkt(dispatch)
 ; halt(passive) ;

 using enter_critical section to protect
 */
 struct recv_priv {
 	spinlock_t lock;
 	struct semaphore recv_sema;
 	struct semaphore terminate_recvthread_sema;
 	struct  __queue	free_recv_queue;
 	struct  __queue	recv_pending_queue;
 	u8 *pallocated_frame_buf;
 	u8 *precv_frame_buf;
 	uint free_recvframe_cnt;
 	struct _adapter	*adapter;
 	uint	rx_bytes;
 	uint	rx_pkts;
 	uint	rx_drop;
 	uint  rx_icv_err;
 	uint  rx_largepacket_crcerr;
 	uint  rx_smallpacket_crcerr;
 	uint  rx_middlepacket_crcerr;
 	struct semaphore allrxreturnevt;
 	u8  rx_pending_cnt;
 	uint	ff_hwaddr;
 	struct tasklet_struct recv_tasklet;
 	struct sk_buff_head free_recv_skb_queue;
 	struct sk_buff_head rx_skb_queue;
 	u8 *pallocated_recv_buf;
 	u8 *precv_buf;    /* 4 alignment */
 	struct  __queue	free_recv_buf_queue;
 	u32	free_recv_buf_queue_cnt;
 	/* For the phy informatiom */
 	s8 rssi;
 	u8 signal;
 	u8 noise;
 	u8 fw_rssi;
 	struct smooth_rssi_data signal_qual_data;
 	struct smooth_rssi_data signal_strength_data;
 };

 struct sta_recv_priv {
 	spinlock_t lock;
 	sint	option;
 	struct  __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;
 };

 #include "rtl8712_recv.h"

 /* get a free recv_frame from pfree_recv_queue */
 union recv_frame *r8712_alloc_recvframe(struct  __queue *pfree_recv_queue);
 union recv_frame *r8712_dequeue_recvframe(struct  __queue *queue);
 int r8712_enqueue_recvframe(union recv_frame *precvframe,
 			     struct  __queue *queue);
 int r8712_free_recvframe(union recv_frame *precvframe,
 			  struct  __queue *pfree_recv_queue);
 void r8712_free_recvframe_queue(struct  __queue *pframequeue,
 				 struct  __queue *pfree_recv_queue);
 void r8712_init_recvframe(union recv_frame *precvframe,
 			   struct recv_priv *precvpriv);
 int r8712_wlanhdr_to_ethhdr(union recv_frame *precvframe);
 int recv_func(struct _adapter *padapter, void *pcontext);

 static inline u8 *get_rxmem(union recv_frame *precvframe)
 {
 	/* always return rx_head... */
 	if (precvframe == NULL)
 		return NULL;
 	return precvframe->u.hdr.rx_head;
 }

 static inline u8 *get_rx_status(union recv_frame *precvframe)
 {
 	return get_rxmem(precvframe);
 }

 static inline u8 *get_recvframe_data(union recv_frame *precvframe)
 {
 	/* always return rx_data */
 	if (precvframe == NULL)
 		return NULL;
 	return precvframe->u.hdr.rx_data;
 }

 static inline 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;
 }

 static inline u8 *recvframe_pull(union recv_frame *precvframe, sint sz)
 {
 	/* 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;
 }

 static inline u8 *recvframe_put(union recv_frame *precvframe, sint 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 == 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;
 }

 static inline 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;
 }

 static inline _buffer *get_rxbuf_desc(union recv_frame *precvframe)
 {
 	_buffer *buf_desc;
 	if (precvframe == NULL)
 		return NULL;
 	return buf_desc;
 }

 static inline 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 *)(((addr_t)rxmem >> RXFRAME_ALIGN) <<
 				  RXFRAME_ALIGN);
 }

 static inline 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;
 }

 static inline 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;
 }

 static inline 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;
 }

 static inline sint get_recvframe_len(union recv_frame *precvframe)
 {
 	return precvframe->u.hdr.len;
 }

 struct sta_info;

 void	_r8712_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv);
 sint r8712_recvframe_chkmic(struct _adapter *adapter,
 			    union recv_frame *precvframe);
 union recv_frame *r8712_decryptor(struct _adapter *adapter,
 				  union recv_frame *precv_frame);
 union recv_frame *r8712_recvframe_chk_defrag(struct _adapter *adapter,
 					     union recv_frame *precv_frame);
 union recv_frame *r8712_recvframe_defrag(struct _adapter *adapter,
 					 struct  __queue *defrag_q);
 union recv_frame *r8712_recvframe_chk_defrag_new(struct _adapter *adapter,
 					union recv_frame *precv_frame);
 union recv_frame *r8712_recvframe_defrag_new(struct _adapter *adapter,
 					struct  __queue *defrag_q,
 					union recv_frame *precv_frame);
 int r8712_recv_decache(union recv_frame *precv_frame, u8 bretry,
 		       struct stainfo_rxcache *prxcache);
 int r8712_sta2sta_data_frame(struct _adapter *adapter,
 			     union recv_frame *precv_frame,
 			     struct sta_info **psta);
 int r8712_ap2sta_data_frame(struct _adapter *adapter,
 			    union recv_frame *precv_frame,
 			    struct sta_info **psta);
 int r8712_sta2ap_data_frame(struct _adapter *adapter,
 			    union recv_frame *precv_frame,
 			    struct sta_info **psta);
 int r8712_validate_recv_ctrl_frame(struct _adapter *adapter,
 				   union recv_frame *precv_frame);
 int r8712_validate_recv_mgnt_frame(struct _adapter *adapter,
 				   union recv_frame *precv_frame);
 int r8712_validate_recv_data_frame(struct _adapter *adapter,
 				   union recv_frame *precv_frame);
 int r8712_validate_recv_frame(struct _adapter *adapter,
 			      union recv_frame *precv_frame);
 union recv_frame *r8712_portctrl(struct _adapter *adapter,
 				 union recv_frame *precv_frame);
 void  r8712_mgt_dispatcher(struct _adapter *padapter, u8 *pframe, uint len);
 int r8712_amsdu_to_msdu(struct _adapter *padapter, union recv_frame *prframe);

 #endif
	#ifndef _RTL871X_RECV_H_
	#define _RTL871X_RECV_H_

	#include "osdep_service.h"
	#include "drv_types.h"

	#define NR_RECVFRAME 256

	#define RXFRAME_ALIGN 8
	#define RXFRAME_ALIGN_SZ (1 << RXFRAME_ALIGN)

	#define MAX_RXFRAME_CNT 512
	#define MAX_RX_NUMBLKS (32)
	#define RECVFRAME_HDR_ALIGN 128
	#define MAX_SUBFRAME_COUNT 64

	#define SNAP_SIZE sizeof(struct ieee80211_snap_hdr)

	/* for Rx reordering buffer control */
	struct recv_reorder_ctrl {
	struct _adapter *padapter;
	u16 indicate_seq; /* =wstart_b, init_value=0xffff */
	u16 wend_b;
	u8 wsize_b;
	struct __queue pending_recvframe_queue;
	struct timer_list reordering_ctrl_timer;
	};

	struct stainfo_rxcache {
	u16 tid_rxseq[16];
	};

	#define PHY_RSSI_SLID_WIN_MAX 100
	#define PHY_LINKQUALITY_SLID_WIN_MAX 20


	struct smooth_rssi_data {
	u32 elements[100]; /* array to store values */
	u32 index; /* index to current array to store */
	u32 total_num; /* num of valid elements */
	u32 total_val; /* sum of valid elements */
	};

	struct rx_pkt_attrib {

	u8 amsdu;
	u8 order;
	u8 qos;
	u8 to_fr_ds;
	u8 frag_num;
	u16 seq_num;
	u8 pw_save;
	u8 mfrag;
	u8 mdata;
	u8 privacy; /* in frame_ctrl field */
	u8 bdecrypted;
	int hdrlen; /* the WLAN Header Len */
	int encrypt; /* 0 no encrypt. != 0 encrypt algorith */
	int iv_len;
	int icv_len;
	int priority;
	int ack_policy;
	u8 crc_err;
	u8 dst[ETH_ALEN];
	u8 src[ETH_ALEN];
	u8 ta[ETH_ALEN];
	u8 ra[ETH_ALEN];
	u8 bssid[ETH_ALEN];
	u8 tcpchk_valid; /* 0: invalid, 1: valid */
	u8 ip_chkrpt; /* 0: incorrect, 1: correct */
	u8 tcp_chkrpt; /* 0: incorrect, 1: correct */
	u8 signal_qual;
	s8 rx_mimo_signal_qual[2];
	u8 mcs_rate;
	u8 htc;
	u8 signal_strength;
	};

	/*
	accesser of recv_priv: recv_entry(dispatch / passive level);
	recv_thread(passive) ; returnpkt(dispatch)
	; halt(passive) ;

	using enter_critical section to protect
	*/
	struct recv_priv {
	spinlock_t lock;
	struct semaphore recv_sema;
	struct semaphore terminate_recvthread_sema;
	struct __queue free_recv_queue;
	struct __queue recv_pending_queue;
	u8 *pallocated_frame_buf;
	u8 *precv_frame_buf;
	uint free_recvframe_cnt;
	struct _adapter *adapter;
	uint rx_bytes;
	uint rx_pkts;
	uint rx_drop;
	uint rx_icv_err;
	uint rx_largepacket_crcerr;
	uint rx_smallpacket_crcerr;
	uint rx_middlepacket_crcerr;
	struct semaphore allrxreturnevt;
	u8 rx_pending_cnt;
	uint ff_hwaddr;
	struct tasklet_struct recv_tasklet;
	struct sk_buff_head free_recv_skb_queue;
	struct sk_buff_head rx_skb_queue;
	u8 *pallocated_recv_buf;
	u8 precv_buf; / 4 alignment */
	struct __queue free_recv_buf_queue;
	u32 free_recv_buf_queue_cnt;
	/* For the phy informatiom */
	s8 rssi;
	u8 signal;
	u8 noise;
	u8 fw_rssi;
	struct smooth_rssi_data signal_qual_data;
	struct smooth_rssi_data signal_strength_data;
	};

	struct sta_recv_priv {
	spinlock_t lock;
	sint option;
	struct __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;
	};

	#include "rtl8712_recv.h"

	/* get a free recv_frame from pfree_recv_queue */
	union recv_frame r8712_alloc_recvframe(struct __queue pfree_recv_queue);
	union recv_frame r8712_dequeue_recvframe(struct __queue queue);
	int r8712_enqueue_recvframe(union recv_frame *precvframe,
	struct __queue *queue);
	int r8712_free_recvframe(union recv_frame *precvframe,
	struct __queue *pfree_recv_queue);
	void r8712_free_recvframe_queue(struct __queue *pframequeue,
	struct __queue *pfree_recv_queue);
	void r8712_init_recvframe(union recv_frame *precvframe,
	struct recv_priv *precvpriv);
	int r8712_wlanhdr_to_ethhdr(union recv_frame *precvframe);
	int recv_func(struct _adapter padapter, void pcontext);

	static inline u8 get_rxmem(union recv_frame precvframe)
	{
	/* always return rx_head... */
	if (precvframe == NULL)
	return NULL;
	return precvframe->u.hdr.rx_head;
	}

	static inline u8 get_rx_status(union recv_frame precvframe)
	{
	return get_rxmem(precvframe);
	}

	static inline u8 get_recvframe_data(union recv_frame precvframe)
	{
	/* always return rx_data */
	if (precvframe == NULL)
	return NULL;
	return precvframe->u.hdr.rx_data;
	}

	static inline 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;
	}

	static inline u8 recvframe_pull(union recv_frame precvframe, sint sz)
	{
	/* 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;
	}

	static inline u8 recvframe_put(union recv_frame precvframe, sint 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 == 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;
	}

	static inline 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;
	}

	static inline _buffer get_rxbuf_desc(union recv_frame precvframe)
	{
	_buffer *buf_desc;
	if (precvframe == NULL)
	return NULL;
	return buf_desc;
	}

	static inline 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 *)(((addr_t)rxmem >> RXFRAME_ALIGN) <<
	RXFRAME_ALIGN);
	}

	static inline 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;
	}

	static inline 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;
	}

	static inline 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;
	}

	static inline sint get_recvframe_len(union recv_frame *precvframe)
	{
	return precvframe->u.hdr.len;
	}

	struct sta_info;

	void _r8712_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv);
	sint r8712_recvframe_chkmic(struct _adapter *adapter,
	union recv_frame *precvframe);
	union recv_frame r8712_decryptor(struct _adapter adapter,
	union recv_frame *precv_frame);
	union recv_frame r8712_recvframe_chk_defrag(struct _adapter adapter,
	union recv_frame *precv_frame);
	union recv_frame r8712_recvframe_defrag(struct _adapter adapter,
	struct __queue *defrag_q);
	union recv_frame r8712_recvframe_chk_defrag_new(struct _adapter adapter,
	union recv_frame *precv_frame);
	union recv_frame r8712_recvframe_defrag_new(struct _adapter adapter,
	struct __queue *defrag_q,
	union recv_frame *precv_frame);
	int r8712_recv_decache(union recv_frame *precv_frame, u8 bretry,
	struct stainfo_rxcache *prxcache);
	int r8712_sta2sta_data_frame(struct _adapter *adapter,
	union recv_frame *precv_frame,
	struct sta_info **psta);
	int r8712_ap2sta_data_frame(struct _adapter *adapter,
	union recv_frame *precv_frame,
	struct sta_info **psta);
	int r8712_sta2ap_data_frame(struct _adapter *adapter,
	union recv_frame *precv_frame,
	struct sta_info **psta);
	int r8712_validate_recv_ctrl_frame(struct _adapter *adapter,
	union recv_frame *precv_frame);
	int r8712_validate_recv_mgnt_frame(struct _adapter *adapter,
	union recv_frame *precv_frame);
	int r8712_validate_recv_data_frame(struct _adapter *adapter,
	union recv_frame *precv_frame);
	int r8712_validate_recv_frame(struct _adapter *adapter,
	union recv_frame *precv_frame);
	union recv_frame r8712_portctrl(struct _adapter adapter,
	union recv_frame *precv_frame);
	void r8712_mgt_dispatcher(struct _adapter padapter, u8 pframe, uint len);
	int r8712_amsdu_to_msdu(struct _adapter padapter, union recv_frame prframe);

	#endif