Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3ce54934 authored by Malcolm Priestley's avatar Malcolm Priestley Committed by Greg Kroah-Hartman
Browse files

staging: vt6656: device_init_registers remove camel case 



camel case changes
pDevice -> priv
byAntenna -> antenna
ntStatus -> status
byTmp-> tmp
byCalibTXIQ -> calib_tx_iq
byCalibTXDC -> calib_tx_dc
byCalibRXIQ -> calib_rx_iq

Signed-off-by: default avatarMalcolm Priestley <tvboxspy@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent da3b67b3

drivers/staging/vt6656/main_usb.c

+117 −117
Original line number Diff line number Diff line
@@ -220,22 +220,22 @@ static void device_set_options(struct vnt_private *priv) 
/*

 * initialization of MAC & BBP registers

 */

static int device_init_registers(struct vnt_private *pDevice)

static int device_init_registers(struct vnt_private *priv)

{

	struct vnt_cmd_card_init *init_cmd = &pDevice->init_command;

	struct vnt_rsp_card_init *init_rsp = &pDevice->init_response;

	u8 byAntenna;

	struct vnt_cmd_card_init *init_cmd = &priv->init_command;

	struct vnt_rsp_card_init *init_rsp = &priv->init_response;

	u8 antenna;

	int ii;

	int ntStatus = STATUS_SUCCESS;

	u8 byTmp;

	u8 byCalibTXIQ = 0, byCalibTXDC = 0, byCalibRXIQ = 0;

	int status = STATUS_SUCCESS;

	u8 tmp;

	u8 calib_tx_iq = 0, calib_tx_dc = 0, calib_rx_iq = 0;



	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n",

				DEVICE_INIT_COLD, pDevice->byPacketType);

				DEVICE_INIT_COLD, priv->byPacketType);



	if (!vnt_check_firmware_version(pDevice)) {

		if (vnt_download_firmware(pDevice) == true) {

			if (vnt_firmware_branch_to_sram(pDevice) == false) {

	if (!vnt_check_firmware_version(priv)) {

		if (vnt_download_firmware(priv) == true) {

			if (vnt_firmware_branch_to_sram(priv) == false) {

				DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO

					" vnt_firmware_branch_to_sram fail\n");

				return false;
@@ -247,63 +247,63 @@ static int device_init_registers(struct vnt_private *pDevice) 
		}

	}



	if (!vnt_vt3184_init(pDevice)) {

	if (!vnt_vt3184_init(priv)) {

		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" vnt_vt3184_init fail\n");

		return false;

	}



	init_cmd->init_class = DEVICE_INIT_COLD;

	init_cmd->exist_sw_net_addr = (u8) pDevice->bExistSWNetAddr;

	init_cmd->exist_sw_net_addr = (u8) priv->bExistSWNetAddr;

	for (ii = 0; ii < 6; ii++)

		init_cmd->sw_net_addr[ii] = pDevice->abyCurrentNetAddr[ii];

	init_cmd->short_retry_limit = pDevice->byShortRetryLimit;

	init_cmd->long_retry_limit = pDevice->byLongRetryLimit;

		init_cmd->sw_net_addr[ii] = priv->abyCurrentNetAddr[ii];

	init_cmd->short_retry_limit = priv->byShortRetryLimit;

	init_cmd->long_retry_limit = priv->byLongRetryLimit;



	/* issue card_init command to device */

	ntStatus = vnt_control_out(pDevice,

	status = vnt_control_out(priv,

		MESSAGE_TYPE_CARDINIT, 0, 0,

		sizeof(struct vnt_cmd_card_init), (u8 *)init_cmd);

	if (ntStatus != STATUS_SUCCESS) {

	if (status != STATUS_SUCCESS) {

		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail\n");

		return false;

	}



	ntStatus = vnt_control_in(pDevice, MESSAGE_TYPE_INIT_RSP, 0, 0,

	status = vnt_control_in(priv, MESSAGE_TYPE_INIT_RSP, 0, 0,

		sizeof(struct vnt_rsp_card_init), (u8 *)init_rsp);

	if (ntStatus != STATUS_SUCCESS) {

	if (status != STATUS_SUCCESS) {

		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO

			"Cardinit request in status fail!\n");

		return false;

	}



	/* local ID for AES functions */

	ntStatus = vnt_control_in(pDevice, MESSAGE_TYPE_READ,

	status = vnt_control_in(priv, MESSAGE_TYPE_READ,

		MAC_REG_LOCALID, MESSAGE_REQUEST_MACREG, 1,

			&pDevice->byLocalID);

	if (ntStatus != STATUS_SUCCESS)

			&priv->byLocalID);

	if (status != STATUS_SUCCESS)

		return false;



	/* do MACbSoftwareReset in MACvInitialize */



	pDevice->byTopOFDMBasicRate = RATE_24M;

	pDevice->byTopCCKBasicRate = RATE_1M;

	priv->byTopOFDMBasicRate = RATE_24M;

	priv->byTopCCKBasicRate = RATE_1M;



	/* target to IF pin while programming to RF chip */

	pDevice->byCurPwr = 0xFF;

	priv->byCurPwr = 0xFF;



	pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];

	pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];

	priv->byCCKPwr = priv->abyEEPROM[EEP_OFS_PWR_CCK];

	priv->byOFDMPwrG = priv->abyEEPROM[EEP_OFS_PWR_OFDMG];

	/* load power table */

	for (ii = 0; ii < 14; ii++) {

		pDevice->abyCCKPwrTbl[ii] =

			pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];

		priv->abyCCKPwrTbl[ii] =

			priv->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];



		if (pDevice->abyCCKPwrTbl[ii] == 0)

			pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;

		pDevice->abyOFDMPwrTbl[ii] =

				pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];

		if (pDevice->abyOFDMPwrTbl[ii] == 0)

			pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;

		if (priv->abyCCKPwrTbl[ii] == 0)

			priv->abyCCKPwrTbl[ii] = priv->byCCKPwr;

		priv->abyOFDMPwrTbl[ii] =

				priv->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];

		if (priv->abyOFDMPwrTbl[ii] == 0)

			priv->abyOFDMPwrTbl[ii] = priv->byOFDMPwrG;

	}



	/*
@@ -311,111 +311,111 @@ static int device_init_registers(struct vnt_private *pDevice) 
	 * then need to recover 12, 13, 14 channels with 11 channel

	 */

	for (ii = 11; ii < 14; ii++) {

		pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];

		pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];

		priv->abyCCKPwrTbl[ii] = priv->abyCCKPwrTbl[10];

		priv->abyOFDMPwrTbl[ii] = priv->abyOFDMPwrTbl[10];

	}



	pDevice->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */

	priv->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */



	/* load OFDM A power table */

	for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {

		pDevice->abyOFDMAPwrTbl[ii] =

			pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];

		priv->abyOFDMAPwrTbl[ii] =

			priv->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];



		if (pDevice->abyOFDMAPwrTbl[ii] == 0)

			pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;

		if (priv->abyOFDMAPwrTbl[ii] == 0)

			priv->abyOFDMAPwrTbl[ii] = priv->byOFDMPwrA;

	}



	byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];

	antenna = priv->abyEEPROM[EEP_OFS_ANTENNA];



	if (byAntenna & EEP_ANTINV)

		pDevice->bTxRxAntInv = true;

	if (antenna & EEP_ANTINV)

		priv->bTxRxAntInv = true;

	else

		pDevice->bTxRxAntInv = false;

		priv->bTxRxAntInv = false;



	byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);

	antenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);



	if (byAntenna == 0) /* if not set default is both */

		byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);

	if (antenna == 0) /* if not set default is both */

		antenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);



	if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {

		pDevice->byAntennaCount = 2;

		pDevice->byTxAntennaMode = ANT_B;

		pDevice->dwTxAntennaSel = 1;

		pDevice->dwRxAntennaSel = 1;

	if (antenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {

		priv->byAntennaCount = 2;

		priv->byTxAntennaMode = ANT_B;

		priv->dwTxAntennaSel = 1;

		priv->dwRxAntennaSel = 1;



		if (pDevice->bTxRxAntInv == true)

			pDevice->byRxAntennaMode = ANT_A;

		if (priv->bTxRxAntInv == true)

			priv->byRxAntennaMode = ANT_A;

		else

			pDevice->byRxAntennaMode = ANT_B;

			priv->byRxAntennaMode = ANT_B;

	} else  {

		pDevice->byAntennaCount = 1;

		pDevice->dwTxAntennaSel = 0;

		pDevice->dwRxAntennaSel = 0;

		priv->byAntennaCount = 1;

		priv->dwTxAntennaSel = 0;

		priv->dwRxAntennaSel = 0;



		if (byAntenna & EEP_ANTENNA_AUX) {

			pDevice->byTxAntennaMode = ANT_A;

		if (antenna & EEP_ANTENNA_AUX) {

			priv->byTxAntennaMode = ANT_A;



			if (pDevice->bTxRxAntInv == true)

				pDevice->byRxAntennaMode = ANT_B;

			if (priv->bTxRxAntInv == true)

				priv->byRxAntennaMode = ANT_B;

			else

				pDevice->byRxAntennaMode = ANT_A;

				priv->byRxAntennaMode = ANT_A;

		} else {

			pDevice->byTxAntennaMode = ANT_B;

			priv->byTxAntennaMode = ANT_B;



		if (pDevice->bTxRxAntInv == true)

			pDevice->byRxAntennaMode = ANT_A;

		if (priv->bTxRxAntInv == true)

			priv->byRxAntennaMode = ANT_A;

		else

			pDevice->byRxAntennaMode = ANT_B;

			priv->byRxAntennaMode = ANT_B;

		}

	}



	/* Set initial antenna mode */

	vnt_set_antenna_mode(pDevice, pDevice->byRxAntennaMode);

	vnt_set_antenna_mode(priv, priv->byRxAntennaMode);



	/* get Auto Fall Back type */

	pDevice->byAutoFBCtrl = AUTO_FB_0;

	priv->byAutoFBCtrl = AUTO_FB_0;



	/* default Auto Mode */

	pDevice->byBBType = BB_TYPE_11G;

	priv->byBBType = BB_TYPE_11G;



	/* get RFType */

	pDevice->byRFType = init_rsp->rf_type;

	priv->byRFType = init_rsp->rf_type;



	/* load vt3266 calibration parameters in EEPROM */

	if (pDevice->byRFType == RF_VT3226D0) {

		if ((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&

		    (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {



			byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];

			byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];

			byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];

			if (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) {

	if (priv->byRFType == RF_VT3226D0) {

		if ((priv->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&

		    (priv->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {



			calib_tx_iq = priv->abyEEPROM[EEP_OFS_CALIB_TX_IQ];

			calib_tx_dc = priv->abyEEPROM[EEP_OFS_CALIB_TX_DC];

			calib_rx_iq = priv->abyEEPROM[EEP_OFS_CALIB_RX_IQ];

			if (calib_tx_iq || calib_tx_dc || calib_rx_iq) {

				/* CR255, enable TX/RX IQ and

				   DC compensation mode */

				vnt_control_out_u8(pDevice,

				vnt_control_out_u8(priv,

						   MESSAGE_REQUEST_BBREG,

						   0xff,

						   0x03);

				/* CR251, TX I/Q Imbalance Calibration */

				vnt_control_out_u8(pDevice,

				vnt_control_out_u8(priv,

						   MESSAGE_REQUEST_BBREG,

						   0xfb,

						   byCalibTXIQ);

						   calib_tx_iq);

				/* CR252, TX DC-Offset Calibration */

				vnt_control_out_u8(pDevice,

				vnt_control_out_u8(priv,

						   MESSAGE_REQUEST_BBREG,

						   0xfC,

						   byCalibTXDC);

						   calib_tx_dc);

				/* CR253, RX I/Q Imbalance Calibration */

				vnt_control_out_u8(pDevice,

				vnt_control_out_u8(priv,

						   MESSAGE_REQUEST_BBREG,

						   0xfd,

						   byCalibRXIQ);

						   calib_rx_iq);

			} else {

				/* CR255, turn off

				   BB Calibration compensation */

				vnt_control_out_u8(pDevice,

				vnt_control_out_u8(priv,

						   MESSAGE_REQUEST_BBREG,

						   0xff,

						   0x0);
@@ -424,58 +424,58 @@ static int device_init_registers(struct vnt_private *pDevice) 
	}



	/* get permanent network address */

	memcpy(pDevice->abyPermanentNetAddr, init_rsp->net_addr, 6);

	memcpy(pDevice->abyCurrentNetAddr,

				pDevice->abyPermanentNetAddr, ETH_ALEN);

	memcpy(priv->abyPermanentNetAddr, init_rsp->net_addr, 6);

	memcpy(priv->abyCurrentNetAddr,

				priv->abyPermanentNetAddr, ETH_ALEN);



	/* if exist SW network address, use it */

	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",

		pDevice->abyCurrentNetAddr);

		priv->abyCurrentNetAddr);



	/*

	* set BB and packet type at the same time

	* set Short Slot Time, xIFS, and RSPINF

	*/

	if (pDevice->byBBType == BB_TYPE_11A)

		pDevice->bShortSlotTime = true;

	if (priv->byBBType == BB_TYPE_11A)

		priv->bShortSlotTime = true;

	else

		pDevice->bShortSlotTime = false;

		priv->bShortSlotTime = false;



	vnt_set_short_slot_time(pDevice);

	vnt_set_short_slot_time(priv);



	pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];

	pDevice->bHWRadioOff = false;

	priv->byRadioCtl = priv->abyEEPROM[EEP_OFS_RADIOCTL];

	priv->bHWRadioOff = false;



	if ((pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0) {

		ntStatus = vnt_control_in(pDevice, MESSAGE_TYPE_READ,

			MAC_REG_GPIOCTL1, MESSAGE_REQUEST_MACREG, 1, &byTmp);

	if ((priv->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0) {

		status = vnt_control_in(priv, MESSAGE_TYPE_READ,

			MAC_REG_GPIOCTL1, MESSAGE_REQUEST_MACREG, 1, &tmp);



		if (ntStatus != STATUS_SUCCESS)

		if (status != STATUS_SUCCESS)

			return false;



		if ((byTmp & GPIO3_DATA) == 0) {

			pDevice->bHWRadioOff = true;

			vnt_mac_reg_bits_on(pDevice, MAC_REG_GPIOCTL1,

		if ((tmp & GPIO3_DATA) == 0) {

			priv->bHWRadioOff = true;

			vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL1,

								GPIO3_INTMD);

		} else {

			vnt_mac_reg_bits_off(pDevice, MAC_REG_GPIOCTL1,

			vnt_mac_reg_bits_off(priv, MAC_REG_GPIOCTL1,

								GPIO3_INTMD);

			pDevice->bHWRadioOff = false;

			priv->bHWRadioOff = false;

		}



	}



	vnt_mac_set_led(pDevice, LEDSTS_TMLEN, 0x38);

	vnt_mac_set_led(priv, LEDSTS_TMLEN, 0x38);



	vnt_mac_set_led(pDevice, LEDSTS_STS, LEDSTS_SLOW);

	vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_SLOW);



	vnt_mac_reg_bits_on(pDevice, MAC_REG_GPIOCTL0, 0x01);

	vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL0, 0x01);



	if ((pDevice->bHWRadioOff == true) ||

				(pDevice->bRadioControlOff == true)) {

		vnt_radio_power_off(pDevice);

	if ((priv->bHWRadioOff == true) ||

				(priv->bRadioControlOff == true)) {

		vnt_radio_power_off(priv);

	} else {

		vnt_radio_power_on(pDevice);

		vnt_radio_power_on(priv);

	}



	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");