rtmp.h

r73模块的无线网卡在Linux下的驱动程序

					case 5220000:	 ch = 44;  /* UNII */  break;	  \
					case 5240000:	 ch = 48;  /* UNII */  break;	  \
					case 5260000:	 ch = 52;  /* UNII */  break;	  \
					case 5280000:	 ch = 56;  /* UNII */  break;	  \
					case 5300000:	 ch = 60;  /* UNII */  break;	  \
					case 5320000:	 ch = 64;  /* UNII */  break;	  \
					case 5745000:	 ch = 149; /* UNII */  break;	  \
					case 5765000:	 ch = 153; /* UNII */  break;	  \
					case 5785000:	 ch = 157; /* UNII */  break;	  \
					case 5805000:	 ch = 161; /* UNII */  break;	  \
					case 5825000:	 ch = 165; /* UNII */  break;	  \
					case 5500000:	 ch = 100; /* HiperLAN2 */	break;	   \
					case 5520000:	 ch = 104; /* HiperLAN2 */	break;	   \
					case 5540000:	 ch = 108; /* HiperLAN2 */	break;	   \
					case 5560000:	 ch = 112; /* HiperLAN2 */	break;	   \
					case 5580000:	 ch = 116; /* HiperLAN2 */	break;	   \
					case 5600000:	 ch = 120; /* HiperLAN2 */	break;	   \
					case 5620000:	 ch = 124; /* HiperLAN2 */	break;	   \
					case 5640000:	 ch = 128; /* HiperLAN2 */	break;	   \
					case 5660000:	 ch = 132; /* HiperLAN2 */	break;	   \
					case 5680000:	 ch = 136; /* HiperLAN2 */	break;	   \
					case 5700000:	 ch = 140; /* HiperLAN2 */	break;	   \
					case 5170000:	 ch = 34;  /* Japan MMAC */   break;   \
					case 5190000:	 ch = 38;  /* Japan MMAC */   break;   \
					case 5210000:	 ch = 42;  /* Japan MMAC */   break;   \
					case 5230000:	 ch = 46;  /* Japan MMAC */   break;   \
					default:		 ch = 1;	 break; 	\
				}											\
			}


//
// Common fragment list structure -  Identical to the scatter gather frag list structure
//
#define NIC_MAX_PHYS_BUF_COUNT				8

typedef struct _RTMP_SCATTER_GATHER_ELEMENT {
	PVOID		Address;
	ULONG		Length;
	PULONG		Reserved;
} RTMP_SCATTER_GATHER_ELEMENT, *PRTMP_SCATTER_GATHER_ELEMENT;

typedef struct _RTMP_SCATTER_GATHER_LIST {
	ULONG  NumberOfElements;
	PULONG Reserved;
	RTMP_SCATTER_GATHER_ELEMENT Elements[NIC_MAX_PHYS_BUF_COUNT];
} RTMP_SCATTER_GATHER_LIST, *PRTMP_SCATTER_GATHER_LIST;


//
//	Some utility macros
//
#ifndef min
#define min(_a, _b) 	(((_a) < (_b)) ? (_a) : (_b))
#endif

#ifndef max
#define max(_a, _b) 	(((_a) > (_b)) ? (_a) : (_b))
#endif

#define INC_COUNTER(Val)		(Val.QuadPart++)
#define	INC_COUNTER64(Val)		(Val.QuadPart++)

#define INFRA_ON(_p)			(OPSTATUS_TEST_FLAG(_p, fOP_STATUS_INFRA_ON))
#define ADHOC_ON(_p)			(OPSTATUS_TEST_FLAG(_p, fOP_STATUS_ADHOC_ON))


// b0-b3 as User Priority
#define RTMP_SET_PACKET_UP(_p, _prio)				((_p)->cb[10] = ((_p)->cb[10] & 0xf0) | (_prio))
#define RTMP_GET_PACKET_UP(_p)						((_p)->cb[10] & 0x0f)

// b4-b7 as fragment #
#define RTMP_SET_PACKET_FRAGMENTS(_p, number)		((_p)->cb[10] = ((_p)->cb[10] & 0x0f) | (number << 4))
#define RTMP_GET_PACKET_FRAGMENTS(_p)				(((_p)->cb[10] & 0xf0) >> 4)

// 0x0 ~0x7f: TX to AP's own BSS which has the specified AID (this value also as MAC table index)
// 0x80~0xff: TX to a WDS link. b0~6: WDS index
#define RTMP_SET_PACKET_WDS(_p, _wdsidx)			((_p)->cb[11] = _wdsidx)
#define RTMP_GET_PACKET_WDS(_p) 					((_p)->cb[11])

// 0xff: PKTSRC_NDIS, others: local TX buffer index. This value affects how to a packet
#define RTMP_SET_PACKET_SOURCE(_p, _pktsrc) 		((_p)->cb[12]= _pktsrc)
#define RTMP_GET_PACKET_SOURCE(_p)					((_p)->cb[12])

// b0~2: RTS/CTS-to-self protection method
#define RTMP_SET_PACKET_RTS(_p, _num)				((_p)->cb[13] = ((_p)->cb[13] & 0xf8) | (_num))
#define RTMP_GET_PACKET_RTS(_p) 					((_p)->cb[13] & 0x07)

// b3~7: TX rate index
#define RTMP_SET_PACKET_TXRATE(_p, _rate)			((_p)->cb[13] = ((_p)->cb[13] & 0x07) | (_rate << 3))
#define RTMP_GET_PACKET_TXRATE(_p)					(((_p)->cb[13] & 0xf8) >> 3)


#define PKTSRC_NDIS 			0x7f
#define PKTSRC_DRIVER			0x0f

#define	MAKE_802_3_HEADER(_p, _pMac1, _pMac2, _pType)					\
{																		\
	NdisMoveMemory(_p, _pMac1, MAC_ADDR_LEN);							\
	NdisMoveMemory((_p + MAC_ADDR_LEN), _pMac2, MAC_ADDR_LEN);			\
	NdisMoveMemory((_p + MAC_ADDR_LEN * 2), _pType, LENGTH_802_3_TYPE);	\
}

// if pData has no LLC/SNAP (neither RFC1042 nor Bridge tunnel), keep it that way.
// else if the received frame is LLC/SNAP-encaped IPX or APPLETALK, preserve the LLC/SNAP field
// else remove the LLC/SNAP field from the result Ethernet frame
// Patch for WHQL only, which did not turn on Netbios but use IPX within its payload
// Note:
//	   _pData & _DataSize may be altered (remove 8-byte LLC/SNAP) by this MACRO
//	   _pRemovedLLCSNAP: pointer to removed LLC/SNAP; NULL is not removed
#define CONVERT_TO_802_3(_p8023hdr, _pDA, _pSA, _pData, _DataSize, _pRemovedLLCSNAP)	  \
{																		\
	char LLC_Len[2];													\
																		\
	_pRemovedLLCSNAP = NULL;											\
	if (NdisEqualMemory(SNAP_802_1H, _pData, 6)  || 					\
		NdisEqualMemory(SNAP_BRIDGE_TUNNEL, _pData, 6)) 				\
	{																	\
		PUCHAR pProto = _pData + 6; 									\
																		\
		if ((NdisEqualMemory(IPX, pProto, 2) || NdisEqualMemory(APPLE_TALK, pProto, 2)) &&	\
			NdisEqualMemory(SNAP_802_1H, _pData, 6))					\
		{																\
			LLC_Len[0] = (UCHAR)(_DataSize / 256);						\
			LLC_Len[1] = (UCHAR)(_DataSize % 256);						\
			MAKE_802_3_HEADER(_p8023hdr, _pDA, _pSA, LLC_Len);			\
		}																\
		else															\
		{																\
			MAKE_802_3_HEADER(_p8023hdr, _pDA, _pSA, pProto);			\
			_pRemovedLLCSNAP = _pData;									\
			_DataSize -= LENGTH_802_1_H;								\
			_pData += LENGTH_802_1_H;									\
		}																\
	}																	\
	else																\
	{																	\
		LLC_Len[0] = (UCHAR)(_DataSize / 256);							\
		LLC_Len[1] = (UCHAR)(_DataSize % 256);							\
		MAKE_802_3_HEADER(_p8023hdr, _pDA, _pSA, LLC_Len);				\
	}																	\
}

#define RECORD_LATEST_RX_DATA_RATE(_pAd, _pRxD) 								\
{																				\
	if ((_pRxD)->Ofdm)															\
		(_pAd)->LastRxRate = OfdmSignalToRateId[(_pRxD)->PlcpSignal & 0x0f];	\
	else if ((_pRxD)->PlcpSignal == 10) 										\
		(_pAd)->LastRxRate = RATE_1;											\
	else if ((_pRxD)->PlcpSignal == 20) 										\
		(_pAd)->LastRxRate = RATE_2;											\
	else if ((_pRxD)->PlcpSignal == 55) 										\
		(_pAd)->LastRxRate = RATE_5_5;											\
	else																		\
		(_pAd)->LastRxRate = RATE_11;											\
}

// INFRA mode- Address 1 - AP, Address 2 - this STA, Address 3 - DA
// ADHOC mode- Address 1 - DA, Address 2 - this STA, Address 3 - BSSID
#define MAKE_802_11_HEADER(_pAd, _80211hdr, _pDA, _seq) 						\
{																				\
	NdisZeroMemory(&_80211hdr, sizeof(HEADER_802_11));							\
	if (INFRA_ON(_pAd)) 														\
	{																			\
		COPY_MAC_ADDR(_80211hdr.Addr1, _pAd->PortCfg.Bssid);					\
		COPY_MAC_ADDR(_80211hdr.Addr3, _pDA);									\
		_80211hdr.FC.ToDs = 1;													\
	}																			\
	else																		\
	{																			\
		COPY_MAC_ADDR(_80211hdr.Addr1, _pDA);									\
		COPY_MAC_ADDR(_80211hdr.Addr3, _pAd->PortCfg.Bssid);					\
	}																			\
	COPY_MAC_ADDR(_80211hdr.Addr2, _pAd->CurrentAddress);						\
	_80211hdr.Sequence = _seq;													\
	_80211hdr.FC.Type = BTYPE_DATA; 											\
	_80211hdr.FC.PwrMgmt = (_pAd->PortCfg.Psm == PWR_SAVE); 					\
}

//Need to collect each ant's rssi concurrently
//rssi1 is report to pair2 Ant and rss2 is reprot to pair1 Ant when 4 Ant
#define COLLECT_RX_ANTENNA_AVERAGE_RSSI(_pAd, _rssi1, _rssi2)					\
{																				\
	SHORT	AvgRssi;															\
	UCHAR	UsedAnt;															\
	if (_pAd->RxAnt.EvaluatePeriod == 0)									\
	{																		\
		UsedAnt = _pAd->RxAnt.Pair1PrimaryRxAnt;							\
		AvgRssi = _pAd->RxAnt.Pair1AvgRssi[UsedAnt];						\
		if (AvgRssi < 0)													\
			AvgRssi = AvgRssi - (AvgRssi >> 3) + _rssi1;					\
		else																\
			AvgRssi = _rssi1 << 3;											\
		_pAd->RxAnt.Pair1AvgRssi[UsedAnt] = AvgRssi;						\
	}																		\
	else																	\
	{																		\
		UsedAnt = _pAd->RxAnt.Pair1SecondaryRxAnt;							\
		AvgRssi = _pAd->RxAnt.Pair1AvgRssi[UsedAnt];						\
		if ((AvgRssi < 0) && (_pAd->RxAnt.FirstPktArrivedWhenEvaluate))		\
			AvgRssi = AvgRssi - (AvgRssi >> 3) + _rssi1;					\
		else																\
		{																	\
			_pAd->RxAnt.FirstPktArrivedWhenEvaluate = TRUE;					\
			AvgRssi = _rssi1 << 3;											\
		}																	\
		_pAd->RxAnt.Pair1AvgRssi[UsedAnt] = AvgRssi;						\
		_pAd->RxAnt.RcvPktNumWhenEvaluate++;								\
	}																		\
}

#define RELEASE_NDIS_PACKET(_pAd, _pSkb)								\
{																		\
	if (RTMP_GET_PACKET_SOURCE(_pSkb) == PKTSRC_NDIS)					\
	{																	\
		RTUSBFreeSkbBuffer(_pSkb);										\
		_pAd->RalinkCounters.PendingNdisPacketCount --; 				\
	}																	\
	else																\
		RTUSBFreeSkbBuffer(_pSkb);										\
}

#define EnqueueCmd(cmdq, cmdqelmt)		\
{										\
	if (cmdq->size == 0)				\
		cmdq->head = cmdqelmt;			\
	else								\
		cmdq->tail->next = cmdqelmt;	\
	cmdq->tail = cmdqelmt;				\
	cmdqelmt->next = NULL;				\
	cmdq->size++;						\
}

// Free Tx ring descriptor MACRO
// This can only called from complete function since it will change the IO counters
#define	FREE_TX_RING(_p, _b, _t)			\
{										\
	(_t)->InUse 	 = FALSE;			\
	(_t)->LastOne	 = FALSE;			\
	(_t)->IRPPending = FALSE;			\
	(_t)->bWaitingBulkOut = FALSE;		\
	(_t)->BulkOutSize= 0;				\
	(_p)->NextBulkOutIndex[_b] = (((_p)->NextBulkOutIndex[_b] + 1) % TX_RING_SIZE);	\
}

#define	LOCAL_TX_RING_EMPTY(_p, _i)		(((_p)->TxContext[_i][(_p)->NextBulkOutIndex[_i]].InUse) == FALSE)

#define nextTxContext(p, i)	(&((p)->TxContext[i][(p)->NextBulkOutIndex[i]]))

typedef	struct _CmdQElmt	{
	UINT				command;
	PVOID				buffer;
	ULONG				bufferlength;
	BOOLEAN				CmdFromNdis;
	BOOLEAN				SetOperation;
	BOOLEAN				InUse;
	struct _CmdQElmt	*next;
}	CmdQElmt, *PCmdQElmt;

typedef	struct	_CmdQ	{
	UINT		size;
	CmdQElmt	*head;
	CmdQElmt	*tail;
}	CmdQ, *PCmdQ;


////////////////////////////////////////////////////////////////////////////
// The TX_BUFFER structure forms the transmitted USB packet to the device
////////////////////////////////////////////////////////////////////////////
typedef struct __TX_BUFFER{
	TXD_STRUC		TxDesc;
	union	{
		UCHAR			WirelessPacket[2342];
		HEADER_802_11	NullFrame;
		PSPOLL_FRAME	PsPollPacket;
		RTS_FRAME		RTSFrame;
	};
} TX_BUFFER, *PTX_BUFFER;

////////////////////////////////////////////////////////////////////////////
// The RTS_BUFFER structure forms the transmitted USB packet to the device
////////////////////////////////////////////////////////////////////////////
typedef struct __RTS_BUFFER{
	TXD_STRUC	   TxDesc;
	UCHAR		   RTSPacket[16];
} RTS_BUFFER, *PRTS_BUFFER;

// used to track driver-generated write irps
typedef struct _TX_CONTEXT
{
	PVOID			pAd;			//Initialized in MiniportInitialize
	PURB			pUrb;			//Initialized in MiniportInitialize
//	PIRP			pIrp;			//Initialized in MiniportInitialize, used to cancel pending bulk out
	PTX_BUFFER		TransferBuffer;	//Initialized in MiniportInitialize
	ULONG			BulkOutSize;
	UCHAR			BulkOutPipeId;
	BOOLEAN			InUse;
	BOOLEAN			bWaitingBulkOut;
	BOOLEAN			IRPPending;
	BOOLEAN			LastOne;
}	TX_CONTEXT, *PTX_CONTEXT, **PPTX_CONTEXT;

typedef enum _Pendingirp {
	NONEPENDING,
	IRP0PENDING,
	IRP1PENDING
}	PendingIRP;

typedef enum _BEACON_INDEX {
	BEACON0,
	BEACON1
}	BEACON_INDEX;


#define   IRPLOCK_COMPLETED 		0
#define   IRPLOCK_CANCELABLE		1
#define   IRPLOCK_CANCE_START		2
#define   IRPLOCK_CANCE_COMPLETE	3
//
// Structure to keep track of receive packets and buffers to indicate
// receive data to the protocol.
//
typedef struct _RX_CONTEXT
{
	PUCHAR				TransferBuffer;
	PVOID				pAd;
//	PIRP				pIrp;//used to cancel pending bulk in.
	PURB				pUrb;
	BOOLEAN				InUse;
	BOOLEAN				IRPPending;		// TODO: To be removed
	atomic_t			IrpLock;
}	RX_CONTEXT, *PRX_CONTEXT;

//
// Register set pair for initialzation register set definition
//
typedef struct	_RTMP_REG_PAIR
{
	ULONG	Register;
	ULONG	Value;
}	RTMP_REG_PAIR, *PRTMP_REG_PAIR;

typedef struct	_BBP_REG_PAIR
{
	UCHAR	Register;
	UCHAR	Value;
}	BBP_REG_PAIR, *PBBP_REG_PAIR;

//
// Register set pair for initialzation register set definition
//
typedef struct	_RTMP_RF_REGS
{
	UCHAR	Channel;
	ULONG	R1;
	ULONG	R2;
	ULONG	R3;
	ULONG	R4;
}	RTMP_RF_REGS, *PRTMP_RF_REGS;

//
//	Statistic counter structure
//
typedef struct _COUNTER_802_3
{
	// General Stats
	ULONG		GoodTransmits;
	ULONG		GoodReceives;
	ULONG		TxErrors;
	ULONG		RxErrors;
	ULONG		RxNoBuffer;

	// Ethernet Stats
	ULONG		RcvAlignmentErrors;
	ULONG		OneCollision;
	ULONG		MoreCollisions;

}	COUNTER_802_3, *PCOUNTER_802_3;

typedef struct _COUNTER_802_11 {
	ULONG			Length;
	LARGE_INTEGER	TransmittedFragmentCount;
	LARGE_INTEGER	MulticastTransmittedFrameCount;
	LARGE_INTEGER	FailedCount;
	LARGE_INTEGER	NoRetryCount;
	LARGE_INTEGER	RetryCount;
	LARGE_INTEGER	MultipleRetryCount;
	LARGE_INTEGER	RTSSuccessCount;
	LARGE_INTEGER	RTSFailureCount;
	LARGE_INTEGER	ACKFailureCount;
	LARGE_INTEGER	FrameDuplicateCount;
	LARGE_INTEGER	ReceivedFragmentCount;
	LARGE_INTEGER	MulticastReceivedFrameCount;
	LARGE_INTEGER	FCSErrorCount;
} COUNTER_802_11, *PCOUNTER_802_11;

typedef struct _COUNTER_RALINK {
	ULONG			TransmittedByteCount;	// both successful and failure, used to calculate TX throughput
	ULONG			ReceivedByteCount;		// both CRC okay and CRC error, used to calculate RX throughput
	ULONG			BeenDisassociatedCount;
	ULONG			BadCQIAutoRecoveryCount;
	ULONG			PoorCQIRoamingCount;
	ULONG			MgmtRingFullCount;
	ULONG			RxCount;
	ULONG			RxRingErrCount;
	ULONG			KickTxCount;
	ULONG			TxRingErrCount;
	LARGE_INTEGER	RealFcsErrCount;
	ULONG			PendingNdisPacketCount;

	ULONG			OneSecOsTxCount[NUM_OF_TX_RING];
	ULONG			OneSecDmaDoneCount[NUM_OF_TX_RING];
	ULONG			OneSecTxDoneCount;
	ULONG			OneSecTxAggregationCount;
	ULONG			OneSecRxAggregationCount;

	ULONG			OneSecTxNoRetryOkCount;
	ULONG			OneSecTxRetryOkCount;
	ULONG			OneSecTxFailCount;
	ULONG			OneSecFalseCCACnt;		// CCA error count, for debug purpose, might move to global counter
	ULONG			OneSecRxOkCnt;			// RX without error
	ULONG			OneSecRxFcsErrCnt;		// CRC error
	ULONG			OneSecBeaconSentCnt;
} COUNTER_RALINK, *PCOUNTER_RALINK;

typedef struct _COUNTER_DRS {
	// to record the each TX rate's quality. 0 is best, the bigger the worse.
	USHORT			TxQuality[MAX_LEN_OF_SUPPORTED_RATES];
	UCHAR			PER[MAX_LEN_OF_SUPPORTED_RATES];
	UCHAR			TxRateUpPenalty;	  // extra # of second penalty due to last unstable condition
	ULONG			CurrTxRateStableTime; // # of second in current TX rate
	BOOLEAN 		fNoisyEnvironment;
	UCHAR			LastSecTxRateChangeAction; // 0: no change, 1:rate UP, 2:rate down
} COUNTER_DRS, *PCOUNTER_DRS;

typedef struct _COUNTER_QA {
	LARGE_INTEGER	CRCErrorCount;
	LARGE_INTEGER	RXOverFlowCount;