Staging: rt28x0: fix comments in *.c files (9f548a2a) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/staging/rt2860/chips/rt3070.c

+34 −34

Original line number	Original line	Diff line number	Diff line
	@@ -41,18 +41,18 @@

	#ifndef RTMP_RF_RW_SUPPORT		#ifndef RTMP_RF_RW_SUPPORT
	#error "You Should Enable compile flag RTMP_RF_RW_SUPPORT for this chip"		#error "You Should Enable compile flag RTMP_RF_RW_SUPPORT for this chip"
	#endif // RTMP_RF_RW_SUPPORT //		#endif /* RTMP_RF_RW_SUPPORT // */

	VOID NICInitRT3070RFRegisters(IN PRTMP_ADAPTER pAd)		VOID NICInitRT3070RFRegisters(IN PRTMP_ADAPTER pAd)
	{		{
	INT i;		INT i;
	UCHAR RFValue;		UCHAR RFValue;

	// Driver must read EEPROM to get RfIcType before initial RF registers		/* Driver must read EEPROM to get RfIcType before initial RF registers */
	// Initialize RF register to default value		/* Initialize RF register to default value */
	if (IS_RT3070(pAd) \|\| IS_RT3071(pAd)) {		if (IS_RT3070(pAd) \|\| IS_RT3071(pAd)) {
	// Init RF calibration		/* Init RF calibration */
	// Driver should toggle RF R30 bit7 before init RF registers		/* Driver should toggle RF R30 bit7 before init RF registers */
	UINT32 RfReg = 0;		UINT32 RfReg = 0;
	UINT32 data;		UINT32 data;

	@@ -63,38 +63,38 @@ VOID NICInitRT3070RFRegisters(IN PRTMP_ADAPTER pAd)
	RfReg &= 0x7F;		RfReg &= 0x7F;
	RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR) RfReg);		RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR) RfReg);

	// Initialize RF register to default value		/* Initialize RF register to default value */
	for (i = 0; i < NUM_RF_REG_PARMS; i++) {		for (i = 0; i < NUM_RF_REG_PARMS; i++) {
	RT30xxWriteRFRegister(pAd,		RT30xxWriteRFRegister(pAd,
	RT30xx_RFRegTable[i].Register,		RT30xx_RFRegTable[i].Register,
	RT30xx_RFRegTable[i].Value);		RT30xx_RFRegTable[i].Value);
	}		}

	// add by johnli		/* add by johnli */
	if (IS_RT3070(pAd)) {		if (IS_RT3070(pAd)) {
	//		/* */
	// The DAC issue(LDO_CFG0) has been fixed in RT3070(F).		/* The DAC issue(LDO_CFG0) has been fixed in RT3070(F). */
	// The voltage raising patch is no longer needed for RT3070(F)		/* The voltage raising patch is no longer needed for RT3070(F) */
	//		/* */
	if ((pAd->MACVersion & 0xffff) < 0x0201) {		if ((pAd->MACVersion & 0xffff) < 0x0201) {
	// Update MAC 0x05D4 from 01xxxxxx to 0Dxxxxxx (voltage 1.2V to 1.35V) for RT3070 to improve yield rate		/* Update MAC 0x05D4 from 01xxxxxx to 0Dxxxxxx (voltage 1.2V to 1.35V) for RT3070 to improve yield rate */
	RTUSBReadMACRegister(pAd, LDO_CFG0, &data);		RTUSBReadMACRegister(pAd, LDO_CFG0, &data);
	data = ((data & 0xF0FFFFFF) \| 0x0D000000);		data = ((data & 0xF0FFFFFF) \| 0x0D000000);
	RTUSBWriteMACRegister(pAd, LDO_CFG0, data);		RTUSBWriteMACRegister(pAd, LDO_CFG0, data);
	}		}
	} else if (IS_RT3071(pAd)) {		} else if (IS_RT3071(pAd)) {
	// Driver should set RF R6 bit6 on before init RF registers		/* Driver should set RF R6 bit6 on before init RF registers */
	RT30xxReadRFRegister(pAd, RF_R06, (PUCHAR) & RfReg);		RT30xxReadRFRegister(pAd, RF_R06, (PUCHAR) & RfReg);
	RfReg \|= 0x40;		RfReg \|= 0x40;
	RT30xxWriteRFRegister(pAd, RF_R06, (UCHAR) RfReg);		RT30xxWriteRFRegister(pAd, RF_R06, (UCHAR) RfReg);

	// init R31		/* init R31 */
	RT30xxWriteRFRegister(pAd, RF_R31, 0x14);		RT30xxWriteRFRegister(pAd, RF_R31, 0x14);

	// RT3071 version E has fixed this issue		/* RT3071 version E has fixed this issue */
	if ((pAd->NicConfig2.field.DACTestBit == 1)		if ((pAd->NicConfig2.field.DACTestBit == 1)
	&& ((pAd->MACVersion & 0xffff) < 0x0211)) {		&& ((pAd->MACVersion & 0xffff) < 0x0211)) {
	// patch tx EVM issue temporarily		/* patch tx EVM issue temporarily */
	RTUSBReadMACRegister(pAd, LDO_CFG0, &data);		RTUSBReadMACRegister(pAd, LDO_CFG0, &data);
	data = ((data & 0xE0FFFFFF) \| 0x0D000000);		data = ((data & 0xE0FFFFFF) \| 0x0D000000);
	RTUSBWriteMACRegister(pAd, LDO_CFG0, data);		RTUSBWriteMACRegister(pAd, LDO_CFG0, data);
	@@ -104,35 +104,35 @@ VOID NICInitRT3070RFRegisters(IN PRTMP_ADAPTER pAd)
	RTMP_IO_WRITE32(pAd, LDO_CFG0, data);		RTMP_IO_WRITE32(pAd, LDO_CFG0, data);
	}		}

	// patch LNA_PE_G1 failed issue		/* patch LNA_PE_G1 failed issue */
	RTUSBReadMACRegister(pAd, GPIO_SWITCH, &data);		RTUSBReadMACRegister(pAd, GPIO_SWITCH, &data);
	data &= ~(0x20);		data &= ~(0x20);
	RTUSBWriteMACRegister(pAd, GPIO_SWITCH, data);		RTUSBWriteMACRegister(pAd, GPIO_SWITCH, data);
	}		}
	//For RF filter Calibration		/For RF filter Calibration /
	RTMPFilterCalibration(pAd);		RTMPFilterCalibration(pAd);

	// Initialize RF R27 register, set RF R27 must be behind RTMPFilterCalibration()		/* Initialize RF R27 register, set RF R27 must be behind RTMPFilterCalibration() */
	//		/* */
	// TX to RX IQ glitch(RF_R27) has been fixed in RT3070(F).		/* TX to RX IQ glitch(RF_R27) has been fixed in RT3070(F). */
	// Raising RF voltage is no longer needed for RT3070(F)		/* Raising RF voltage is no longer needed for RT3070(F) */
	//		/* */
	if ((IS_RT3070(pAd)) && ((pAd->MACVersion & 0xffff) < 0x0201)) {		if ((IS_RT3070(pAd)) && ((pAd->MACVersion & 0xffff) < 0x0201)) {
	RT30xxWriteRFRegister(pAd, RF_R27, 0x3);		RT30xxWriteRFRegister(pAd, RF_R27, 0x3);
	} else if ((IS_RT3071(pAd))		} else if ((IS_RT3071(pAd))
	&& ((pAd->MACVersion & 0xffff) < 0x0211)) {		&& ((pAd->MACVersion & 0xffff) < 0x0211)) {
	RT30xxWriteRFRegister(pAd, RF_R27, 0x3);		RT30xxWriteRFRegister(pAd, RF_R27, 0x3);
	}		}
	// set led open drain enable		/* set led open drain enable */
	RTUSBReadMACRegister(pAd, OPT_14, &data);		RTUSBReadMACRegister(pAd, OPT_14, &data);
	data \|= 0x01;		data \|= 0x01;
	RTUSBWriteMACRegister(pAd, OPT_14, data);		RTUSBWriteMACRegister(pAd, OPT_14, data);

	// move from RT30xxLoadRFNormalModeSetup because it's needed for both RT3070 and RT3071		/* move from RT30xxLoadRFNormalModeSetup because it's needed for both RT3070 and RT3071 */
	// TX_LO1_en, RF R17 register Bit 3 to 0		/* TX_LO1_en, RF R17 register Bit 3 to 0 */
	RT30xxReadRFRegister(pAd, RF_R17, &RFValue);		RT30xxReadRFRegister(pAd, RF_R17, &RFValue);
	RFValue &= (~0x08);		RFValue &= (~0x08);
	// to fix rx long range issue		/* to fix rx long range issue */
	if (pAd->NicConfig2.field.ExternalLNAForG == 0) {		if (pAd->NicConfig2.field.ExternalLNAForG == 0) {
	if ((IS_RT3071(pAd)		if ((IS_RT3071(pAd)
	&& ((pAd->MACVersion & 0xffff) >= 0x0211))		&& ((pAd->MACVersion & 0xffff) >= 0x0211))
	@@ -140,22 +140,22 @@ VOID NICInitRT3070RFRegisters(IN PRTMP_ADAPTER pAd)
	RFValue \|= 0x20;		RFValue \|= 0x20;
	}		}
	}		}
	// set RF_R17_bit[2:0] equal to EEPROM setting at 0x48h		/* set RF_R17_bit[2:0] equal to EEPROM setting at 0x48h */
	if (pAd->TxMixerGain24G >= 1) {		if (pAd->TxMixerGain24G >= 1) {
	RFValue &= (~0x7); // clean bit [2:0]		RFValue &= (~0x7); /* clean bit [2:0] */
	RFValue \|= pAd->TxMixerGain24G;		RFValue \|= pAd->TxMixerGain24G;
	}		}
	RT30xxWriteRFRegister(pAd, RF_R17, RFValue);		RT30xxWriteRFRegister(pAd, RF_R17, RFValue);

	if (IS_RT3071(pAd)) {		if (IS_RT3071(pAd)) {
	// add by johnli, RF power sequence setup, load RF normal operation-mode setup		/* add by johnli, RF power sequence setup, load RF normal operation-mode setup */
	RT30xxLoadRFNormalModeSetup(pAd);		RT30xxLoadRFNormalModeSetup(pAd);
	} else if (IS_RT3070(pAd)) {		} else if (IS_RT3070(pAd)) {
	/* add by johnli, reset RF_R27 when interface down & up to fix throughput problem */		/* add by johnli, reset RF_R27 when interface down & up to fix throughput problem */
	// LDORF_VC, RF R27 register Bit 2 to 0		/* LDORF_VC, RF R27 register Bit 2 to 0 */
	RT30xxReadRFRegister(pAd, RF_R27, &RFValue);		RT30xxReadRFRegister(pAd, RF_R27, &RFValue);
	// TX to RX IQ glitch(RF_R27) has been fixed in RT3070(F).		/* TX to RX IQ glitch(RF_R27) has been fixed in RT3070(F). */
	// Raising RF voltage is no longer needed for RT3070(F)		/* Raising RF voltage is no longer needed for RT3070(F) */
	if ((pAd->MACVersion & 0xffff) < 0x0201)		if ((pAd->MACVersion & 0xffff) < 0x0201)
	RFValue = (RFValue & (~0x77)) \| 0x3;		RFValue = (RFValue & (~0x77)) \| 0x3;
	else		else
	@@ -166,4 +166,4 @@ VOID NICInitRT3070RFRegisters(IN PRTMP_ADAPTER pAd)
	}		}

	}		}
	#endif // RT3070 //		#endif /* RT3070 // */

drivers/staging/rt2860/chips/rt3090.c

+17 −17

Original line number	Original line	Diff line number	Diff line
	@@ -41,16 +41,16 @@

	#ifndef RTMP_RF_RW_SUPPORT		#ifndef RTMP_RF_RW_SUPPORT
	#error "You Should Enable compile flag RTMP_RF_RW_SUPPORT for this chip"		#error "You Should Enable compile flag RTMP_RF_RW_SUPPORT for this chip"
	#endif // RTMP_RF_RW_SUPPORT //		#endif /* RTMP_RF_RW_SUPPORT // */

	VOID NICInitRT3090RFRegisters(IN PRTMP_ADAPTER pAd)		VOID NICInitRT3090RFRegisters(IN PRTMP_ADAPTER pAd)
	{		{
	INT i;		INT i;
	// Driver must read EEPROM to get RfIcType before initial RF registers		/* Driver must read EEPROM to get RfIcType before initial RF registers */
	// Initialize RF register to default value		/* Initialize RF register to default value */
	if (IS_RT3090(pAd)) {		if (IS_RT3090(pAd)) {
	// Init RF calibration		/* Init RF calibration */
	// Driver should toggle RF R30 bit7 before init RF registers		/* Driver should toggle RF R30 bit7 before init RF registers */
	UINT32 RfReg = 0, data;		UINT32 RfReg = 0, data;

	RT30xxReadRFRegister(pAd, RF_R30, (PUCHAR) & RfReg);		RT30xxReadRFRegister(pAd, RF_R30, (PUCHAR) & RfReg);
	@@ -60,14 +60,14 @@ VOID NICInitRT3090RFRegisters(IN PRTMP_ADAPTER pAd)
	RfReg &= 0x7F;		RfReg &= 0x7F;
	RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR) RfReg);		RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR) RfReg);

	// init R24, R31		/* init R24, R31 */
	RT30xxWriteRFRegister(pAd, RF_R24, 0x0F);		RT30xxWriteRFRegister(pAd, RF_R24, 0x0F);
	RT30xxWriteRFRegister(pAd, RF_R31, 0x0F);		RT30xxWriteRFRegister(pAd, RF_R31, 0x0F);

	// RT309x version E has fixed this issue		/* RT309x version E has fixed this issue */
	if ((pAd->NicConfig2.field.DACTestBit == 1)		if ((pAd->NicConfig2.field.DACTestBit == 1)
	&& ((pAd->MACVersion & 0xffff) < 0x0211)) {		&& ((pAd->MACVersion & 0xffff) < 0x0211)) {
	// patch tx EVM issue temporarily		/* patch tx EVM issue temporarily */
	RTMP_IO_READ32(pAd, LDO_CFG0, &data);		RTMP_IO_READ32(pAd, LDO_CFG0, &data);
	data = ((data & 0xE0FFFFFF) \| 0x0D000000);		data = ((data & 0xE0FFFFFF) \| 0x0D000000);
	RTMP_IO_WRITE32(pAd, LDO_CFG0, data);		RTMP_IO_WRITE32(pAd, LDO_CFG0, data);
	@@ -77,43 +77,43 @@ VOID NICInitRT3090RFRegisters(IN PRTMP_ADAPTER pAd)
	RTMP_IO_WRITE32(pAd, LDO_CFG0, data);		RTMP_IO_WRITE32(pAd, LDO_CFG0, data);
	}		}

	// patch LNA_PE_G1 failed issue		/* patch LNA_PE_G1 failed issue */
	RTMP_IO_READ32(pAd, GPIO_SWITCH, &data);		RTMP_IO_READ32(pAd, GPIO_SWITCH, &data);
	data &= ~(0x20);		data &= ~(0x20);
	RTMP_IO_WRITE32(pAd, GPIO_SWITCH, data);		RTMP_IO_WRITE32(pAd, GPIO_SWITCH, data);

	// Initialize RF register to default value		/* Initialize RF register to default value */
	for (i = 0; i < NUM_RF_REG_PARMS; i++) {		for (i = 0; i < NUM_RF_REG_PARMS; i++) {
	RT30xxWriteRFRegister(pAd,		RT30xxWriteRFRegister(pAd,
	RT30xx_RFRegTable[i].Register,		RT30xx_RFRegTable[i].Register,
	RT30xx_RFRegTable[i].Value);		RT30xx_RFRegTable[i].Value);
	}		}

	// Driver should set RF R6 bit6 on before calibration		/* Driver should set RF R6 bit6 on before calibration */
	RT30xxReadRFRegister(pAd, RF_R06, (PUCHAR) & RfReg);		RT30xxReadRFRegister(pAd, RF_R06, (PUCHAR) & RfReg);
	RfReg \|= 0x40;		RfReg \|= 0x40;
	RT30xxWriteRFRegister(pAd, RF_R06, (UCHAR) RfReg);		RT30xxWriteRFRegister(pAd, RF_R06, (UCHAR) RfReg);

	//For RF filter Calibration		/For RF filter Calibration /
	RTMPFilterCalibration(pAd);		RTMPFilterCalibration(pAd);

	// Initialize RF R27 register, set RF R27 must be behind RTMPFilterCalibration()		/* Initialize RF R27 register, set RF R27 must be behind RTMPFilterCalibration() */
	if ((pAd->MACVersion & 0xffff) < 0x0211)		if ((pAd->MACVersion & 0xffff) < 0x0211)
	RT30xxWriteRFRegister(pAd, RF_R27, 0x3);		RT30xxWriteRFRegister(pAd, RF_R27, 0x3);

	// set led open drain enable		/* set led open drain enable */
	RTMP_IO_READ32(pAd, OPT_14, &data);		RTMP_IO_READ32(pAd, OPT_14, &data);
	data \|= 0x01;		data \|= 0x01;
	RTMP_IO_WRITE32(pAd, OPT_14, data);		RTMP_IO_WRITE32(pAd, OPT_14, data);

	// set default antenna as main		/* set default antenna as main */
	if (pAd->RfIcType == RFIC_3020)		if (pAd->RfIcType == RFIC_3020)
	AsicSetRxAnt(pAd, pAd->RxAnt.Pair1PrimaryRxAnt);		AsicSetRxAnt(pAd, pAd->RxAnt.Pair1PrimaryRxAnt);

	// add by johnli, RF power sequence setup, load RF normal operation-mode setup		/* add by johnli, RF power sequence setup, load RF normal operation-mode setup */
	RT30xxLoadRFNormalModeSetup(pAd);		RT30xxLoadRFNormalModeSetup(pAd);
	}		}

	}		}

	#endif // RT3090 //		#endif /* RT3090 // */

drivers/staging/rt2860/chips/rt30xx.c

+73 −73

Original line number	Original line	Diff line number	Diff line
	@@ -39,13 +39,13 @@

	#ifndef RTMP_RF_RW_SUPPORT		#ifndef RTMP_RF_RW_SUPPORT
	#error "You Should Enable compile flag RTMP_RF_RW_SUPPORT for this chip"		#error "You Should Enable compile flag RTMP_RF_RW_SUPPORT for this chip"
	#endif // RTMP_RF_RW_SUPPORT //		#endif /* RTMP_RF_RW_SUPPORT // */

	#include "../rt_config.h"		#include "../rt_config.h"

	//		/* */
	// RF register initialization set		/* RF register initialization set */
	//		/* */
	REG_PAIR RT30xx_RFRegTable[] = {		REG_PAIR RT30xx_RFRegTable[] = {
	{RF_R04, 0x40}		{RF_R04, 0x40}
	,		,
	@@ -89,12 +89,12 @@ REG_PAIR RT30xx_RFRegTable[] = {

	UCHAR NUM_RF_REG_PARMS = (sizeof(RT30xx_RFRegTable) / sizeof(REG_PAIR));		UCHAR NUM_RF_REG_PARMS = (sizeof(RT30xx_RFRegTable) / sizeof(REG_PAIR));

	// Antenna divesity use GPIO3 and EESK pin for control		/* Antenna divesity use GPIO3 and EESK pin for control */
	// Antenna and EEPROM access are both using EESK pin,		/* Antenna and EEPROM access are both using EESK pin, */
	// Therefor we should avoid accessing EESK at the same time		/* Therefor we should avoid accessing EESK at the same time */
	// Then restore antenna after EEPROM access		/* Then restore antenna after EEPROM access */
	// The original name of this function is AsicSetRxAnt(), now change to		/* The original name of this function is AsicSetRxAnt(), now change to */
	//VOID AsicSetRxAnt(		/VOID AsicSetRxAnt( /
	VOID RT30xxSetRxAnt(IN PRTMP_ADAPTER pAd, IN UCHAR Ant)		VOID RT30xxSetRxAnt(IN PRTMP_ADAPTER pAd, IN UCHAR Ant)
	{		{
	UINT32 Value;		UINT32 Value;
	@@ -109,16 +109,16 @@ VOID RT30xxSetRxAnt(IN PRTMP_ADAPTER pAd, IN UCHAR Ant)
	(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {
	return;		return;
	}		}
	// the antenna selection is through firmware and MAC register(GPIO3)		/* the antenna selection is through firmware and MAC register(GPIO3) */
	if (Ant == 0) {		if (Ant == 0) {
	// Main antenna		/* Main antenna */
	#ifdef RTMP_MAC_PCI		#ifdef RTMP_MAC_PCI
	RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);
	x \|= (EESK);		x \|= (EESK);
	RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);
	#else		#else
	AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x1, 0x0);		AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x1, 0x0);
	#endif // RTMP_MAC_PCI //		#endif /* RTMP_MAC_PCI // */

	RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);
	Value &= ~(0x0808);		Value &= ~(0x0808);
	@@ -126,14 +126,14 @@ VOID RT30xxSetRxAnt(IN PRTMP_ADAPTER pAd, IN UCHAR Ant)
	DBGPRINT_RAW(RT_DEBUG_TRACE,		DBGPRINT_RAW(RT_DEBUG_TRACE,
	("AsicSetRxAnt, switch to main antenna\n"));		("AsicSetRxAnt, switch to main antenna\n"));
	} else {		} else {
	// Aux antenna		/* Aux antenna */
	#ifdef RTMP_MAC_PCI		#ifdef RTMP_MAC_PCI
	RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);
	x &= ~(EESK);		x &= ~(EESK);
	RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);
	#else		#else
	AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x0, 0x0);		AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x0, 0x0);
	#endif // RTMP_MAC_PCI //		#endif /* RTMP_MAC_PCI // */
	RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);
	Value &= ~(0x0808);		Value &= ~(0x0808);
	Value \|= 0x08;		Value \|= 0x08;
	@@ -165,14 +165,14 @@ VOID RTMPFilterCalibration(IN PRTMP_ADAPTER pAd)
	UINT loop = 0, count = 0, loopcnt = 0, ReTry = 0;		UINT loop = 0, count = 0, loopcnt = 0, ReTry = 0;
	UCHAR RF_R24_Value = 0;		UCHAR RF_R24_Value = 0;

	// Give bbp filter initial value		/* Give bbp filter initial value */
	pAd->Mlme.CaliBW20RfR24 = 0x1F;		pAd->Mlme.CaliBW20RfR24 = 0x1F;
	pAd->Mlme.CaliBW40RfR24 = 0x2F; //Bit[5] must be 1 for BW 40		pAd->Mlme.CaliBW40RfR24 = 0x2F; /Bit[5] must be 1 for BW 40 /

	do {		do {
	if (loop == 1) //BandWidth = 40 MHz		if (loop == 1) /BandWidth = 40 MHz /
	{		{
	// Write 0x27 to RF_R24 to program filter		/* Write 0x27 to RF_R24 to program filter */
	RF_R24_Value = 0x27;		RF_R24_Value = 0x27;
	RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);		RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
	if (IS_RT3090(pAd) \|\| IS_RT3572(pAd) \|\| IS_RT3390(pAd))		if (IS_RT3090(pAd) \|\| IS_RT3572(pAd) \|\| IS_RT3390(pAd))
	@@ -180,19 +180,19 @@ VOID RTMPFilterCalibration(IN PRTMP_ADAPTER pAd)
	else		else
	FilterTarget = 0x19;		FilterTarget = 0x19;

	// when calibrate BW40, BBP mask must set to BW40.		/* when calibrate BW40, BBP mask must set to BW40. */
	RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &BBPValue);		RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &BBPValue);
	BBPValue &= (~0x18);		BBPValue &= (~0x18);
	BBPValue \|= (0x10);		BBPValue \|= (0x10);
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, BBPValue);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, BBPValue);

	// set to BW40		/* set to BW40 */
	RT30xxReadRFRegister(pAd, RF_R31, &value);		RT30xxReadRFRegister(pAd, RF_R31, &value);
	value \|= 0x20;		value \|= 0x20;
	RT30xxWriteRFRegister(pAd, RF_R31, value);		RT30xxWriteRFRegister(pAd, RF_R31, value);
	} else //BandWidth = 20 MHz		} else /BandWidth = 20 MHz /
	{		{
	// Write 0x07 to RF_R24 to program filter		/* Write 0x07 to RF_R24 to program filter */
	RF_R24_Value = 0x07;		RF_R24_Value = 0x07;
	RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);		RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
	if (IS_RT3090(pAd) \|\| IS_RT3572(pAd) \|\| IS_RT3390(pAd))		if (IS_RT3090(pAd) \|\| IS_RT3572(pAd) \|\| IS_RT3390(pAd))
	@@ -200,39 +200,39 @@ VOID RTMPFilterCalibration(IN PRTMP_ADAPTER pAd)
	else		else
	FilterTarget = 0x16;		FilterTarget = 0x16;

	// set to BW20		/* set to BW20 */
	RT30xxReadRFRegister(pAd, RF_R31, &value);		RT30xxReadRFRegister(pAd, RF_R31, &value);
	value &= (~0x20);		value &= (~0x20);
	RT30xxWriteRFRegister(pAd, RF_R31, value);		RT30xxWriteRFRegister(pAd, RF_R31, value);
	}		}

	// Write 0x01 to RF_R22 to enable baseband loopback mode		/* Write 0x01 to RF_R22 to enable baseband loopback mode */
	RT30xxReadRFRegister(pAd, RF_R22, &value);		RT30xxReadRFRegister(pAd, RF_R22, &value);
	value \|= 0x01;		value \|= 0x01;
	RT30xxWriteRFRegister(pAd, RF_R22, value);		RT30xxWriteRFRegister(pAd, RF_R22, value);

	// Write 0x00 to BBP_R24 to set power & frequency of passband test tone		/* Write 0x00 to BBP_R24 to set power & frequency of passband test tone */
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, 0);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, 0);

	do {		do {
	// Write 0x90 to BBP_R25 to transmit test tone		/* Write 0x90 to BBP_R25 to transmit test tone */
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R25, 0x90);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R25, 0x90);

	RTMPusecDelay(1000);		RTMPusecDelay(1000);
	// Read BBP_R55[6:0] for received power, set R55x = BBP_R55[6:0]		/* Read BBP_R55[6:0] for received power, set R55x = BBP_R55[6:0] */
	RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R55, &value);		RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R55, &value);
	R55x = value & 0xFF;		R55x = value & 0xFF;

	} while ((ReTry++ < 100) && (R55x == 0));		} while ((ReTry++ < 100) && (R55x == 0));

	// Write 0x06 to BBP_R24 to set power & frequency of stopband test tone		/* Write 0x06 to BBP_R24 to set power & frequency of stopband test tone */
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, 0x06);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, 0x06);

	while (TRUE) {		while (TRUE) {
	// Write 0x90 to BBP_R25 to transmit test tone		/* Write 0x90 to BBP_R25 to transmit test tone */
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R25, 0x90);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R25, 0x90);

	//We need to wait for calibration		/We need to wait for calibration /
	RTMPusecDelay(1000);		RTMPusecDelay(1000);
	RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R55, &value);		RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R55, &value);
	value &= 0xFF;		value &= 0xFF;
	@@ -245,27 +245,27 @@ VOID RTMPFilterCalibration(IN PRTMP_ADAPTER pAd)
	break;		break;
	}		}

	// prevent infinite loop cause driver hang.		/* prevent infinite loop cause driver hang. */
	if (loopcnt++ > 100) {		if (loopcnt++ > 100) {
	DBGPRINT(RT_DEBUG_ERROR,		DBGPRINT(RT_DEBUG_ERROR,
	("RTMPFilterCalibration - can't find a valid value, loopcnt=%d stop calibrating",		("RTMPFilterCalibration - can't find a valid value, loopcnt=%d stop calibrating",
	loopcnt));		loopcnt));
	break;		break;
	}		}
	// Write RF_R24 to program filter		/* Write RF_R24 to program filter */
	RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);		RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
	}		}

	if (count > 0) {		if (count > 0) {
	RF_R24_Value = RF_R24_Value - ((count) ? (1) : (0));		RF_R24_Value = RF_R24_Value - ((count) ? (1) : (0));
	}		}
	// Store for future usage		/* Store for future usage */
	if (loopcnt < 100) {		if (loopcnt < 100) {
	if (loop++ == 0) {		if (loop++ == 0) {
	//BandWidth = 20 MHz		/BandWidth = 20 MHz /
	pAd->Mlme.CaliBW20RfR24 = (UCHAR) RF_R24_Value;		pAd->Mlme.CaliBW20RfR24 = (UCHAR) RF_R24_Value;
	} else {		} else {
	//BandWidth = 40 MHz		/BandWidth = 40 MHz /
	pAd->Mlme.CaliBW40RfR24 = (UCHAR) RF_R24_Value;		pAd->Mlme.CaliBW40RfR24 = (UCHAR) RF_R24_Value;
	break;		break;
	}		}
	@@ -274,20 +274,20 @@ VOID RTMPFilterCalibration(IN PRTMP_ADAPTER pAd)

	RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);		RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);

	// reset count		/* reset count */
	count = 0;		count = 0;
	} while (TRUE);		} while (TRUE);

	//		/* */
	// Set back to initial state		/* Set back to initial state */
	//		/* */
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, 0);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, 0);

	RT30xxReadRFRegister(pAd, RF_R22, &value);		RT30xxReadRFRegister(pAd, RF_R22, &value);
	value &= ~(0x01);		value &= ~(0x01);
	RT30xxWriteRFRegister(pAd, RF_R22, value);		RT30xxWriteRFRegister(pAd, RF_R22, value);

	// set BBP back to BW20		/* set BBP back to BW20 */
	RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &BBPValue);		RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &BBPValue);
	BBPValue &= (~0x18);		BBPValue &= (~0x18);
	RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, BBPValue);		RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, BBPValue);
	@@ -297,7 +297,7 @@ VOID RTMPFilterCalibration(IN PRTMP_ADAPTER pAd)
	pAd->Mlme.CaliBW20RfR24, pAd->Mlme.CaliBW40RfR24));		pAd->Mlme.CaliBW20RfR24, pAd->Mlme.CaliBW40RfR24));
	}		}

	// add by johnli, RF power sequence setup		/* add by johnli, RF power sequence setup */
	/*		/*
	==========================================================================		==========================================================================
	Description:		Description:
	@@ -310,12 +310,12 @@ VOID RT30xxLoadRFNormalModeSetup(IN PRTMP_ADAPTER pAd)
	{		{
	UCHAR RFValue;		UCHAR RFValue;

	// RX0_PD & TX0_PD, RF R1 register Bit 2 & Bit 3 to 0 and RF_BLOCK_en,RX1_PD & TX1_PD, Bit0, Bit 4 & Bit5 to 1		/* RX0_PD & TX0_PD, RF R1 register Bit 2 & Bit 3 to 0 and RF_BLOCK_en,RX1_PD & TX1_PD, Bit0, Bit 4 & Bit5 to 1 */
	RT30xxReadRFRegister(pAd, RF_R01, &RFValue);		RT30xxReadRFRegister(pAd, RF_R01, &RFValue);
	RFValue = (RFValue & (~0x0C)) \| 0x31;		RFValue = (RFValue & (~0x0C)) \| 0x31;
	RT30xxWriteRFRegister(pAd, RF_R01, RFValue);		RT30xxWriteRFRegister(pAd, RF_R01, RFValue);

	// TX_LO2_en, RF R15 register Bit 3 to 0		/* TX_LO2_en, RF R15 register Bit 3 to 0 */
	RT30xxReadRFRegister(pAd, RF_R15, &RFValue);		RT30xxReadRFRegister(pAd, RF_R15, &RFValue);
	RFValue &= (~0x08);		RFValue &= (~0x08);
	RT30xxWriteRFRegister(pAd, RF_R15, RFValue);		RT30xxWriteRFRegister(pAd, RF_R15, RFValue);
	@@ -338,22 +338,22 @@ VOID RT30xxLoadRFNormalModeSetup(IN PRTMP_ADAPTER pAd)
	RT30xxWriteRFRegister(pAd, RF_R17, RFValue);		RT30xxWriteRFRegister(pAd, RF_R17, RFValue);
	*/		*/

	// RX_LO1_en, RF R20 register Bit 3 to 0		/* RX_LO1_en, RF R20 register Bit 3 to 0 */
	RT30xxReadRFRegister(pAd, RF_R20, &RFValue);		RT30xxReadRFRegister(pAd, RF_R20, &RFValue);
	RFValue &= (~0x08);		RFValue &= (~0x08);
	RT30xxWriteRFRegister(pAd, RF_R20, RFValue);		RT30xxWriteRFRegister(pAd, RF_R20, RFValue);

	// RX_LO2_en, RF R21 register Bit 3 to 0		/* RX_LO2_en, RF R21 register Bit 3 to 0 */
	RT30xxReadRFRegister(pAd, RF_R21, &RFValue);		RT30xxReadRFRegister(pAd, RF_R21, &RFValue);
	RFValue &= (~0x08);		RFValue &= (~0x08);
	RT30xxWriteRFRegister(pAd, RF_R21, RFValue);		RT30xxWriteRFRegister(pAd, RF_R21, RFValue);

	/* add by johnli, reset RF_R27 when interface down & up to fix throughput problem */		/* add by johnli, reset RF_R27 when interface down & up to fix throughput problem */
	// LDORF_VC, RF R27 register Bit 2 to 0		/* LDORF_VC, RF R27 register Bit 2 to 0 */
	RT30xxReadRFRegister(pAd, RF_R27, &RFValue);		RT30xxReadRFRegister(pAd, RF_R27, &RFValue);
	// TX to RX IQ glitch(RF_R27) has been fixed in RT3070(F).		/* TX to RX IQ glitch(RF_R27) has been fixed in RT3070(F). */
	// Raising RF voltage is no longer needed for RT3070(F)		/* Raising RF voltage is no longer needed for RT3070(F) */
	if (IS_RT3090(pAd)) // RT309x and RT3071/72		if (IS_RT3090(pAd)) /* RT309x and RT3071/72 */
	{		{
	if ((pAd->MACVersion & 0xffff) < 0x0211)		if ((pAd->MACVersion & 0xffff) < 0x0211)
	RFValue = (RFValue & (~0x77)) \| 0x3;		RFValue = (RFValue & (~0x77)) \| 0x3;
	@@ -379,35 +379,35 @@ VOID RT30xxLoadRFSleepModeSetup(IN PRTMP_ADAPTER pAd)

	#ifdef RTMP_MAC_USB		#ifdef RTMP_MAC_USB
	if (!IS_RT3572(pAd))		if (!IS_RT3572(pAd))
	#endif // RTMP_MAC_USB //		#endif /* RTMP_MAC_USB // */
	{		{
	// RF_BLOCK_en. RF R1 register Bit 0 to 0		/* RF_BLOCK_en. RF R1 register Bit 0 to 0 */
	RT30xxReadRFRegister(pAd, RF_R01, &RFValue);		RT30xxReadRFRegister(pAd, RF_R01, &RFValue);
	RFValue &= (~0x01);		RFValue &= (~0x01);
	RT30xxWriteRFRegister(pAd, RF_R01, RFValue);		RT30xxWriteRFRegister(pAd, RF_R01, RFValue);

	// VCO_IC, RF R7 register Bit 4 & Bit 5 to 0		/* VCO_IC, RF R7 register Bit 4 & Bit 5 to 0 */
	RT30xxReadRFRegister(pAd, RF_R07, &RFValue);		RT30xxReadRFRegister(pAd, RF_R07, &RFValue);
	RFValue &= (~0x30);		RFValue &= (~0x30);
	RT30xxWriteRFRegister(pAd, RF_R07, RFValue);		RT30xxWriteRFRegister(pAd, RF_R07, RFValue);

	// Idoh, RF R9 register Bit 1, Bit 2 & Bit 3 to 0		/* Idoh, RF R9 register Bit 1, Bit 2 & Bit 3 to 0 */
	RT30xxReadRFRegister(pAd, RF_R09, &RFValue);		RT30xxReadRFRegister(pAd, RF_R09, &RFValue);
	RFValue &= (~0x0E);		RFValue &= (~0x0E);
	RT30xxWriteRFRegister(pAd, RF_R09, RFValue);		RT30xxWriteRFRegister(pAd, RF_R09, RFValue);

	// RX_CTB_en, RF R21 register Bit 7 to 0		/* RX_CTB_en, RF R21 register Bit 7 to 0 */
	RT30xxReadRFRegister(pAd, RF_R21, &RFValue);		RT30xxReadRFRegister(pAd, RF_R21, &RFValue);
	RFValue &= (~0x80);		RFValue &= (~0x80);
	RT30xxWriteRFRegister(pAd, RF_R21, RFValue);		RT30xxWriteRFRegister(pAd, RF_R21, RFValue);
	}		}

	if (IS_RT3090(pAd) \|\| // IS_RT3090 including RT309x and RT3071/72		if (IS_RT3090(pAd) \|\| /* IS_RT3090 including RT309x and RT3071/72 */
	IS_RT3572(pAd) \|\|		IS_RT3572(pAd) \|\|
	(IS_RT3070(pAd) && ((pAd->MACVersion & 0xffff) < 0x0201))) {		(IS_RT3070(pAd) && ((pAd->MACVersion & 0xffff) < 0x0201))) {
	#ifdef RTMP_MAC_USB		#ifdef RTMP_MAC_USB
	if (!IS_RT3572(pAd))		if (!IS_RT3572(pAd))
	#endif // RTMP_MAC_USB //		#endif /* RTMP_MAC_USB // */
	{		{
	RT30xxReadRFRegister(pAd, RF_R27, &RFValue);		RT30xxReadRFRegister(pAd, RF_R27, &RFValue);
	RFValue \|= 0x77;		RFValue \|= 0x77;
	@@ -435,36 +435,36 @@ VOID RT30xxReverseRFSleepModeSetup(IN PRTMP_ADAPTER pAd)

	#ifdef RTMP_MAC_USB		#ifdef RTMP_MAC_USB
	if (!IS_RT3572(pAd))		if (!IS_RT3572(pAd))
	#endif // RTMP_MAC_USB //		#endif /* RTMP_MAC_USB // */
	{		{
	// RF_BLOCK_en, RF R1 register Bit 0 to 1		/* RF_BLOCK_en, RF R1 register Bit 0 to 1 */
	RT30xxReadRFRegister(pAd, RF_R01, &RFValue);		RT30xxReadRFRegister(pAd, RF_R01, &RFValue);
	RFValue \|= 0x01;		RFValue \|= 0x01;
	RT30xxWriteRFRegister(pAd, RF_R01, RFValue);		RT30xxWriteRFRegister(pAd, RF_R01, RFValue);

	// VCO_IC, RF R7 register Bit 4 & Bit 5 to 1		/* VCO_IC, RF R7 register Bit 4 & Bit 5 to 1 */
	RT30xxReadRFRegister(pAd, RF_R07, &RFValue);		RT30xxReadRFRegister(pAd, RF_R07, &RFValue);
	RFValue \|= 0x30;		RFValue \|= 0x30;
	RT30xxWriteRFRegister(pAd, RF_R07, RFValue);		RT30xxWriteRFRegister(pAd, RF_R07, RFValue);

	// Idoh, RF R9 register Bit 1, Bit 2 & Bit 3 to 1		/* Idoh, RF R9 register Bit 1, Bit 2 & Bit 3 to 1 */
	RT30xxReadRFRegister(pAd, RF_R09, &RFValue);		RT30xxReadRFRegister(pAd, RF_R09, &RFValue);
	RFValue \|= 0x0E;		RFValue \|= 0x0E;
	RT30xxWriteRFRegister(pAd, RF_R09, RFValue);		RT30xxWriteRFRegister(pAd, RF_R09, RFValue);

	// RX_CTB_en, RF R21 register Bit 7 to 1		/* RX_CTB_en, RF R21 register Bit 7 to 1 */
	RT30xxReadRFRegister(pAd, RF_R21, &RFValue);		RT30xxReadRFRegister(pAd, RF_R21, &RFValue);
	RFValue \|= 0x80;		RFValue \|= 0x80;
	RT30xxWriteRFRegister(pAd, RF_R21, RFValue);		RT30xxWriteRFRegister(pAd, RF_R21, RFValue);
	}		}

	if (IS_RT3090(pAd) \|\| // IS_RT3090 including RT309x and RT3071/72		if (IS_RT3090(pAd) \|\| /* IS_RT3090 including RT309x and RT3071/72 */
	IS_RT3572(pAd) \|\|		IS_RT3572(pAd) \|\|
	IS_RT3390(pAd) \|\|		IS_RT3390(pAd) \|\|
	(IS_RT3070(pAd) && ((pAd->MACVersion & 0xffff) < 0x0201))) {		(IS_RT3070(pAd) && ((pAd->MACVersion & 0xffff) < 0x0201))) {
	#ifdef RTMP_MAC_USB		#ifdef RTMP_MAC_USB
	if (!IS_RT3572(pAd))		if (!IS_RT3572(pAd))
	#endif // RTMP_MAC_USB //		#endif /* RTMP_MAC_USB // */
	{		{
	RT30xxReadRFRegister(pAd, RF_R27, &RFValue);		RT30xxReadRFRegister(pAd, RF_R27, &RFValue);
	if ((pAd->MACVersion & 0xffff) < 0x0211)		if ((pAd->MACVersion & 0xffff) < 0x0211)
	@@ -473,10 +473,10 @@ VOID RT30xxReverseRFSleepModeSetup(IN PRTMP_ADAPTER pAd)
	RFValue = (RFValue & (~0x77));		RFValue = (RFValue & (~0x77));
	RT30xxWriteRFRegister(pAd, RF_R27, RFValue);		RT30xxWriteRFRegister(pAd, RF_R27, RFValue);
	}		}
	// RT3071 version E has fixed this issue		/* RT3071 version E has fixed this issue */
	if ((pAd->NicConfig2.field.DACTestBit == 1)		if ((pAd->NicConfig2.field.DACTestBit == 1)
	&& ((pAd->MACVersion & 0xffff) < 0x0211)) {		&& ((pAd->MACVersion & 0xffff) < 0x0211)) {
	// patch tx EVM issue temporarily		/* patch tx EVM issue temporarily */
	RTMP_IO_READ32(pAd, LDO_CFG0, &MACValue);		RTMP_IO_READ32(pAd, LDO_CFG0, &MACValue);
	MACValue = ((MACValue & 0xE0FFFFFF) \| 0x0D000000);		MACValue = ((MACValue & 0xE0FFFFFF) \| 0x0D000000);
	RTMP_IO_WRITE32(pAd, LDO_CFG0, MACValue);		RTMP_IO_WRITE32(pAd, LDO_CFG0, MACValue);
	@@ -491,22 +491,22 @@ VOID RT30xxReverseRFSleepModeSetup(IN PRTMP_ADAPTER pAd)
	RT30xxWriteRFRegister(pAd, RF_R08, 0x80);		RT30xxWriteRFRegister(pAd, RF_R08, 0x80);
	}		}

	// end johnli		/* end johnli */

	VOID RT30xxHaltAction(IN PRTMP_ADAPTER pAd)		VOID RT30xxHaltAction(IN PRTMP_ADAPTER pAd)
	{		{
	UINT32 TxPinCfg = 0x00050F0F;		UINT32 TxPinCfg = 0x00050F0F;

	//		/* */
	// Turn off LNA_PE or TRSW_POL		/* Turn off LNA_PE or TRSW_POL */
	//		/* */
	if (IS_RT3070(pAd) \|\| IS_RT3071(pAd) \|\| IS_RT3572(pAd)) {		if (IS_RT3070(pAd) \|\| IS_RT3071(pAd) \|\| IS_RT3572(pAd)) {
	if ((IS_RT3071(pAd) \|\| IS_RT3572(pAd))		if ((IS_RT3071(pAd) \|\| IS_RT3572(pAd))
	#ifdef RTMP_EFUSE_SUPPORT		#ifdef RTMP_EFUSE_SUPPORT
	&& (pAd->bUseEfuse)		&& (pAd->bUseEfuse)
	#endif // RTMP_EFUSE_SUPPORT //		#endif /* RTMP_EFUSE_SUPPORT // */
	) {		) {
	TxPinCfg &= 0xFFFBF0F0; // bit18 off		TxPinCfg &= 0xFFFBF0F0; /* bit18 off */
	} else {		} else {
	TxPinCfg &= 0xFFFFF0F0;		TxPinCfg &= 0xFFFFF0F0;
	}		}
	@@ -515,4 +515,4 @@ VOID RT30xxHaltAction(IN PRTMP_ADAPTER pAd)
	}		}
	}		}

	#endif // RT30xx //		#endif /* RT30xx // */

drivers/staging/rt2860/pci_main_dev.c

+145 −145

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/rt2860/rt_linux.c

+55 −55

File changed.

Preview size limit exceeded, changes collapsed.