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: Malcolm Priestley <tvboxspy@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

drivers/staging/vt6656/main_usb.c

@@ -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];
-
-		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;
+		priv->abyCCKPwrTbl[ii] =
+			priv->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
+
+		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");