Commit 7f8a0fba authored by Larry Finger's avatar Larry Finger Committed by Greg Kroah-Hartman
Browse files

staging: r8188eu: Add files for new driver - part 30 



This commit adds files include/rtw_security.h, include/rtw_sreset.h,
include/rtw_version.h, and include/rtw_xmit.h.

Signed-off-by: default avatarLarry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent fff3340f

drivers/staging/rtl8188eu/include/rtw_security.h

0 → 100644
+383 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2007 - 2011 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_SECURITY_H_

#define __RTW_SECURITY_H_



#include <osdep_service.h>

#include <drv_types.h>



#define _NO_PRIVACY_			0x0

#define _WEP40_				0x1

#define _TKIP_				0x2

#define _TKIP_WTMIC_			0x3

#define _AES_				0x4

#define _WEP104_			0x5

#define _WEP_WPA_MIXED_			0x07  /*  WEP + WPA */

#define _SMS4_				0x06



#define is_wep_enc(alg) (((alg) == _WEP40_) || ((alg) == _WEP104_))



#define _WPA_IE_ID_	0xdd

#define _WPA2_IE_ID_	0x30



#define SHA256_MAC_LEN 32

#define AES_BLOCK_SIZE 16

#define AES_PRIV_SIZE (4 * 44)



enum {

	ENCRYP_PROTOCOL_OPENSYS,   /* open system */

	ENCRYP_PROTOCOL_WEP,       /* WEP */

	ENCRYP_PROTOCOL_WPA,       /* WPA */

	ENCRYP_PROTOCOL_WPA2,      /* WPA2 */

	ENCRYP_PROTOCOL_WAPI,      /* WAPI: Not support in this version */

	ENCRYP_PROTOCOL_MAX

};





#ifndef Ndis802_11AuthModeWPA2

#define Ndis802_11AuthModeWPA2 (Ndis802_11AuthModeWPANone + 1)

#endif



#ifndef Ndis802_11AuthModeWPA2PSK

#define Ndis802_11AuthModeWPA2PSK (Ndis802_11AuthModeWPANone + 2)

#endif



union pn48	{

	u64	val;



#ifdef __LITTLE_ENDIAN

	struct {

		u8 TSC0;

		u8 TSC1;

		u8 TSC2;

		u8 TSC3;

		u8 TSC4;

		u8 TSC5;

		u8 TSC6;

		u8 TSC7;

	} _byte_;



#elif defined(__BIG_ENDIAN)



	struct {

		u8 TSC7;

		u8 TSC6;

		u8 TSC5;

		u8 TSC4;

		u8 TSC3;

		u8 TSC2;

		u8 TSC1;

		u8 TSC0;

	} _byte_;

#endif

};



union Keytype {

	u8   skey[16];

	u32    lkey[4];

};



struct rt_pmkid_list {

	u8	bUsed;

	u8	Bssid[6];

	u8	PMKID[16];

	u8	SsidBuf[33];

	u8	*ssid_octet;

	u16	ssid_length;

};



struct security_priv {

	u32	  dot11AuthAlgrthm;	/*  802.11 auth, could be open,

					 * shared, 8021x and authswitch */

	u32	  dot11PrivacyAlgrthm;	/*  This specify the privacy for

					 * shared auth. algorithm. */

	/* WEP */

	u32	  dot11PrivacyKeyIndex;	/*  this is only valid for legendary

					 * wep, 0~3 for key id.(tx key index) */

	union Keytype dot11DefKey[4];	/*  this is only valid for def. key */

	u32	dot11DefKeylen[4];

	u32 dot118021XGrpPrivacy;	/*  This specify the privacy algthm.

					 * used for Grp key */

	u32	dot118021XGrpKeyid;	/*  key id used for Grp Key

					 * ( tx key index) */

	union Keytype	dot118021XGrpKey[4];	/*  802.1x Group Key,

						 * for inx0 and inx1 */

	union Keytype	dot118021XGrptxmickey[4];

	union Keytype	dot118021XGrprxmickey[4];

	union pn48	dot11Grptxpn;		/* PN48 used for Grp Key xmit.*/

	union pn48	dot11Grprxpn;		/* PN48 used for Grp Key recv.*/

#ifdef CONFIG_88EU_AP_MODE

	/* extend security capabilities for AP_MODE */

	unsigned int dot8021xalg;/* 0:disable, 1:psk, 2:802.1x */

	unsigned int wpa_psk;/* 0:disable, bit(0): WPA, bit(1):WPA2 */

	unsigned int wpa_group_cipher;

	unsigned int wpa2_group_cipher;

	unsigned int wpa_pairwise_cipher;

	unsigned int wpa2_pairwise_cipher;

#endif

	u8 wps_ie[MAX_WPS_IE_LEN];/* added in assoc req */

	int wps_ie_len;

	u8	binstallGrpkey;

	u8	busetkipkey;

	u8	bcheck_grpkey;

	u8	bgrpkey_handshake;

	s32	sw_encrypt;/* from registry_priv */

	s32	sw_decrypt;/* from registry_priv */

	s32	hw_decrypted;/* if the rx packets is hw_decrypted==false,i

			      * it means the hw has not been ready. */



	/* keeps the auth_type & enc_status from upper layer

	 * ioctl(wpa_supplicant or wzc) */

	u32 ndisauthtype;	/*  NDIS_802_11_AUTHENTICATION_MODE */

	u32 ndisencryptstatus;	/*  NDIS_802_11_ENCRYPTION_STATUS */

	struct wlan_bssid_ex sec_bss;  /* for joinbss (h2c buffer) usage */

	struct ndis_802_11_wep ndiswep;

	u8 assoc_info[600];

	u8 szofcapability[256]; /* for wpa2 usage */

	u8 oidassociation[512]; /* for wpa/wpa2 usage */

	u8 authenticator_ie[256];  /* store ap security information element */

	u8 supplicant_ie[256];  /* store sta security information element */



	/* for tkip countermeasure */

	u32 last_mic_err_time;

	u8	btkip_countermeasure;

	u8	btkip_wait_report;

	u32 btkip_countermeasure_time;



	/*  */

	/*  For WPA2 Pre-Authentication. */

	/*  */

	struct rt_pmkid_list PMKIDList[NUM_PMKID_CACHE];

	u8	PMKIDIndex;

	u8 bWepDefaultKeyIdxSet;

};



struct sha256_state {

	u64 length;

	u32 state[8], curlen;

	u8 buf[64];

};



#define GET_ENCRY_ALGO(psecuritypriv, psta, encry_algo, bmcst)		\

do {									\

	switch (psecuritypriv->dot11AuthAlgrthm) {			\

	case dot11AuthAlgrthm_Open:					\

	case dot11AuthAlgrthm_Shared:					\

	case dot11AuthAlgrthm_Auto:					\

		encry_algo = (u8)psecuritypriv->dot11PrivacyAlgrthm;	\

		break;							\

	case dot11AuthAlgrthm_8021X:					\

		if (bmcst)						\

			encry_algo = (u8)psecuritypriv->dot118021XGrpPrivacy;\

		else							\

			encry_algo = (u8)psta->dot118021XPrivacy;	\

		break;							\

	case dot11AuthAlgrthm_WAPI:					\

		encry_algo = (u8)psecuritypriv->dot11PrivacyAlgrthm;	\

		break;							\

	}								\

} while (0)



#define SET_ICE_IV_LEN(iv_len, icv_len, encrypt)			\

do {									\

	switch (encrypt) {						\

	case _WEP40_:							\

	case _WEP104_:							\

		iv_len = 4;						\

		icv_len = 4;						\

		break;							\

	case _TKIP_:							\

		iv_len = 8;						\

		icv_len = 4;						\

		break;							\

	case _AES_:							\

		iv_len = 8;						\

		icv_len = 8;						\

		break;							\

	case _SMS4_:							\

		iv_len = 18;						\

		icv_len = 16;						\

		break;							\

	default:							\

		iv_len = 0;						\

		icv_len = 0;						\

		break;							\

	}								\

} while (0)





#define GET_TKIP_PN(iv, dot11txpn)					\

do {									\

	dot11txpn._byte_.TSC0 = iv[2];					\

	dot11txpn._byte_.TSC1 = iv[0];					\

	dot11txpn._byte_.TSC2 = iv[4];					\

	dot11txpn._byte_.TSC3 = iv[5];					\

	dot11txpn._byte_.TSC4 = iv[6];					\

	dot11txpn._byte_.TSC5 = iv[7];					\

} while (0)





#define ROL32(A, n)	(((A) << (n)) | (((A)>>(32-(n)))  & ((1UL << (n)) - 1)))

#define ROR32(A, n)	ROL32((A), 32-(n))



struct mic_data {

	u32  K0, K1;         /*  Key */

	u32  L, R;           /*  Current state */

	u32  M;              /*  Message accumulator (single word) */

	u32  nBytesInM;      /*  # bytes in M */

};



extern const u32 Te0[256];

extern const u32 Te1[256];

extern const u32 Te2[256];

extern const u32 Te3[256];

extern const u32 Te4[256];

extern const u32 Td0[256];

extern const u32 Td1[256];

extern const u32 Td2[256];

extern const u32 Td3[256];

extern const u32 Td4[256];

extern const u32 rcon[10];

extern const u8 Td4s[256];

extern const u8 rcons[10];



#define RCON(i) (rcons[(i)] << 24)



static inline u32 rotr(u32 val, int bits)

{

	return (val >> bits) | (val << (32 - bits));

}



#define TE0(i) Te0[((i) >> 24) & 0xff]

#define TE1(i) rotr(Te0[((i) >> 16) & 0xff], 8)

#define TE2(i) rotr(Te0[((i) >> 8) & 0xff], 16)

#define TE3(i) rotr(Te0[(i) & 0xff], 24)

#define TE41(i) ((Te0[((i) >> 24) & 0xff] << 8) & 0xff000000)

#define TE42(i) (Te0[((i) >> 16) & 0xff] & 0x00ff0000)

#define TE43(i) (Te0[((i) >> 8) & 0xff] & 0x0000ff00)

#define TE44(i) ((Te0[(i) & 0xff] >> 8) & 0x000000ff)

#define TE421(i) ((Te0[((i) >> 16) & 0xff] << 8) & 0xff000000)

#define TE432(i) (Te0[((i) >> 8) & 0xff] & 0x00ff0000)

#define TE443(i) (Te0[(i) & 0xff] & 0x0000ff00)

#define TE414(i) ((Te0[((i) >> 24) & 0xff] >> 8) & 0x000000ff)

#define TE4(i) ((Te0[(i)] >> 8) & 0x000000ff)



#define TD0(i) Td0[((i) >> 24) & 0xff]

#define TD1(i) rotr(Td0[((i) >> 16) & 0xff], 8)

#define TD2(i) rotr(Td0[((i) >> 8) & 0xff], 16)

#define TD3(i) rotr(Td0[(i) & 0xff], 24)

#define TD41(i) (Td4s[((i) >> 24) & 0xff] << 24)

#define TD42(i) (Td4s[((i) >> 16) & 0xff] << 16)

#define TD43(i) (Td4s[((i) >> 8) & 0xff] << 8)

#define TD44(i) (Td4s[(i) & 0xff])

#define TD0_(i) Td0[(i) & 0xff]

#define TD1_(i) rotr(Td0[(i) & 0xff], 8)

#define TD2_(i) rotr(Td0[(i) & 0xff], 16)

#define TD3_(i) rotr(Td0[(i) & 0xff], 24)



#define GETU32(pt) (((u32)(pt)[0] << 24) ^ ((u32)(pt)[1] << 16) ^ \

			((u32)(pt)[2] <<  8) ^ ((u32)(pt)[3]))



#define PUTU32(ct, st) { \

(ct)[0] = (u8)((st) >> 24); (ct)[1] = (u8)((st) >> 16); \

(ct)[2] = (u8)((st) >>  8); (ct)[3] = (u8)(st); }



#define WPA_GET_BE32(a) ((((u32)(a)[0]) << 24) | (((u32)(a)[1]) << 16) | \

			 (((u32)(a)[2]) << 8) | ((u32)(a)[3]))



#define WPA_PUT_LE16(a, val)			\

	do {					\

		(a)[1] = ((u16)(val)) >> 8;	\

		(a)[0] = ((u16)(val)) & 0xff;	\

	} while (0)



#define WPA_PUT_BE32(a, val)					\

	do {							\

		(a)[0] = (u8)((((u32)(val)) >> 24) & 0xff);	\

		(a)[1] = (u8)((((u32)(val)) >> 16) & 0xff);	\

		(a)[2] = (u8)((((u32)(val)) >> 8) & 0xff);	\

		(a)[3] = (u8)(((u32)(val)) & 0xff);		\

	} while (0)



#define WPA_PUT_BE64(a, val)				\

	do {						\

		(a)[0] = (u8)(((u64)(val)) >> 56);	\

		(a)[1] = (u8)(((u64)(val)) >> 48);	\

		(a)[2] = (u8)(((u64)(val)) >> 40);	\

		(a)[3] = (u8)(((u64)(val)) >> 32);	\

		(a)[4] = (u8)(((u64)(val)) >> 24);	\

		(a)[5] = (u8)(((u64)(val)) >> 16);	\

		(a)[6] = (u8)(((u64)(val)) >> 8);	\

		(a)[7] = (u8)(((u64)(val)) & 0xff);	\

	} while (0)



/* ===== start - public domain SHA256 implementation ===== */



/* This is based on SHA256 implementation in LibTomCrypt that was released into

 * public domain by Tom St Denis. */



/* the K array */

static const unsigned long K[64] = {

	0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,

	0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,

	0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,

	0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,

	0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,

	0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,

	0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,

	0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,

	0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,

	0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,

	0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,

	0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,

	0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL

};



/* Various logical functions */

#define RORc(x, y) \

	(((((unsigned long)(x) & 0xFFFFFFFFUL) >> (unsigned long)((y)&31)) | \

	 ((unsigned long)(x) << (unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)

#define Ch(x, y ,z)       (z ^ (x & (y ^ z)))

#define Maj(x, y, z)      (((x | y) & z) | (x & y))

#define S(x, n)         RORc((x), (n))

#define R(x, n)         (((x)&0xFFFFFFFFUL)>>(n))

#define Sigma0(x)       (S(x, 2) ^ S(x, 13) ^ S(x, 22))

#define Sigma1(x)       (S(x, 6) ^ S(x, 11) ^ S(x, 25))

#define Gamma0(x)       (S(x, 7) ^ S(x, 18) ^ R(x, 3))

#define Gamma1(x)       (S(x, 17) ^ S(x, 19) ^ R(x, 10))

#ifndef MIN

#define MIN(x, y) (((x) < (y)) ? (x) : (y))

#endif



void rtw_secmicsetkey(struct mic_data *pmicdata, u8 *key);

void rtw_secmicappendbyte(struct mic_data *pmicdata, u8 b);

void rtw_secmicappend(struct mic_data *pmicdata, u8 *src, u32 nBytes);

void rtw_secgetmic(struct mic_data *pmicdata, u8 *dst);

void rtw_seccalctkipmic(u8 *key, u8 *header, u8 *data, u32 data_len,

			u8 *Miccode, u8   priority);

u32 rtw_aes_encrypt(struct adapter *padapter, u8 *pxmitframe);

u32 rtw_tkip_encrypt(struct adapter *padapter, u8 *pxmitframe);

void rtw_wep_encrypt(struct adapter *padapter, u8  *pxmitframe);

u32 rtw_aes_decrypt(struct adapter *padapter, u8  *precvframe);

u32 rtw_tkip_decrypt(struct adapter *padapter, u8  *precvframe);

void rtw_wep_decrypt(struct adapter *padapter, u8  *precvframe);

void rtw_use_tkipkey_handler(void *FunctionContext);



#endif	/* __RTL871X_SECURITY_H_ */

drivers/staging/rtl8188eu/include/rtw_sreset.h

0 → 100644
+50 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * 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_SRESET_C_

#define _RTW_SRESET_C_



#include <osdep_service.h>

#include <drv_types.h>



struct sreset_priv {

	struct mutex	silentreset_mutex;

	u8	silent_reset_inprogress;

	u8	Wifi_Error_Status;

	unsigned long last_tx_time;

	unsigned long last_tx_complete_time;

};



#include <rtl8188e_hal.h>



#define	WIFI_STATUS_SUCCESS		0

#define	USB_VEN_REQ_CMD_FAIL	BIT0

#define	USB_READ_PORT_FAIL		BIT1

#define	USB_WRITE_PORT_FAIL		BIT2

#define	WIFI_MAC_TXDMA_ERROR	BIT3

#define   WIFI_TX_HANG				BIT4

#define	WIFI_RX_HANG				BIT5

#define		WIFI_IF_NOT_EXIST			BIT6



void sreset_init_value(struct adapter *padapter);

void sreset_reset_value(struct adapter *padapter);

u8 sreset_get_wifi_status(struct adapter *padapter);

void sreset_set_wifi_error_status(struct adapter *padapter, u32 status);



#endif

drivers/staging/rtl8188eu/include/rtw_version.h

0 → 100644
+1 −0
Original line number Diff line number Diff line 
#define DRIVERVERSION	"v4.1.4_6773.20130222"

drivers/staging/rtl8188eu/include/rtw_xmit.h

0 → 100644
+384 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2007 - 2011 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_XMIT_H_

#define _RTW_XMIT_H_



#include <osdep_service.h>

#include <drv_types.h>



#define MAX_XMITBUF_SZ	(20480)	/*  20k */

#define NR_XMITBUFF		(4)



#define XMITBUF_ALIGN_SZ	4



/*  xmit extension buff defination */

#define MAX_XMIT_EXTBUF_SZ	(1536)

#define NR_XMIT_EXTBUFF		(32)



#define MAX_NUMBLKS		(1)



#define XMIT_VO_QUEUE		(0)

#define XMIT_VI_QUEUE		(1)

#define XMIT_BE_QUEUE		(2)

#define XMIT_BK_QUEUE		(3)



#define VO_QUEUE_INX		0

#define VI_QUEUE_INX		1

#define BE_QUEUE_INX		2

#define BK_QUEUE_INX		3

#define BCN_QUEUE_INX		4

#define MGT_QUEUE_INX		5

#define HIGH_QUEUE_INX		6

#define TXCMD_QUEUE_INX		7



#define HW_QUEUE_ENTRY		8



#define WEP_IV(pattrib_iv, dot11txpn, keyidx)\

do {\

	pattrib_iv[0] = dot11txpn._byte_.TSC0;\

	pattrib_iv[1] = dot11txpn._byte_.TSC1;\

	pattrib_iv[2] = dot11txpn._byte_.TSC2;\

	pattrib_iv[3] = ((keyidx & 0x3)<<6);\

	dot11txpn.val = (dot11txpn.val == 0xffffff) ? 0 : (dot11txpn.val+1);\

} while (0)





#define TKIP_IV(pattrib_iv, dot11txpn, keyidx)\

do {\

	pattrib_iv[0] = dot11txpn._byte_.TSC1;\

	pattrib_iv[1] = (dot11txpn._byte_.TSC1 | 0x20) & 0x7f;\

	pattrib_iv[2] = dot11txpn._byte_.TSC0;\

	pattrib_iv[3] = BIT(5) | ((keyidx & 0x3)<<6);\

	pattrib_iv[4] = dot11txpn._byte_.TSC2;\

	pattrib_iv[5] = dot11txpn._byte_.TSC3;\

	pattrib_iv[6] = dot11txpn._byte_.TSC4;\

	pattrib_iv[7] = dot11txpn._byte_.TSC5;\

	dot11txpn.val = dot11txpn.val == 0xffffffffffffULL ? 0 : (dot11txpn.val+1);\

} while (0)



#define AES_IV(pattrib_iv, dot11txpn, keyidx)\

do {							\

	pattrib_iv[0] = dot11txpn._byte_.TSC0;		\

	pattrib_iv[1] = dot11txpn._byte_.TSC1;		\

	pattrib_iv[2] = 0;				\

	pattrib_iv[3] = BIT(5) | ((keyidx & 0x3)<<6);	\

	pattrib_iv[4] = dot11txpn._byte_.TSC2;		\

	pattrib_iv[5] = dot11txpn._byte_.TSC3;		\

	pattrib_iv[6] = dot11txpn._byte_.TSC4;		\

	pattrib_iv[7] = dot11txpn._byte_.TSC5;		\

	dot11txpn.val = dot11txpn.val == 0xffffffffffffULL ? 0 : (dot11txpn.val+1);\

} while (0)



#define HWXMIT_ENTRY	4



#define TXDESC_SIZE 32



#define PACKET_OFFSET_SZ (8)

#define TXDESC_OFFSET (TXDESC_SIZE + PACKET_OFFSET_SZ)



struct tx_desc {

	/* DWORD 0 */

	__le32 txdw0;

	__le32 txdw1;

	__le32 txdw2;

	__le32 txdw3;

	__le32 txdw4;

	__le32 txdw5;

	__le32 txdw6;

	__le32 txdw7;

};



union txdesc {

	struct tx_desc txdesc;

	unsigned int value[TXDESC_SIZE>>2];

};



struct	hw_xmit	{

	struct __queue *sta_queue;

	int	accnt;

};



/* reduce size */

struct pkt_attrib {

	u8	type;

	u8	subtype;

	u8	bswenc;

	u8	dhcp_pkt;

	u16	ether_type;

	u16	seqnum;

	u16	pkt_hdrlen;	/* the original 802.3 pkt header len */

	u16	hdrlen;		/* the WLAN Header Len */

	u32	pktlen;		/* the original 802.3 pkt raw_data len (not include

				 * ether_hdr data) */

	u32	last_txcmdsz;

	u8	nr_frags;

	u8	encrypt;	/* when 0 indicate no encrypt. when non-zero,

				 * indicate the encrypt algorith */

	u8	iv_len;

	u8	icv_len;

	u8	iv[18];

	u8	icv[16];

	u8	priority;

	u8	ack_policy;

	u8	mac_id;

	u8	vcs_mode;	/* virtual carrier sense method */

	u8	dst[ETH_ALEN];

	u8	src[ETH_ALEN];

	u8	ta[ETH_ALEN];

	u8	ra[ETH_ALEN];

	u8	key_idx;

	u8	qos_en;

	u8	ht_en;

	u8	raid;/* rate adpative id */

	u8	bwmode;

	u8	ch_offset;/* PRIME_CHNL_OFFSET */

	u8	sgi;/* short GI */

	u8	ampdu_en;/* tx ampdu enable */

	u8	mdata;/* more data bit */

	u8	pctrl;/* per packet txdesc control enable */

	u8	triggered;/* for ap mode handling Power Saving sta */

	u8	qsel;

	u8	eosp;

	u8	rate;

	u8	intel_proxim;

	u8	retry_ctrl;

	struct sta_info *psta;

};



#define WLANHDR_OFFSET	64



#define NULL_FRAMETAG		(0x0)

#define DATA_FRAMETAG		0x01

#define L2_FRAMETAG		0x02

#define MGNT_FRAMETAG		0x03

#define AMSDU_FRAMETAG	0x04



#define EII_FRAMETAG		0x05

#define IEEE8023_FRAMETAG  0x06



#define MP_FRAMETAG		0x07



#define TXAGG_FRAMETAG	0x08



struct  submit_ctx {

	u32 submit_time; /* */

	u32 timeout_ms; /* <0: not synchronous, 0: wait forever, >0: up to ms waiting */

	int status; /* status for operation */

	struct completion done;

};



enum {

	RTW_SCTX_SUBMITTED = -1,

	RTW_SCTX_DONE_SUCCESS = 0,

	RTW_SCTX_DONE_UNKNOWN,

	RTW_SCTX_DONE_TIMEOUT,

	RTW_SCTX_DONE_BUF_ALLOC,

	RTW_SCTX_DONE_BUF_FREE,

	RTW_SCTX_DONE_WRITE_PORT_ERR,

	RTW_SCTX_DONE_TX_DESC_NA,

	RTW_SCTX_DONE_TX_DENY,

	RTW_SCTX_DONE_CCX_PKT_FAIL,

	RTW_SCTX_DONE_DRV_STOP,

	RTW_SCTX_DONE_DEV_REMOVE,

};



void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms);

int rtw_sctx_wait(struct submit_ctx *sctx);

void rtw_sctx_done_err(struct submit_ctx **sctx, int status);

void rtw_sctx_done(struct submit_ctx **sctx);



struct xmit_buf {

	struct list_head list;

	struct adapter *padapter;

	u8 *pallocated_buf;

	u8 *pbuf;

	void *priv_data;

	u16 ext_tag; /*  0: Normal xmitbuf, 1: extension xmitbuf. */

	u16 flags;

	u32 alloc_sz;

	u32  len;

	struct submit_ctx *sctx;

	u32	ff_hwaddr;

	struct urb *pxmit_urb[8];

	dma_addr_t dma_transfer_addr;	/* (in) dma addr for transfer_buffer */

	u8 bpending[8];

	int last[8];

};



struct xmit_frame {

	struct list_head list;

	struct pkt_attrib attrib;

	struct sk_buff *pkt;

	int	frame_tag;

	struct adapter *padapter;

	u8	*buf_addr;

	struct xmit_buf *pxmitbuf;



	u8	agg_num;

	s8	pkt_offset;

	u8 ack_report;

};



struct tx_servq {

	struct list_head tx_pending;

	struct __queue sta_pending;

	int qcnt;

};



struct sta_xmit_priv {

	spinlock_t lock;

	int	option;

	int	apsd_setting;	/* When bit mask is on, the associated edca

				 * queue supports APSD. */

	struct tx_servq	be_q;			/* priority == 0,3 */

	struct tx_servq	bk_q;			/* priority == 1,2 */

	struct tx_servq	vi_q;			/* priority == 4,5 */

	struct tx_servq	vo_q;			/* priority == 6,7 */

	struct list_head legacy_dz;

	struct list_head apsd;

	u16 txseq_tid[16];

};



struct	hw_txqueue {

	volatile int	head;

	volatile int	tail;

	volatile int	free_sz;	/* in units of 64 bytes */

	volatile int      free_cmdsz;

	volatile int	 txsz[8];

	uint	ff_hwaddr;

	uint	cmd_hwaddr;

	int	ac_tag;

};



struct agg_pkt_info {

	u16 offset;

	u16 pkt_len;

};



struct	xmit_priv {

	spinlock_t lock;

	struct semaphore xmit_sema;

	struct semaphore terminate_xmitthread_sema;

	struct __queue be_pending;

	struct __queue bk_pending;

	struct __queue vi_pending;

	struct __queue vo_pending;

	struct __queue bm_pending;

	u8 *pallocated_frame_buf;

	u8 *pxmit_frame_buf;

	uint free_xmitframe_cnt;

	struct __queue free_xmit_queue;

	uint	frag_len;

	struct adapter	*adapter;

	u8   vcs_setting;

	u8	vcs;

	u8	vcs_type;

	u64	tx_bytes;

	u64	tx_pkts;

	u64	tx_drop;

	u64	last_tx_bytes;

	u64	last_tx_pkts;

	struct hw_xmit *hwxmits;

	u8	hwxmit_entry;

	u8	wmm_para_seq[4];/* sequence for wmm ac parameter strength

				 * from large to small. it's value is 0->vo,

				 * 1->vi, 2->be, 3->bk. */

	struct semaphore tx_retevt;/* all tx return event; */

	u8		txirp_cnt;/*  */

	struct tasklet_struct xmit_tasklet;

	/* per AC pending irp */

	int beq_cnt;

	int bkq_cnt;

	int viq_cnt;

	int voq_cnt;

	struct __queue free_xmitbuf_queue;

	struct __queue pending_xmitbuf_queue;

	u8 *pallocated_xmitbuf;

	u8 *pxmitbuf;

	uint free_xmitbuf_cnt;

	struct __queue free_xmit_extbuf_queue;

	u8 *pallocated_xmit_extbuf;

	u8 *pxmit_extbuf;

	uint free_xmit_extbuf_cnt;

	u16	nqos_ssn;

	int	ack_tx;

	struct mutex ack_tx_mutex;

	struct submit_ctx ack_tx_ops;

};



struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv);

s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv,

			 struct xmit_buf *pxmitbuf);

struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv);

s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv,

		     struct xmit_buf *pxmitbuf);

void rtw_count_tx_stats(struct adapter *padapter,

			struct xmit_frame *pxmitframe, int sz);

void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len);

s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr,

		     struct pkt_attrib *pattrib);

s32 rtw_put_snap(u8 *data, u16 h_proto);



struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv);

s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv,

		       struct xmit_frame *pxmitframe);

void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv,

			      struct __queue *pframequeue);

struct tx_servq *rtw_get_sta_pending(struct adapter *padapter,

				     struct sta_info *psta, int up, u8 *ac);

s32 rtw_xmitframe_enqueue(struct adapter *padapter,

			  struct xmit_frame *pxmitframe);

struct xmit_frame *rtw_dequeue_xframe(struct xmit_priv *pxmitpriv,

				      struct hw_xmit *phwxmit_i, int entry);



s32 rtw_xmit_classifier(struct adapter *padapter,

			struct xmit_frame *pxmitframe);

u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib);

#define rtw_wlan_pkt_size(f) rtw_calculate_wlan_pkt_size_by_attribue(&f->attrib)

s32 rtw_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt,

			   struct xmit_frame *pxmitframe);

s32 _rtw_init_hw_txqueue(struct hw_txqueue *phw_txqueue, u8 ac_tag);

void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv);

s32 rtw_txframes_pending(struct adapter *padapter);

s32 rtw_txframes_sta_ac_pending(struct adapter *padapter,

				struct pkt_attrib *pattrib);

void rtw_init_hwxmits(struct hw_xmit *phwxmit, int entry);

s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter);

void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv);

void rtw_alloc_hwxmits(struct adapter *padapter);

void rtw_free_hwxmits(struct adapter *padapter);

s32 rtw_xmit(struct adapter *padapter, struct sk_buff **pkt);



#if defined(CONFIG_88EU_AP_MODE)

int xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe);

void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta);

void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta);

void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta);

#endif



u8	qos_acm(u8 acm_mask, u8 priority);

u32	rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe);

int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms);

void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status);



/* include after declaring struct xmit_buf, in order to avoid warning */

#include <xmit_osdep.h>



#endif	/* _RTL871X_XMIT_H_ */