From cde4362f0244a70bab73e37e24f167186bb9a8be Mon Sep 17 00:00:00 2001
From: Mauro Carvalho Chehab <mchehab@redhat.com>
Date: Tue, 3 Mar 2009 13:31:36 -0300
Subject: V4L/DVB (10956): cx231xx: First series of manual CodingStyle fixes

This patch cleans up CodingStyle on the following source files:

There are still much more to be fixed on later patches

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
---
 drivers/media/video/cx231xx/cx231xx-audio.c  |   37 +-
 drivers/media/video/cx231xx/cx231xx-avcore.c | 2107 +++++++++++---------------
 drivers/media/video/cx231xx/cx231xx-vbi.c    |   86 +-
 drivers/media/video/cx231xx/cx231xx-video.c  |  595 ++++----
 drivers/media/video/cx231xx/cx231xx.h        |   60 +-
 5 files changed, 1257 insertions(+), 1628 deletions(-)

(limited to 'drivers/media/video/cx231xx')

diff --git a/drivers/media/video/cx231xx/cx231xx-audio.c b/drivers/media/video/cx231xx/cx231xx-audio.c
index cee64879c4f0..3810b0fd2d61 100644
--- a/drivers/media/video/cx231xx/cx231xx-audio.c
+++ b/drivers/media/video/cx231xx/cx231xx-audio.c
@@ -70,7 +70,6 @@ static int cx231xx_isoc_audio_deinit(struct cx231xx *dev)
 
 			kfree(dev->adev.transfer_buffer[i]);
 			dev->adev.transfer_buffer[i] = NULL;
-
 		}
 	}
 
@@ -108,18 +107,19 @@ static void cx231xx_audio_isocirq(struct urb *urb)
 		stride = runtime->frame_bits >> 3;
 
 		for (i = 0; i < urb->number_of_packets; i++) {
-			int length =
-			    urb->iso_frame_desc[i].actual_length / stride;
+			int length = urb->iso_frame_desc[i].actual_length /
+				     stride;
 			cp = (unsigned char *)urb->transfer_buffer +
-			    urb->iso_frame_desc[i].offset;
+					      urb->iso_frame_desc[i].offset;
 
 			if (!length)
 				continue;
 
 			oldptr = dev->adev.hwptr_done_capture;
 			if (oldptr + length >= runtime->buffer_size) {
-				unsigned int cnt =
-				    runtime->buffer_size - oldptr;
+				unsigned int cnt;
+
+				cnt = runtime->buffer_size - oldptr;
 				memcpy(runtime->dma_area + oldptr * stride, cp,
 				       cnt * stride);
 				memcpy(runtime->dma_area, cp + cnt * stride,
@@ -132,16 +132,12 @@ static void cx231xx_audio_isocirq(struct urb *urb)
 			snd_pcm_stream_lock(substream);
 
 			dev->adev.hwptr_done_capture += length;
-			if (dev->adev.hwptr_done_capture >=
-			    runtime->buffer_size)
-				dev->adev.hwptr_done_capture -=
-				    runtime->buffer_size;
+			if (dev->adev.hwptr_done_capture >= runtime->buffer_size)
+				dev->adev.hwptr_done_capture -= runtime->buffer_size;
 
 			dev->adev.capture_transfer_done += length;
-			if (dev->adev.capture_transfer_done >=
-			    runtime->period_size) {
-				dev->adev.capture_transfer_done -=
-				    runtime->period_size;
+			if (dev->adev.capture_transfer_done >= runtime->period_size) {
+				dev->adev.capture_transfer_done -= runtime->period_size;
 				period_elapsed = 1;
 			}
 			snd_pcm_stream_unlock(substream);
@@ -189,8 +185,7 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
 
 		urb->dev = dev->udev;
 		urb->context = dev;
-		urb->pipe =
-		    usb_rcvisocpipe(dev->udev, dev->adev.end_point_addr);
+		urb->pipe = usb_rcvisocpipe(dev->udev, dev->adev.end_point_addr);
 		urb->transfer_flags = URB_ISO_ASAP;
 		urb->transfer_buffer = dev->adev.transfer_buffer[i];
 		urb->interval = 1;
@@ -198,8 +193,7 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
 		urb->number_of_packets = CX231XX_NUM_AUDIO_PACKETS;
 		urb->transfer_buffer_length = sb_size;
 
-		for (j = k = 0; j < CX231XX_NUM_AUDIO_PACKETS;
-		     j++, k += dev->adev.max_pkt_size) {
+		for (j = k = 0; j < CX231XX_NUM_AUDIO_PACKETS; j++, k += dev->adev.max_pkt_size) {
 			urb->iso_frame_desc[j].offset = k;
 			urb->iso_frame_desc[j].length = dev->adev.max_pkt_size;
 		}
@@ -275,10 +269,10 @@ static struct snd_pcm_hardware snd_cx231xx_hw_capture = {
 	.channels_min = 2,
 	.channels_max = 2,
 	.buffer_bytes_max = 62720 * 8,	/* just about the value in usbaudio.c */
-	.period_bytes_min = 64,	/* 12544/2, */
+	.period_bytes_min = 64,		/* 12544/2, */
 	.period_bytes_max = 12544,
 	.periods_min = 2,
-	.periods_max = 98,	/* 12544, */
+	.periods_max = 98,		/* 12544, */
 };
 
 static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
@@ -477,9 +471,8 @@ static int cx231xx_audio_init(struct cx231xx *dev)
 		     "non standard usbaudio\n");
 
 	card = snd_card_new(index[devnr], "Cx231xx Audio", THIS_MODULE, 0);
-	if (card == NULL) {
+	if (card == NULL)
 		return -ENOMEM;
-	}
 
 	spin_lock_init(&adev->slock);
 	err = snd_pcm_new(card, "Cx231xx Audio", 0, 0, 1, &pcm);
diff --git a/drivers/media/video/cx231xx/cx231xx-avcore.c b/drivers/media/video/cx231xx/cx231xx-avcore.c
index 3c09b9473843..bbfc78ebd94b 100644
--- a/drivers/media/video/cx231xx/cx231xx-avcore.c
+++ b/drivers/media/video/cx231xx/cx231xx-avcore.c
@@ -1,5 +1,6 @@
 /*
-   cx231xx_avcore.c - driver for Conexant Cx23100/101/102 USB video capture devices
+   cx231xx_avcore.c - driver for Conexant Cx23100/101/102
+		      USB video capture devices
 
    Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
 
@@ -38,9 +39,9 @@
 
 #include "cx231xx.h"
 
-/*************************************************************************************
- *            C O L I B R I - B L O C K    C O N T R O L   functions                 *
- *************************************************************************************/
+/******************************************************************************
+ *            C O L I B R I - B L O C K    C O N T R O L   functions          *
+ ********************************************************************* ********/
 int cx231xx_colibri_init_super_block(struct cx231xx *dev, u32 ref_count)
 {
 	int status = 0;
@@ -50,42 +51,35 @@ int cx231xx_colibri_init_super_block(struct cx231xx *dev, u32 ref_count)
 
 	/* super block initialize */
 	temp = (u8) (ref_count & 0xff);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS, SUP_BLK_TUNE2,
-				   2, temp, 1);
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+					SUP_BLK_TUNE2, 2, temp, 1);
 
-	status =
-	    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS, SUP_BLK_TUNE2, 2,
-				  &colibri_power_status, 1);
+	status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+				       SUP_BLK_TUNE2, 2,
+				       &colibri_power_status, 1);
 
 	temp = (u8) ((ref_count & 0x300) >> 8);
 	temp |= 0x40;
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS, SUP_BLK_TUNE1,
-				   2, temp, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS, SUP_BLK_PLL2, 2,
-				   0x0f, 1);
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+					SUP_BLK_TUNE1, 2, temp, 1);
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+					SUP_BLK_PLL2, 2, 0x0f, 1);
 
 	/* enable pll     */
 	while (colibri_power_status != 0x18) {
-		status =
-		    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-					   SUP_BLK_PWRDN, 2, 0x18, 1);
-		status =
-		    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-					  SUP_BLK_PWRDN, 2,
-					  &colibri_power_status, 1);
+		status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+						SUP_BLK_PWRDN, 2, 0x18, 1);
+		status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+					       SUP_BLK_PWRDN, 2,
+					       &colibri_power_status, 1);
 		colibri_power_status &= 0xff;
 		if (status < 0) {
-			cx231xx_info
-			    (": Init Super Block failed in sending/receiving cmds\n");
+			cx231xx_info(": Init Super Block failed in sending/receiving cmds\n");
 			break;
 		}
 		i++;
 		if (i == 10) {
-			cx231xx_info
-			    (": Init Super Block force break in loop !!!!\n");
+			cx231xx_info(": Init Super Block force break in loop !!!!\n");
 			status = -1;
 			break;
 		}
@@ -95,9 +89,8 @@ int cx231xx_colibri_init_super_block(struct cx231xx *dev, u32 ref_count)
 		return status;
 
 	/* start tuning filter */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS, SUP_BLK_TUNE3,
-				   2, 0x40, 1);
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+					SUP_BLK_TUNE3, 2, 0x40, 1);
 	msleep(5);
 
 	/* exit tuning */
@@ -113,86 +106,64 @@ int cx231xx_colibri_init_channels(struct cx231xx *dev)
 	int status = 0;
 
 	/* power up all 3 channels, clear pd_buffer */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_PWRDN_CLAMP_CH1, 2, 0x00, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_PWRDN_CLAMP_CH2, 2, 0x00, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_PWRDN_CLAMP_CH3, 2, 0x00, 1);
 
 	/* Enable quantizer calibration */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS, ADC_COM_QUANT,
-				   2, 0x02, 1);
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+					ADC_COM_QUANT, 2, 0x02, 1);
 
 	/* channel initialize, force modulator (fb) reset */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_FB_FRCRST_CH1, 2, 0x17, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_FB_FRCRST_CH2, 2, 0x17, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_FB_FRCRST_CH3, 2, 0x17, 1);
 
 	/* start quantilizer calibration  */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_CAL_ATEST_CH1, 2, 0x10, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_CAL_ATEST_CH2, 2, 0x10, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_CAL_ATEST_CH3, 2, 0x10, 1);
 	msleep(5);
 
 	/* exit modulator (fb) reset */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_FB_FRCRST_CH1, 2, 0x07, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status =  cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_FB_FRCRST_CH2, 2, 0x07, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_FB_FRCRST_CH3, 2, 0x07, 1);
 
 	/* enable the pre_clamp in each channel for single-ended input */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_NTF_PRECLMP_EN_CH1, 2, 0xf0, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_NTF_PRECLMP_EN_CH2, 2, 0xf0, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_NTF_PRECLMP_EN_CH3, 2, 0xf0, 1);
 
 	/* use diode instead of resistor, so set term_en to 0, res_en to 0  */
-	status =
-	    cx231xx_reg_mask_write(dev, Colibri_DEVICE_ADDRESS, 8,
+	status = cx231xx_reg_mask_write(dev, Colibri_DEVICE_ADDRESS, 8,
 				   ADC_QGAIN_RES_TRM_CH1, 3, 7, 0x00);
-	status =
-	    cx231xx_reg_mask_write(dev, Colibri_DEVICE_ADDRESS, 8,
+	status = cx231xx_reg_mask_write(dev, Colibri_DEVICE_ADDRESS, 8,
 				   ADC_QGAIN_RES_TRM_CH2, 3, 7, 0x00);
-	status =
-	    cx231xx_reg_mask_write(dev, Colibri_DEVICE_ADDRESS, 8,
+	status = cx231xx_reg_mask_write(dev, Colibri_DEVICE_ADDRESS, 8,
 				   ADC_QGAIN_RES_TRM_CH3, 3, 7, 0x00);
 
 	/* dynamic element matching off */
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_DCSERVO_DEM_CH1, 2, 0x03, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_DCSERVO_DEM_CH2, 2, 0x03, 1);
-	status =
-	    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+	status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 				   ADC_DCSERVO_DEM_CH3, 2, 0x03, 1);
 
 	return status;
@@ -235,8 +206,7 @@ int cx231xx_colibri_set_input_mux(struct cx231xx *dev, u32 input_mux)
 		value &= (!INPUT_SEL_MASK);
 		value |= (ch1_setting - 1) << 4;
 		value &= 0xff;
-		status =
-		    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					   ADC_INPUT_CH1, 2, value, 1);
 	}
 
@@ -247,21 +217,19 @@ int cx231xx_colibri_set_input_mux(struct cx231xx *dev, u32 input_mux)
 		value &= (!INPUT_SEL_MASK);
 		value |= (ch2_setting - 1) << 4;
 		value &= 0xff;
-		status =
-		    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					   ADC_INPUT_CH2, 2, value, 1);
 	}
 
-	/* For ch3_setting, the value to put in the register is 7 less than the input number */
+	/* For ch3_setting, the value to put in the register is
+	   7 less than the input number */
 	if (ch3_setting != 0) {
-		status =
-		    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					  ADC_INPUT_CH3, 2, &value, 1);
 		value &= (!INPUT_SEL_MASK);
 		value |= (ch3_setting - 1) << 4;
 		value &= 0xff;
-		status =
-		    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					   ADC_INPUT_CH3, 2, value, 1);
 	}
 
@@ -290,12 +258,9 @@ int cx231xx_colibri_set_mode(struct cx231xx *dev, enum AFE_MODE mode)
 		break;
 	}
 
-	if ((mode != dev->colibri_mode)
-	    && (dev->video_input == CX231XX_VMUX_TELEVISION)) {
-		status =
-		    cx231xx_colibri_adjust_ref_count(dev,
+	if ((mode != dev->colibri_mode) && (dev->video_input == CX231XX_VMUX_TELEVISION))
+		status = cx231xx_colibri_adjust_ref_count(dev,
 						     CX231XX_VMUX_TELEVISION);
-	}
 
 	dev->colibri_mode = mode;
 
@@ -314,84 +279,80 @@ int cx231xx_colibri_update_power_control(struct cx231xx *dev, AV_MODE avmode)
 
 		if (avmode == POLARIS_AVMODE_ANALOGT_TV) {
 			while (colibri_power_status != 0x18) {
-				status =
-				    cx231xx_write_i2c_data(dev,
-							   Colibri_DEVICE_ADDRESS,
-							   SUP_BLK_PWRDN, 2,
-							   0x18, 1);
-				status =
-				    cx231xx_read_i2c_data(dev,
-							  Colibri_DEVICE_ADDRESS,
-							  SUP_BLK_PWRDN, 2,
-							  &colibri_power_status,
-							  1);
+				status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							0x18, 1);
+				status = cx231xx_read_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							&colibri_power_status,
+							1);
 				if (status < 0)
 					break;
 			}
 
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH1, 2, 0x00,
 						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH2, 2, 0x00,
 						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH3, 2, 0x00,
 						   1);
 		} else if (avmode == POLARIS_AVMODE_DIGITAL) {
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH1, 2, 0x70,
 						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH2, 2, 0x70,
 						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH3, 2, 0x70,
 						   1);
 
-			status =
-			    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_read_i2c_data(dev,
+						  Colibri_DEVICE_ADDRESS,
 						  SUP_BLK_PWRDN, 2,
 						  &colibri_power_status, 1);
 			colibri_power_status |= 0x07;
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   SUP_BLK_PWRDN, 2,
 						   colibri_power_status, 1);
 		} else if (avmode == POLARIS_AVMODE_ENXTERNAL_AV) {
 
 			while (colibri_power_status != 0x18) {
-				status =
-				    cx231xx_write_i2c_data(dev,
-							   Colibri_DEVICE_ADDRESS,
-							   SUP_BLK_PWRDN, 2,
-							   0x18, 1);
-				status =
-				    cx231xx_read_i2c_data(dev,
-							  Colibri_DEVICE_ADDRESS,
-							  SUP_BLK_PWRDN, 2,
-							  &colibri_power_status,
-							  1);
+				status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							0x18, 1);
+				status = cx231xx_read_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							&colibri_power_status,
+							1);
 				if (status < 0)
 					break;
 			}
 
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH1, 2, 0x00,
 						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH2, 2, 0x00,
 						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+			status = cx231xx_write_i2c_data(dev,
+						   Colibri_DEVICE_ADDRESS,
 						   ADC_PWRDN_CLAMP_CH3, 2, 0x00,
 						   1);
 		} else {
@@ -402,85 +363,83 @@ int cx231xx_colibri_update_power_control(struct cx231xx *dev, AV_MODE avmode)
 	default:
 		if (avmode == POLARIS_AVMODE_ANALOGT_TV) {
 			while (colibri_power_status != 0x18) {
-				status =
-				    cx231xx_write_i2c_data(dev,
-							   Colibri_DEVICE_ADDRESS,
-							   SUP_BLK_PWRDN, 2,
-							   0x18, 1);
-				status =
-				    cx231xx_read_i2c_data(dev,
-							  Colibri_DEVICE_ADDRESS,
-							  SUP_BLK_PWRDN, 2,
-							  &colibri_power_status,
-							  1);
+				status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							0x18, 1);
+				status = cx231xx_read_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							&colibri_power_status,
+							1);
 				if (status < 0)
 					break;
 			}
 
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH1, 2, 0x40,
-						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH2, 2, 0x40,
-						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH3, 2, 0x00,
-						   1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH1, 2,
+							0x40, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH2, 2,
+							0x40, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH3, 2,
+							0x00, 1);
 		} else if (avmode == POLARIS_AVMODE_DIGITAL) {
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH1, 2, 0x70,
-						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH2, 2, 0x70,
-						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH3, 2, 0x70,
-						   1);
-
-			status =
-			    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						  SUP_BLK_PWRDN, 2,
-						  &colibri_power_status, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH1, 2,
+							0x70, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH2, 2,
+							0x70, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH3, 2,
+							0x70, 1);
+
+			status = cx231xx_read_i2c_data(dev,
+						       Colibri_DEVICE_ADDRESS,
+						       SUP_BLK_PWRDN, 2,
+						       &colibri_power_status,
+						       1);
 			colibri_power_status |= 0x07;
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   SUP_BLK_PWRDN, 2,
-						   colibri_power_status, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							colibri_power_status,
+							1);
 		} else if (avmode == POLARIS_AVMODE_ENXTERNAL_AV) {
 			while (colibri_power_status != 0x18) {
-				status =
-				    cx231xx_write_i2c_data(dev,
-							   Colibri_DEVICE_ADDRESS,
-							   SUP_BLK_PWRDN, 2,
-							   0x18, 1);
-				status =
-				    cx231xx_read_i2c_data(dev,
-							  Colibri_DEVICE_ADDRESS,
-							  SUP_BLK_PWRDN, 2,
-							  &colibri_power_status,
-							  1);
+				status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							0x18, 1);
+				status = cx231xx_read_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							SUP_BLK_PWRDN, 2,
+							&colibri_power_status,
+							1);
 				if (status < 0)
 					break;
 			}
 
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH1, 2, 0x00,
-						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH2, 2, 0x00,
-						   1);
-			status =
-			    cx231xx_write_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						   ADC_PWRDN_CLAMP_CH3, 2, 0x40,
-						   1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH1, 2,
+							0x00, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH2, 2,
+							0x00, 1);
+			status = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							ADC_PWRDN_CLAMP_CH3, 2,
+							0x40, 1);
 		} else {
 			cx231xx_info("Invalid AV mode input\n");
 			status = -1;
@@ -499,19 +458,15 @@ int cx231xx_colibri_adjust_ref_count(struct cx231xx *dev, u32 video_input)
 	dev->video_input = video_input;
 
 	if (video_input == CX231XX_VMUX_TELEVISION) {
-		status =
-		    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					  ADC_INPUT_CH3, 2, &input_mode, 1);
-		status =
-		    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					  ADC_NTF_PRECLMP_EN_CH3, 2, &ntf_mode,
 					  1);
 	} else {
-		status =
-		    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					  ADC_INPUT_CH1, 2, &input_mode, 1);
-		status =
-		    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
 					  ADC_NTF_PRECLMP_EN_CH1, 2, &ntf_mode,
 					  1);
 	}
@@ -540,9 +495,9 @@ int cx231xx_colibri_adjust_ref_count(struct cx231xx *dev, u32 video_input)
 	return status;
 }
 
-/*************************************************************************************
- *       V I D E O / A U D I O    D E C O D E R    C O N T R O L   functions         *
- *************************************************************************************/
+/******************************************************************************
+ *     V I D E O / A U D I O    D E C O D E R    C O N T R O L   functions    *
+ ******************************************++**********************************/
 int cx231xx_set_video_input_mux(struct cx231xx *dev, u8 input)
 {
 	int status = 0;
@@ -552,38 +507,38 @@ int cx231xx_set_video_input_mux(struct cx231xx *dev, u8 input)
 	case CX231XX_VMUX_SVIDEO:
 		if ((dev->current_pcb_config.type == USB_BUS_POWER) &&
 		    (dev->power_mode != POLARIS_AVMODE_ENXTERNAL_AV)) {
-			status = cx231xx_set_power_mode(dev, POLARIS_AVMODE_ENXTERNAL_AV);	/* External AV */
+			/* External AV */
+			status = cx231xx_set_power_mode(dev,
+					POLARIS_AVMODE_ENXTERNAL_AV);
 			if (status < 0) {
-				cx231xx_errdev
-				    ("%s: cx231xx_set_power_mode : Failed to set Power - errCode [%d]!\n",
+				cx231xx_errdev("%s: cx231xx_set_power_mode : Failed to set Power - errCode [%d]!\n",
 				     __func__, status);
 				return status;
 			}
 		}
-		status =
-		    cx231xx_set_decoder_video_input(dev, INPUT(input)->type,
-						    INPUT(input)->vmux);
+		status = cx231xx_set_decoder_video_input(dev,
+							 INPUT(input)->type,
+							 INPUT(input)->vmux);
 		break;
 	case CX231XX_VMUX_TELEVISION:
 	case CX231XX_VMUX_CABLE:
 		if ((dev->current_pcb_config.type == USB_BUS_POWER) &&
 		    (dev->power_mode != POLARIS_AVMODE_ANALOGT_TV)) {
-			status = cx231xx_set_power_mode(dev, POLARIS_AVMODE_ANALOGT_TV);	/* Tuner */
+			/* Tuner */
+			status = cx231xx_set_power_mode(dev,
+						POLARIS_AVMODE_ANALOGT_TV);
 			if (status < 0) {
-				cx231xx_errdev
-				    ("%s: cx231xx_set_power_mode : Failed to set Power - errCode [%d]!\n",
+				cx231xx_errdev("%s: cx231xx_set_power_mode : Failed to set Power - errCode [%d]!\n",
 				     __func__, status);
 				return status;
 			}
 		}
-		status =
-		    cx231xx_set_decoder_video_input(dev,
-						    CX231XX_VMUX_COMPOSITE1,
-						    INPUT(input)->vmux);
+		status = cx231xx_set_decoder_video_input(dev,
+							CX231XX_VMUX_COMPOSITE1,
+							INPUT(input)->vmux);
 		break;
 	default:
-		cx231xx_errdev
-		    ("%s: cx231xx_set_power_mode : Unknown Input %d !\n",
+		cx231xx_errdev("%s: cx231xx_set_power_mode : Unknown Input %d !\n",
 		     __func__, INPUT(input)->type);
 		break;
 	}
@@ -602,8 +557,7 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev, u8 pin_type, u8 input)
 	if (pin_type != dev->video_input) {
 		status = cx231xx_colibri_adjust_ref_count(dev, pin_type);
 		if (status < 0) {
-			cx231xx_errdev
-			    ("%s: cx231xx_colibri_adjust_ref_count :Failed to set Colibri input mux - errCode [%d]!\n",
+			cx231xx_errdev("%s: cx231xx_colibri_adjust_ref_count :Failed to set Colibri input mux - errCode [%d]!\n",
 			     __func__, status);
 			return status;
 		}
@@ -612,57 +566,190 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev, u8 pin_type, u8 input)
 	/* call colibri block to set video inputs */
 	status = cx231xx_colibri_set_input_mux(dev, input);
 	if (status < 0) {
-		cx231xx_errdev
-		    ("%s: cx231xx_colibri_set_input_mux :Failed to set Colibri input mux - errCode [%d]!\n",
+		cx231xx_errdev("%s: cx231xx_colibri_set_input_mux :Failed to set Colibri input mux - errCode [%d]!\n",
 		     __func__, status);
 		return status;
 	}
 
 	switch (pin_type) {
 	case CX231XX_VMUX_COMPOSITE1:
-		{
-			status =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  AFE_CTRL, 2, &value, 4);
+		status = cx231xx_read_i2c_data(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						AFE_CTRL, 2, &value, 4);
+		value |= (0 << 13) | (1 << 4);
+		value &= ~(1 << 5);
+
+		value &= (~(0x1ff8000));	/* set [24:23] [22:15] to 0  */
+		value |= 0x1000000;	/* set FUNC_MODE[24:23] = 2 IF_MOD[22:15] = 0  */
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						AFE_CTRL, 2, value, 4);
+
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						OUT_CTRL1, 2, &value, 4);
+		value |= (1 << 7);
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						OUT_CTRL1, 2, value, 4);
+
+		/* Set vip 1.1 output mode */
+		status = cx231xx_read_modify_write_i2c_dword(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							OUT_CTRL1,
+							FLD_OUT_MODE,
+							OUT_MODE_VIP11);
+
+		/* Tell DIF object to go to baseband mode  */
+		status = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
+		if (status < 0) {
+			cx231xx_errdev("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
+				__func__, status);
+			return status;
+		}
+
+		/* Read the DFE_CTRL1 register */
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						DFE_CTRL1, 2, &value, 4);
+
+		/* enable the VBI_GATE_EN */
+		value |= FLD_VBI_GATE_EN;
+
+		/* Enable the auto-VGA enable */
+		value |= FLD_VGA_AUTO_EN;
+
+		/* Write it back */
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						DFE_CTRL1, 2, value, 4);
+
+		/* Disable auto config of registers */
+		status = cx231xx_read_modify_write_i2c_dword(dev,
+					HAMMERHEAD_I2C_ADDRESS,
+					MODE_CTRL, FLD_ACFG_DIS,
+					cx231xx_set_field(FLD_ACFG_DIS, 1));
+
+		/* Set CVBS input mode */
+		status = cx231xx_read_modify_write_i2c_dword(dev,
+			HAMMERHEAD_I2C_ADDRESS,
+			MODE_CTRL, FLD_INPUT_MODE,
+			cx231xx_set_field(FLD_INPUT_MODE, INPUT_MODE_CVBS_0));
+		break;
+	case CX231XX_VMUX_SVIDEO:
+		/* Disable the use of  DIF */
+
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					       AFE_CTRL, 2, &value, 4);
+
+		value &= (~(0x1ff8000));	/* set [24:23] [22:15] to 0 */
+		value |= 0x1000010;	/* set FUNC_MODE[24:23] = 2
+						IF_MOD[22:15] = 0 DCR_BYP_CH2[4:4] = 1; */
+		status = cx231xx_write_i2c_data(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						AFE_CTRL, 2, value, 4);
+
+		/* Tell DIF object to go to baseband mode */
+		status = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
+		if (status < 0) {
+			cx231xx_errdev("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
+				__func__, status);
+			return status;
+		}
+
+		/* Read the DFE_CTRL1 register */
+		status = cx231xx_read_i2c_data(dev,
+					       HAMMERHEAD_I2C_ADDRESS,
+					       DFE_CTRL1, 2, &value, 4);
+
+		/* enable the VBI_GATE_EN */
+		value |= FLD_VBI_GATE_EN;
+
+		/* Enable the auto-VGA enable */
+		value |= FLD_VGA_AUTO_EN;
+
+		/* Write it back */
+		status = cx231xx_write_i2c_data(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						DFE_CTRL1, 2, value, 4);
+
+		/* Disable auto config of registers  */
+		status =  cx231xx_read_modify_write_i2c_dword(dev,
+					HAMMERHEAD_I2C_ADDRESS,
+					MODE_CTRL, FLD_ACFG_DIS,
+					cx231xx_set_field(FLD_ACFG_DIS, 1));
+
+		/* Set YC input mode */
+		status = cx231xx_read_modify_write_i2c_dword(dev,
+			HAMMERHEAD_I2C_ADDRESS,
+			MODE_CTRL,
+			FLD_INPUT_MODE,
+			cx231xx_set_field(FLD_INPUT_MODE, INPUT_MODE_YC_1));
+
+		/* Chroma to ADC2 */
+		status = cx231xx_read_i2c_data(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						AFE_CTRL, 2, &value, 4);
+		value |= FLD_CHROMA_IN_SEL;	/* set the chroma in select */
+
+		/* Clear VGA_SEL_CH2 and VGA_SEL_CH3 (bits 7 and 8)
+		   This sets them to use video
+		   rather than audio.  Only one of the two will be in use. */
+		value &= ~(FLD_VGA_SEL_CH2 | FLD_VGA_SEL_CH3);
+
+		status = cx231xx_write_i2c_data(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						AFE_CTRL, 2, value, 4);
+
+		status = cx231xx_colibri_set_mode(dev, AFE_MODE_BASEBAND);
+		break;
+	case CX231XX_VMUX_TELEVISION:
+	case CX231XX_VMUX_CABLE:
+	default:
+		switch (dev->model) {
+		case CX231XX_BOARD_CNXT_RDE_250:
+		case CX231XX_BOARD_CNXT_RDU_250:
+			/* Disable the use of  DIF   */
+
+			status = cx231xx_read_i2c_data(dev,
+						       HAMMERHEAD_I2C_ADDRESS,
+						       AFE_CTRL, 2,
+						       &value, 4);
 			value |= (0 << 13) | (1 << 4);
 			value &= ~(1 << 5);
 
-			value &= (~(0x1FF8000));	/* set [24:23] [22:15] to 0  */
-			value |= 0x1000000;	/* set FUNC_MODE[24:23] = 2 IF_MOD[22:15] = 0  */
-			status =
-			    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						   AFE_CTRL, 2, value, 4);
+			value &= (~(0x1FF8000));	/* set [24:23] [22:15] to 0 */
+			value |= 0x1000000;	/* set FUNC_MODE[24:23] = 2 IF_MOD[22:15] = 0 */
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							AFE_CTRL, 2,
+							value, 4);
 
-			status =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  OUT_CTRL1, 2, &value, 4);
+			status = cx231xx_read_i2c_data(dev,
+						       HAMMERHEAD_I2C_ADDRESS,
+						       OUT_CTRL1, 2,
+						       &value, 4);
 			value |= (1 << 7);
-			status =
-			    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						   OUT_CTRL1, 2, value, 4);
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							OUT_CTRL1, 2,
+							value, 4);
 
 			/* Set vip 1.1 output mode */
-			status =
-			    cx231xx_read_modify_write_i2c_dword(dev,
-								HAMMERHEAD_I2C_ADDRESS,
-								OUT_CTRL1,
-								FLD_OUT_MODE,
-								OUT_MODE_VIP11);
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							OUT_CTRL1, FLD_OUT_MODE,
+							OUT_MODE_VIP11);
 
-			/* Tell DIF object to go to baseband mode  */
-			status =
-			    cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
+			/* Tell DIF object to go to baseband mode */
+			status = cx231xx_dif_set_standard(dev,
+							  DIF_USE_BASEBAND);
 			if (status < 0) {
-				cx231xx_errdev
-				    ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
-				     __func__, status);
+				cx231xx_errdev("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
+					__func__, status);
 				return status;
 			}
 
 			/* Read the DFE_CTRL1 register */
-			status =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  DFE_CTRL1, 2, &value, 4);
+			status = cx231xx_read_i2c_data(dev,
+						       HAMMERHEAD_I2C_ADDRESS,
+						       DFE_CTRL1, 2,
+						       &value, 4);
 
 			/* enable the VBI_GATE_EN */
 			value |= FLD_VBI_GATE_EN;
@@ -671,349 +758,144 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev, u8 pin_type, u8 input)
 			value |= FLD_VGA_AUTO_EN;
 
 			/* Write it back */
-			status =
-			    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						   DFE_CTRL1, 2, value, 4);
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							DFE_CTRL1, 2,
+							value, 4);
 
 			/* Disable auto config of registers */
-			status =
-			    cx231xx_read_modify_write_i2c_dword(dev,
-								HAMMERHEAD_I2C_ADDRESS,
-								MODE_CTRL,
-								FLD_ACFG_DIS,
-								cx231xx_set_field
-								(FLD_ACFG_DIS,
-								 1));
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+					HAMMERHEAD_I2C_ADDRESS,
+					MODE_CTRL, FLD_ACFG_DIS,
+					cx231xx_set_field(FLD_ACFG_DIS, 1));
 
 			/* Set CVBS input mode */
-			status =
-			    cx231xx_read_modify_write_i2c_dword(dev,
-								HAMMERHEAD_I2C_ADDRESS,
-								MODE_CTRL,
-								FLD_INPUT_MODE,
-								cx231xx_set_field
-								(FLD_INPUT_MODE,
-								 INPUT_MODE_CVBS_0));
-		}
-		break;
-	case CX231XX_VMUX_SVIDEO:
-		{
-			/* Disable the use of  DIF */
-
-			status =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  AFE_CTRL, 2, &value, 4);
-
-			value &= (~(0x1FF8000));	/* set [24:23] [22:15] to 0 */
-			value |= 0x1000010;	/* set FUNC_MODE[24:23] = 2
-						   IF_MOD[22:15] = 0 DCR_BYP_CH2[4:4] = 1; */
-			status =
-			    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						   AFE_CTRL, 2, value, 4);
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+				HAMMERHEAD_I2C_ADDRESS,
+				MODE_CTRL, FLD_INPUT_MODE,
+				cx231xx_set_field(FLD_INPUT_MODE, INPUT_MODE_CVBS_0));
+			break;
+		default:
+			/* Enable the DIF for the tuner */
 
-			/* Tell DIF object to go to baseband mode */
-			status =
-			    cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
+			/* Reinitialize the DIF */
+			status = cx231xx_dif_set_standard(dev, dev->norm);
 			if (status < 0) {
-				cx231xx_errdev
-				    ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
-				     __func__, status);
+				cx231xx_errdev("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
+					__func__, status);
 				return status;
 			}
 
+			/* Make sure bypass is cleared */
+			status = cx231xx_read_i2c_data(dev,
+						      HAMMERHEAD_I2C_ADDRESS,
+						      DIF_MISC_CTRL,
+						      2, &value, 4);
+
+			/* Clear the bypass bit */
+			value &= ~FLD_DIF_DIF_BYPASS;
+
+			/* Enable the use of the DIF block */
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							DIF_MISC_CTRL,
+							2, value, 4);
+
 			/* Read the DFE_CTRL1 register */
-			status =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  DFE_CTRL1, 2, &value, 4);
+			status = cx231xx_read_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							DFE_CTRL1, 2,
+							&value, 4);
 
-			/* enable the VBI_GATE_EN */
-			value |= FLD_VBI_GATE_EN;
+			/* Disable the VBI_GATE_EN */
+			value &= ~FLD_VBI_GATE_EN;
 
-			/* Enable the auto-VGA enable */
-			value |= FLD_VGA_AUTO_EN;
+			/* Enable the auto-VGA enable, AGC, and
+			   set the skip count to 2 */
+			value |= FLD_VGA_AUTO_EN | FLD_AGC_AUTO_EN | 0x00200000;
 
 			/* Write it back */
-			status =
-			    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						   DFE_CTRL1, 2, value, 4);
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							DFE_CTRL1, 2,
+							value, 4);
 
-			/* Disable auto config of registers  */
-			status =
-			    cx231xx_read_modify_write_i2c_dword(dev,
-								HAMMERHEAD_I2C_ADDRESS,
-								MODE_CTRL,
-								FLD_ACFG_DIS,
-								cx231xx_set_field
-								(FLD_ACFG_DIS,
-								 1));
-
-			/* Set YC input mode */
-			status =
-			    cx231xx_read_modify_write_i2c_dword(dev,
-								HAMMERHEAD_I2C_ADDRESS,
-								MODE_CTRL,
-								FLD_INPUT_MODE,
-								cx231xx_set_field
-								(FLD_INPUT_MODE,
-								 INPUT_MODE_YC_1));
-
-			/* Chroma to ADC2 */
-			status =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  AFE_CTRL, 2, &value, 4);
-			value |= FLD_CHROMA_IN_SEL;	/* set the chroma in select */
+			/* Wait 15 ms */
+			msleep(1);
 
-			/* Clear VGA_SEL_CH2 and VGA_SEL_CH3 (bits 7 and 8)  This sets them to use video
-			   rather than audio.  Only one of the two will be in use. */
-			value &= ~(FLD_VGA_SEL_CH2 | FLD_VGA_SEL_CH3);
+			/* Disable the auto-VGA enable AGC */
+			value &= ~(FLD_VGA_AUTO_EN);
 
-			status =
-			    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						   AFE_CTRL, 2, value, 4);
+			/* Write it back */
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							DFE_CTRL1, 2,
+							value, 4);
 
-			status =
-			    cx231xx_colibri_set_mode(dev, AFE_MODE_BASEBAND);
-		}
-		break;
-	case CX231XX_VMUX_TELEVISION:
-	case CX231XX_VMUX_CABLE:
-	default:
-		{
-			switch (dev->model) {
-			case CX231XX_BOARD_CNXT_RDE_250:
-			case CX231XX_BOARD_CNXT_RDU_250:
-				{
-					/* Disable the use of  DIF   */
-
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  AFE_CTRL, 2,
-								  &value, 4);
-					value |= (0 << 13) | (1 << 4);
-					value &= ~(1 << 5);
-
-					value &= (~(0x1FF8000));	/* set [24:23] [22:15] to 0 */
-					value |= 0x1000000;	/* set FUNC_MODE[24:23] = 2 IF_MOD[22:15] = 0 */
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   AFE_CTRL, 2,
-								   value, 4);
-
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  OUT_CTRL1, 2,
-								  &value, 4);
-					value |= (1 << 7);
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   OUT_CTRL1, 2,
-								   value, 4);
-
-					/* Set vip 1.1 output mode */
-					status =
-					    cx231xx_read_modify_write_i2c_dword
-					    (dev, HAMMERHEAD_I2C_ADDRESS,
-					     OUT_CTRL1, FLD_OUT_MODE,
-					     OUT_MODE_VIP11);
-
-					/* Tell DIF object to go to baseband mode */
-					status =
-					    cx231xx_dif_set_standard(dev,
-								     DIF_USE_BASEBAND);
-					if (status < 0) {
-						cx231xx_errdev
-						    ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
-						     __func__, status);
-						return status;
-					}
-
-					/* Read the DFE_CTRL1 register */
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  DFE_CTRL1, 2,
-								  &value, 4);
-
-					/* enable the VBI_GATE_EN */
-					value |= FLD_VBI_GATE_EN;
-
-					/* Enable the auto-VGA enable */
-					value |= FLD_VGA_AUTO_EN;
-
-					/* Write it back */
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   DFE_CTRL1, 2,
-								   value, 4);
-
-					/* Disable auto config of registers */
-					status =
-					    cx231xx_read_modify_write_i2c_dword
-					    (dev, HAMMERHEAD_I2C_ADDRESS,
-					     MODE_CTRL, FLD_ACFG_DIS,
-					     cx231xx_set_field(FLD_ACFG_DIS,
-							       1));
-
-					/* Set CVBS input mode */
-					status =
-					    cx231xx_read_modify_write_i2c_dword
-					    (dev, HAMMERHEAD_I2C_ADDRESS,
-					     MODE_CTRL, FLD_INPUT_MODE,
-					     cx231xx_set_field(FLD_INPUT_MODE,
-							       INPUT_MODE_CVBS_0));
-				}
-				break;
-			default:
-				{
-					/* Enable the DIF for the tuner */
-
-					/* Reinitialize the DIF */
-					status =
-					    cx231xx_dif_set_standard(dev,
-								     dev->norm);
-					if (status < 0) {
-						cx231xx_errdev
-						    ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
-						     __func__, status);
-						return status;
-					}
-
-					/* Make sure bypass is cleared */
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  DIF_MISC_CTRL,
-								  2, &value, 4);
-
-					/* Clear the bypass bit */
-					value &= ~FLD_DIF_DIF_BYPASS;
-
-					/* Enable the use of the DIF block */
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   DIF_MISC_CTRL,
-								   2, value, 4);
-
-					/* Read the DFE_CTRL1 register */
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  DFE_CTRL1, 2,
-								  &value, 4);
-
-					/* Disable the VBI_GATE_EN */
-					value &= ~FLD_VBI_GATE_EN;
-
-					/* Enable the auto-VGA enable, AGC, and set the skip count to 2 */
-					value |=
-					    FLD_VGA_AUTO_EN | FLD_AGC_AUTO_EN |
-					    0x00200000;
-
-					/* Write it back */
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   DFE_CTRL1, 2,
-								   value, 4);
-
-					/* Wait 15 ms */
-					msleep(1);
-
-					/* Disable the auto-VGA enable AGC */
-					value &= ~(FLD_VGA_AUTO_EN);
-
-					/* Write it back */
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   DFE_CTRL1, 2,
-								   value, 4);
-
-					/* Enable Polaris B0 AGC output */
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  PIN_CTRL, 2,
-								  &value, 4);
-					value |=
-					    (FLD_OEF_AGC_RF) |
-					    (FLD_OEF_AGC_IFVGA) |
-					    (FLD_OEF_AGC_IF);
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   PIN_CTRL, 2,
-								   value, 4);
-
-					/* Set vip 1.1 output mode */
-					status =
-					    cx231xx_read_modify_write_i2c_dword
-					    (dev, HAMMERHEAD_I2C_ADDRESS,
-					     OUT_CTRL1, FLD_OUT_MODE,
-					     OUT_MODE_VIP11);
-
-					/* Disable auto config of registers */
-					status =
-					    cx231xx_read_modify_write_i2c_dword
-					    (dev, HAMMERHEAD_I2C_ADDRESS,
-					     MODE_CTRL, FLD_ACFG_DIS,
-					     cx231xx_set_field(FLD_ACFG_DIS,
-							       1));
-
-					/* Set CVBS input mode */
-					status =
-					    cx231xx_read_modify_write_i2c_dword
-					    (dev, HAMMERHEAD_I2C_ADDRESS,
-					     MODE_CTRL, FLD_INPUT_MODE,
-					     cx231xx_set_field(FLD_INPUT_MODE,
-							       INPUT_MODE_CVBS_0));
-
-					/* Set some bits in AFE_CTRL so that channel 2 or 3 is ready to receive audio */
-					/* Clear clamp for channels 2 and 3      (bit 16-17) */
-					/* Clear droop comp                      (bit 19-20) */
-					/* Set VGA_SEL (for audio control)       (bit 7-8) */
-					status =
-					    cx231xx_read_i2c_data(dev,
-								  HAMMERHEAD_I2C_ADDRESS,
-								  AFE_CTRL, 2,
-								  &value, 4);
-
-					value |=
-					    FLD_VGA_SEL_CH3 | FLD_VGA_SEL_CH2;
-
-					status =
-					    cx231xx_write_i2c_data(dev,
-								   HAMMERHEAD_I2C_ADDRESS,
-								   AFE_CTRL, 2,
-								   value, 4);
-				}
-				break;
+			/* Enable Polaris B0 AGC output */
+			status = cx231xx_read_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							PIN_CTRL, 2,
+							&value, 4);
+			value |= (FLD_OEF_AGC_RF) |
+				 (FLD_OEF_AGC_IFVGA) |
+				 (FLD_OEF_AGC_IF);
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							PIN_CTRL, 2,
+							value, 4);
+
+			/* Set vip 1.1 output mode */
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						OUT_CTRL1, FLD_OUT_MODE,
+						OUT_MODE_VIP11);
+
+			/* Disable auto config of registers */
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+					HAMMERHEAD_I2C_ADDRESS,
+					MODE_CTRL, FLD_ACFG_DIS,
+					cx231xx_set_field(FLD_ACFG_DIS, 1));
+
+			/* Set CVBS input mode */
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+				HAMMERHEAD_I2C_ADDRESS,
+				MODE_CTRL, FLD_INPUT_MODE,
+				cx231xx_set_field(FLD_INPUT_MODE, INPUT_MODE_CVBS_0));
+
+			/* Set some bits in AFE_CTRL so that channel 2 or 3 is ready to receive audio */
+			/* Clear clamp for channels 2 and 3      (bit 16-17) */
+			/* Clear droop comp                      (bit 19-20) */
+			/* Set VGA_SEL (for audio control)       (bit 7-8) */
+			status = cx231xx_read_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							AFE_CTRL, 2,
+							&value, 4);
+
+			value |= FLD_VGA_SEL_CH3 | FLD_VGA_SEL_CH2;
+
+			status = cx231xx_write_i2c_data(dev,
+							HAMMERHEAD_I2C_ADDRESS,
+							AFE_CTRL, 2,
+							value, 4);
+			break;
 
-			}
 		}
 		break;
 	}
 
 	/* Set raw VBI mode */
-	status =
-	    cx231xx_read_modify_write_i2c_dword(dev, HAMMERHEAD_I2C_ADDRESS,
-						OUT_CTRL1, FLD_VBIHACTRAW_EN,
-						cx231xx_set_field
-						(FLD_VBIHACTRAW_EN, 1));
+	status = cx231xx_read_modify_write_i2c_dword(dev,
+				HAMMERHEAD_I2C_ADDRESS,
+				OUT_CTRL1, FLD_VBIHACTRAW_EN,
+				cx231xx_set_field(FLD_VBIHACTRAW_EN, 1));
 
-	status =
-	    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, OUT_CTRL1, 2,
-				  &value, 4);
+	status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+				       OUT_CTRL1, 2,
+				       &value, 4);
 	if (value & 0x02) {
 		value |= (1 << 19);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   OUT_CTRL1, 2, value, 4);
 	}
 
@@ -1032,70 +914,62 @@ int cx231xx_do_mode_ctrl_overrides(struct cx231xx *dev)
 		     (unsigned int)dev->norm);
 
 	/* Change the DFE_CTRL3 bp_percent to fix flagging */
-	status =
-	    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, DFE_CTRL3, 2,
-				   0xCD3F0280, 4);
+	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					DFE_CTRL3, 2,
+					0xCD3F0280, 4);
 
 	if (dev->norm & (V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_JP | V4L2_STD_PAL_M)) {
 		cx231xx_info("do_mode_ctrl_overrides NTSC\n");
 
-		/* Move the close caption lines out of active video, adjust the active video start point */
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		/* Move the close caption lines out of active video,
+		   adjust the active video start point */
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							VERT_TIM_CTRL,
 							FLD_VBLANK_CNT, 0x18);
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							VERT_TIM_CTRL,
 							FLD_VACTIVE_CNT,
 							0x1E6000);
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							VERT_TIM_CTRL,
 							FLD_V656BLANK_CNT,
 							0x1E000000);
 
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							HORIZ_TIM_CTRL,
 							FLD_HBLANK_CNT,
 							cx231xx_set_field
 							(FLD_HBLANK_CNT, 0x79));
-	} else if (dev->
-		   norm & (V4L2_STD_PAL_B | V4L2_STD_PAL_G | V4L2_STD_PAL_D |
-			   V4L2_STD_PAL_I | V4L2_STD_PAL_N | V4L2_STD_PAL_Nc)) {
+	} else if (dev->norm & (V4L2_STD_PAL_B | V4L2_STD_PAL_G |
+				V4L2_STD_PAL_D | V4L2_STD_PAL_I |
+				V4L2_STD_PAL_N | V4L2_STD_PAL_Nc)) {
 		cx231xx_info("do_mode_ctrl_overrides PAL\n");
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							VERT_TIM_CTRL,
 							FLD_VBLANK_CNT, 0x24);
 		/* Adjust the active video horizontal start point */
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							HORIZ_TIM_CTRL,
 							FLD_HBLANK_CNT,
 							cx231xx_set_field
 							(FLD_HBLANK_CNT, 0x85));
-	} else if (dev->
-		   norm & (V4L2_STD_SECAM_B | V4L2_STD_SECAM_D |
-			   V4L2_STD_SECAM_G | V4L2_STD_SECAM_K |
-			   V4L2_STD_SECAM_K1 | V4L2_STD_SECAM_L |
-			   V4L2_STD_SECAM_LC)) {
+	} else if (dev->norm & (V4L2_STD_SECAM_B  | V4L2_STD_SECAM_D |
+				V4L2_STD_SECAM_G  | V4L2_STD_SECAM_K |
+				V4L2_STD_SECAM_K1 | V4L2_STD_SECAM_L |
+				V4L2_STD_SECAM_LC)) {
 		cx231xx_info("do_mode_ctrl_overrides SECAM\n");
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status =  cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							VERT_TIM_CTRL,
 							FLD_VBLANK_CNT, 0x24);
 		/* Adjust the active video horizontal start point */
-		status =
-		    cx231xx_read_modify_write_i2c_dword(dev,
+		status = cx231xx_read_modify_write_i2c_dword(dev,
 							HAMMERHEAD_I2C_ADDRESS,
 							HORIZ_TIM_CTRL,
 							FLD_HBLANK_CNT,
@@ -1137,69 +1011,57 @@ int cx231xx_set_audio_decoder_input(struct cx231xx *dev,
 	u32 value = 0;
 
 	/* Put it in soft reset   */
-	status =
-	    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, GENERAL_CTL, 2,
-				  &gen_ctrl, 1);
+	status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+				       GENERAL_CTL, 2, &gen_ctrl, 1);
 	gen_ctrl |= 1;
-	status =
-	    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, GENERAL_CTL, 2,
-				   gen_ctrl, 1);
+	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					GENERAL_CTL, 2, gen_ctrl, 1);
 
 	switch (audio_input) {
 	case AUDIO_INPUT_LINE:
-
 		/* setup AUD_IO control from Merlin paralle output */
-		value =
-		    cx231xx_set_field(FLD_AUD_CHAN1_SRC, AUD_CHAN_SRC_PARALLEL);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-					   AUD_IO_CTRL, 2, value, 4);
+		value = cx231xx_set_field(FLD_AUD_CHAN1_SRC,
+					  AUD_CHAN_SRC_PARALLEL);
+		status = cx231xx_write_i2c_data(dev,
+						HAMMERHEAD_I2C_ADDRESS,
+						AUD_IO_CTRL, 2, value, 4);
 
 		/* setup input to Merlin, SRC2 connect to AC97
 		   bypass upsample-by-2, slave mode, sony mode, left justify
 		   adr 091c, dat 01000000 */
-		status =
-		    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, AC97_CTL,
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					       AC97_CTL,
 					  2, &dwval, 4);
 
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   AC97_CTL, 2,
 					   (dwval | FLD_AC97_UP2X_BYPASS), 4);
 
 		/* select the parallel1 and SRC3 */
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-					   BAND_OUT_SEL, 2,
-					   cx231xx_set_field(FLD_SRC3_IN_SEL,
-							     0x0) |
-					   cx231xx_set_field(FLD_SRC3_CLK_SEL,
-							     0x0) |
-					   cx231xx_set_field
-					   (FLD_PARALLEL1_SRC_SEL, 0x0), 4);
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+				BAND_OUT_SEL, 2,
+				cx231xx_set_field(FLD_SRC3_IN_SEL, 0x0) |
+				cx231xx_set_field(FLD_SRC3_CLK_SEL, 0x0) |
+				cx231xx_set_field(FLD_PARALLEL1_SRC_SEL, 0x0),
+				4);
 
 		/* unmute all, AC97 in, independence mode
 		   adr 08d0, data 0x00063073 */
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   PATH1_CTL1, 2, 0x00063073, 4);
 
 		/* set AVC maximum threshold, adr 08d4, dat ffff0024 */
-		status =
-		    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					  PATH1_VOL_CTL, 2, &dwval, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   PATH1_VOL_CTL, 2,
 					   (dwval | FLD_PATH1_AVC_THRESHOLD),
 					   4);
 
 		/* set SC maximum threshold, adr 08ec, dat ffffb3a3 */
-		status =
-		    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					  PATH1_SC_CTL, 2, &dwval, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status =  cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   PATH1_SC_CTL, 2,
 					   (dwval | FLD_PATH1_SC_THRESHOLD), 4);
 		break;
@@ -1208,73 +1070,46 @@ int cx231xx_set_audio_decoder_input(struct cx231xx *dev,
 	default:
 
 		/* Setup SRC sources and clocks */
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-					   BAND_OUT_SEL, 2,
-					   cx231xx_set_field(FLD_SRC6_IN_SEL,
-							     0x00) |
-					   cx231xx_set_field(FLD_SRC6_CLK_SEL,
-							     0x01) |
-					   cx231xx_set_field(FLD_SRC5_IN_SEL,
-							     0x00) |
-					   cx231xx_set_field(FLD_SRC5_CLK_SEL,
-							     0x02) |
-					   cx231xx_set_field(FLD_SRC4_IN_SEL,
-							     0x02) |
-					   cx231xx_set_field(FLD_SRC4_CLK_SEL,
-							     0x03) |
-					   cx231xx_set_field(FLD_SRC3_IN_SEL,
-							     0x00) |
-					   cx231xx_set_field(FLD_SRC3_CLK_SEL,
-							     0x00) |
-					   cx231xx_set_field
-					   (FLD_BASEBAND_BYPASS_CTL,
-					    0x00) |
-					   cx231xx_set_field(FLD_AC97_SRC_SEL,
-							     0x03) |
-					   cx231xx_set_field(FLD_I2S_SRC_SEL,
-							     0x00) |
-					   cx231xx_set_field
-					   (FLD_PARALLEL2_SRC_SEL,
-					    0x02) |
-					   cx231xx_set_field
-					   (FLD_PARALLEL1_SRC_SEL, 0x01), 4);
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+			BAND_OUT_SEL, 2,
+			cx231xx_set_field(FLD_SRC6_IN_SEL, 0x00)         |
+			cx231xx_set_field(FLD_SRC6_CLK_SEL, 0x01)        |
+			cx231xx_set_field(FLD_SRC5_IN_SEL, 0x00)         |
+			cx231xx_set_field(FLD_SRC5_CLK_SEL, 0x02)        |
+			cx231xx_set_field(FLD_SRC4_IN_SEL, 0x02)         |
+			cx231xx_set_field(FLD_SRC4_CLK_SEL, 0x03)        |
+			cx231xx_set_field(FLD_SRC3_IN_SEL, 0x00)         |
+			cx231xx_set_field(FLD_SRC3_CLK_SEL, 0x00)        |
+			cx231xx_set_field(FLD_BASEBAND_BYPASS_CTL, 0x00) |
+			cx231xx_set_field(FLD_AC97_SRC_SEL, 0x03)        |
+			cx231xx_set_field(FLD_I2S_SRC_SEL, 0x00)         |
+			cx231xx_set_field(FLD_PARALLEL2_SRC_SEL, 0x02)   |
+			cx231xx_set_field(FLD_PARALLEL1_SRC_SEL, 0x01), 4);
 
 		/* Setup the AUD_IO control */
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-					   AUD_IO_CTRL, 2,
-					   cx231xx_set_field(FLD_I2S_PORT_DIR,
-							     0x00) |
-					   cx231xx_set_field(FLD_I2S_OUT_SRC,
-							     0x00) |
-					   cx231xx_set_field(FLD_AUD_CHAN3_SRC,
-							     0x00) |
-					   cx231xx_set_field(FLD_AUD_CHAN2_SRC,
-							     0x00) |
-					   cx231xx_set_field(FLD_AUD_CHAN1_SRC,
-							     0x03), 4);
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+			AUD_IO_CTRL, 2,
+			cx231xx_set_field(FLD_I2S_PORT_DIR, 0x00)  |
+			cx231xx_set_field(FLD_I2S_OUT_SRC, 0x00)   |
+			cx231xx_set_field(FLD_AUD_CHAN3_SRC, 0x00) |
+			cx231xx_set_field(FLD_AUD_CHAN2_SRC, 0x00) |
+			cx231xx_set_field(FLD_AUD_CHAN1_SRC, 0x03), 4);
 
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   PATH1_CTL1, 2, 0x1F063870, 4);
 
 		/* setAudioStandard(_audio_standard); */
 
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   PATH1_CTL1, 2, 0x00063870, 4);
 		switch (dev->model) {
 		case CX231XX_BOARD_CNXT_RDE_250:
 		case CX231XX_BOARD_CNXT_RDU_250:
-			status =
-			    cx231xx_read_modify_write_i2c_dword(dev,
-								HAMMERHEAD_I2C_ADDRESS,
-								CHIP_CTRL,
-								FLD_SIF_EN,
-								cx231xx_set_field
-								(FLD_SIF_EN,
-								 1));
+			status = cx231xx_read_modify_write_i2c_dword(dev,
+					HAMMERHEAD_I2C_ADDRESS,
+					CHIP_CTRL,
+					FLD_SIF_EN,
+					cx231xx_set_field(FLD_SIF_EN, 1));
 			break;
 		default:
 			break;
@@ -1289,20 +1124,17 @@ int cx231xx_set_audio_decoder_input(struct cx231xx *dev,
 		break;
 
 	case AUDIO_INPUT_MUTE:
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   PATH1_CTL1, 2, 0x1F011012, 4);
 		break;
 	}
 
 	/* Take it out of soft reset */
-	status =
-	    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, GENERAL_CTL, 2,
-				  &gen_ctrl, 1);
+	status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+				       GENERAL_CTL, 2,  &gen_ctrl, 1);
 	gen_ctrl &= ~1;
-	status =
-	    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, GENERAL_CTL, 2,
-				   gen_ctrl, 1);
+	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					GENERAL_CTL, 2, gen_ctrl, 1);
 
 	return status;
 }
@@ -1320,33 +1152,29 @@ int cx231xx_resolution_set(struct cx231xx *dev)
 	get_scale(dev, width, height, &hscale, &vscale);
 
 	/* set horzontal scale */
-	status =
-	    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, HSCALE_CTRL, 2,
-				   hscale, 4);
+	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					HSCALE_CTRL, 2, hscale, 4);
 
 	/* set vertical scale */
-	status =
-	    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, VSCALE_CTRL, 2,
-				   vscale, 4);
+	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					VSCALE_CTRL, 2, vscale, 4);
 
 	return status;
 }
 
-/*************************************************************************************
- *                        C H I P Specific  C O N T R O L   functions                *
- *************************************************************************************/
+/******************************************************************************
+ *                    C H I P Specific  C O N T R O L   functions             *
+ ******************************************************************************/
 int cx231xx_init_ctrl_pin_status(struct cx231xx *dev)
 {
 	u32 value;
 	int status = 0;
 
-	status =
-	    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, PIN_CTRL, 2,
-				  &value, 4);
+	status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, PIN_CTRL,
+				       2, &value, 4);
 	value |= (~dev->board.ctl_pin_status_mask);
-	status =
-	    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, PIN_CTRL, 2,
-				   value, 4);
+	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS, PIN_CTRL,
+					2, value, 4);
 
 	return status;
 }
@@ -1357,14 +1185,12 @@ int cx231xx_set_agc_analog_digital_mux_select(struct cx231xx *dev,
 	int status = 0;
 
 	/* first set the direction to output */
-	status =
-	    cx231xx_set_gpio_direction(dev,
-				       dev->board.
-				       agc_analog_digital_select_gpio, 1);
+	status = cx231xx_set_gpio_direction(dev,
+					    dev->board.
+					    agc_analog_digital_select_gpio, 1);
 
 	/* 0 - demod ; 1 - Analog mode */
-	status =
-	    cx231xx_set_gpio_value(dev,
+	status = cx231xx_set_gpio_value(dev,
 				   dev->board.agc_analog_digital_select_gpio,
 				   analog_or_digital);
 
@@ -1378,23 +1204,21 @@ int cx231xx_enable_i2c_for_tuner(struct cx231xx *dev, u8 I2CIndex)
 
 	cx231xx_info("Changing the i2c port for tuner to %d\n", I2CIndex);
 
-	status =
-	    cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, value, 4);
+	status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER,
+				       PWR_CTL_EN, value, 4);
 	if (status < 0)
 		return status;
 
 	if (I2CIndex == I2C_1) {
 		if (value[0] & I2C_DEMOD_EN) {
 			value[0] &= ~I2C_DEMOD_EN;
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
 						   PWR_CTL_EN, value, 4);
 		}
 	} else {
 		if (!(value[0] & I2C_DEMOD_EN)) {
 			value[0] |= I2C_DEMOD_EN;
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
 						   PWR_CTL_EN, value, 4);
 		}
 	}
@@ -1403,9 +1227,9 @@ int cx231xx_enable_i2c_for_tuner(struct cx231xx *dev, u8 I2CIndex)
 
 }
 
-/*************************************************************************************
- *                     D I F - B L O C K    C O N T R O L   functions                *
- *************************************************************************************/
+/******************************************************************************
+ *                 D I F - B L O C K    C O N T R O L   functions             *
+ ******************************************************************************/
 int cx231xx_dif_configure_C2HH_for_low_IF(struct cx231xx *dev, u32 mode,
 					  u32 function_mode, u32 standard)
 {
@@ -1413,10 +1237,14 @@ int cx231xx_dif_configure_C2HH_for_low_IF(struct cx231xx *dev, u32 mode,
 
 	if (mode == V4L2_TUNER_RADIO) {
 		/* C2HH */
-		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
-		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 23, 24, function_mode);	/* FUNC_MODE = DIF */
-		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xFF);	/* IF_MODE */
-		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+				AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+				AFE_CTRL_C2HH_SRC_CTRL, 23, 24, function_mode);	/* FUNC_MODE = DIF */
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+				AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xFF);	/* IF_MODE */
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+				AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
 	} else {
 		switch (standard) {
 		case V4L2_STD_NTSC_M:	/* 75 IRE Setup */
@@ -1424,20 +1252,40 @@ int cx231xx_dif_configure_C2HH_for_low_IF(struct cx231xx *dev, u32 mode,
 		case V4L2_STD_PAL_M:
 		case V4L2_STD_PAL_N:
 		case V4L2_STD_PAL_Nc:
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 23, 24, function_mode);	/* FUNC_MODE = DIF */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xb);	/* IF_MODE */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AUD_IO_CTRL, 0, 31, 0x00000003);	/* 0x124, AUD_CHAN1_SRC = 0x3 */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 23, 24,
+					function_mode);	/* FUNC_MODE = DIF */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xb);	/* IF_MODE */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AUD_IO_CTRL, 0, 31, 0x00000003);	/* 0x124, AUD_CHAN1_SRC = 0x3 */
 			break;
 
 		case V4L2_STD_PAL_B:
 		case V4L2_STD_PAL_G:
 			/* C2HH setup */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 23, 24, function_mode);	/* FUNC_MODE = DIF */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xE);	/* IF_MODE */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 23, 24,
+					function_mode);	/* FUNC_MODE = DIF */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xE);	/* IF_MODE */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
 			break;
 
 		case V4L2_STD_PAL_D:
@@ -1450,10 +1298,19 @@ int cx231xx_dif_configure_C2HH_for_low_IF(struct cx231xx *dev, u32 mode,
 		case V4L2_STD_SECAM_K:
 		case V4L2_STD_SECAM_K1:
 			/* C2HH setup */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 23, 24, function_mode);	/* FUNC_MODE = DIF */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xF);	/* IF_MODE */
-			status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32, AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 30, 31, 0x1);	/* lo if big signal */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 23, 24,
+					function_mode);	/* FUNC_MODE = DIF */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 15, 22, 0xF);	/* IF_MODE */
+			status = cx231xx_reg_mask_write(dev,
+					HAMMERHEAD_I2C_ADDRESS, 32,
+					AFE_CTRL_C2HH_SRC_CTRL, 9, 9, 0x1);	/* no inv */
 			break;
 
 		case DIF_USE_BASEBAND:
@@ -1489,20 +1346,18 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 		func_mode = 0x01;
 	}
 
-	status =
-	    cx231xx_dif_configure_C2HH_for_low_IF(dev, dev->active_mode,
+	status = cx231xx_dif_configure_C2HH_for_low_IF(dev, dev->active_mode,
 						  func_mode, standard);
 
 	if (standard == DIF_USE_BASEBAND) {	/* base band */
-
-		/* There is a different SRC_PHASE_INC value for baseband vs. DIF */
+		/* There is a different SRC_PHASE_INC value
+		   for baseband vs. DIF */
 		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 						DIF_SRC_PHASE_INC, 2, 0xDF7DF83,
 						4);
-		status =
-		    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-					  DIF_MISC_CTRL, 2,
-					  &dif_misc_ctrl_value, 4);
+		status = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+					       DIF_MISC_CTRL, 2,
+					       &dif_misc_ctrl_value, 4);
 		dif_misc_ctrl_value |= FLD_DIF_DIF_BYPASS;
 		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 						DIF_MISC_CTRL, 2,
@@ -1510,127 +1365,92 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 
 	} else if (standard & (V4L2_STD_PAL_B | V4L2_STD_PAL_G)) {
 
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL, 0, 31, 0x6503bc0c);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL1, 0, 31, 0xbd038c85);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL2, 0, 31, 0x1db4640a);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL3, 0, 31, 0x00008800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_REF, 0, 31, 0x444C1380);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_IF, 0, 31, 0xDA302600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_INT, 0, 31, 0xDA261700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_RF, 0, 31, 0xDA262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_INT_CURRENT, 0, 31,
 					   0x26001700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_RF_CURRENT, 0, 31,
 					   0x00002660);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VIDEO_AGC_CTRL, 0, 31,
 					   0x72500800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VID_AUD_OVERRIDE, 0, 31,
 					   0x27000100);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AV_SEP_CTRL, 0, 31, 0x3F3530EC);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_COMP_FLT_CTRL, 0, 31,
 					   0x00A653A8);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_PHASE_INC, 0, 31,
 					   0x1befbf06);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_GAIN_CONTROL, 0, 31,
 					   0x000035e8);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_RPT_VARIANCE, 0, 31, 0x00000000);
 		/* Save the Spec Inversion value */
 		dif_misc_ctrl_value &= FLD_DIF_SPEC_INV;
 		dif_misc_ctrl_value |= 0x3a013F11;
 
 	} else if (standard & V4L2_STD_PAL_D) {
-
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL, 0, 31, 0x6503bc0c);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL1, 0, 31, 0xbd038c85);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL2, 0, 31, 0x1db4640a);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL3, 0, 31, 0x00008800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_REF, 0, 31, 0x444C1380);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_IF, 0, 31, 0xDA302600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_INT, 0, 31, 0xDA261700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_RF, 0, 31, 0xDA262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_INT_CURRENT, 0, 31,
 					   0x26001700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_RF_CURRENT, 0, 31,
 					   0x00002660);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VIDEO_AGC_CTRL, 0, 31,
 					   0x72500800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VID_AUD_OVERRIDE, 0, 31,
 					   0x27000100);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AV_SEP_CTRL, 0, 31, 0x3F3934EA);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_COMP_FLT_CTRL, 0, 31,
 					   0x00000000);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_PHASE_INC, 0, 31,
 					   0x1befbf06);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_GAIN_CONTROL, 0, 31,
 					   0x000035e8);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_RPT_VARIANCE, 0, 31, 0x00000000);
 		/* Save the Spec Inversion value */
 		dif_misc_ctrl_value &= FLD_DIF_SPEC_INV;
@@ -1638,116 +1458,86 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 
 	} else if (standard & V4L2_STD_PAL_I) {
 
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL, 0, 31, 0x6503bc0c);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL1, 0, 31, 0xbd038c85);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL2, 0, 31, 0x1db4640a);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL3, 0, 31, 0x00008800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_REF, 0, 31, 0x444C1380);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_IF, 0, 31, 0xDA302600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_INT, 0, 31, 0xDA261700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_RF, 0, 31, 0xDA262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_INT_CURRENT, 0, 31,
 					   0x26001700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_RF_CURRENT, 0, 31,
 					   0x00002660);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VIDEO_AGC_CTRL, 0, 31,
 					   0x72500800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VID_AUD_OVERRIDE, 0, 31,
 					   0x27000100);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AV_SEP_CTRL, 0, 31, 0x5F39A934);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_COMP_FLT_CTRL, 0, 31,
 					   0x00000000);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_PHASE_INC, 0, 31,
 					   0x1befbf06);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_GAIN_CONTROL, 0, 31,
 					   0x000035e8);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_RPT_VARIANCE, 0, 31, 0x00000000);
 		/* Save the Spec Inversion value */
 		dif_misc_ctrl_value &= FLD_DIF_SPEC_INV;
 		dif_misc_ctrl_value |= 0x3a033F11;
 
 	} else if (standard & V4L2_STD_PAL_M) {
-
 		/* improved Low Frequency Phase Noise */
 		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 						DIF_PLL_CTRL, 2, 0xFF01FF0C, 4);
 		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 						DIF_PLL_CTRL1, 2, 0xbd038c85,
 						4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL2, 2, 0x1db4640a, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL3, 2, 0x00008800, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_IF_REF, 2, 0x444C1380, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_IF_INT_CURRENT, 2,
 					   0x26001700, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_RF_CURRENT, 2, 0x00002660,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_VIDEO_AGC_CTRL, 2, 0x72500800,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_VID_AUD_OVERRIDE, 2, 0x27000100,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AV_SEP_CTRL, 2, 0x012c405d, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_COMP_FLT_CTRL, 2, 0x009f50c1, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SRC_PHASE_INC, 2, 0x1befbf06, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SRC_GAIN_CONTROL, 2, 0x000035e8,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SOFT_RST_CTRL_REVB, 2,
 					   0x00000000, 4);
 
@@ -1758,52 +1548,38 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 	} else if (standard & (V4L2_STD_PAL_N | V4L2_STD_PAL_Nc)) {
 
 		/* improved Low Frequency Phase Noise */
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL, 2, 0xFF01FF0C, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL1, 2, 0xbd038c85, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL2, 2, 0x1db4640a, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL3, 2, 0x00008800, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_IF_REF, 2, 0x444C1380, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_IF_INT_CURRENT, 2,
 					   0x26001700, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_RF_CURRENT, 2, 0x00002660,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_VIDEO_AGC_CTRL, 2, 0x72500800,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_VID_AUD_OVERRIDE, 2, 0x27000100,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AV_SEP_CTRL, 2, 0x012c405d, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_COMP_FLT_CTRL, 2, 0x009f50c1, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SRC_PHASE_INC, 2, 0x1befbf06, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SRC_GAIN_CONTROL, 2, 0x000035e8,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SOFT_RST_CTRL_REVB, 2,
 					   0x00000000, 4);
 
@@ -1815,62 +1591,45 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 		   (V4L2_STD_SECAM_B | V4L2_STD_SECAM_D | V4L2_STD_SECAM_G |
 		    V4L2_STD_SECAM_K | V4L2_STD_SECAM_K1)) {
 
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL, 0, 31, 0x6503bc0c);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL1, 0, 31, 0xbd038c85);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL2, 0, 31, 0x1db4640a);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL3, 0, 31, 0x00008800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_REF, 0, 31, 0x888C0380);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_IF, 0, 31, 0xe0262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_INT, 0, 31, 0xc2171700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_RF, 0, 31, 0xc2262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_INT_CURRENT, 0, 31,
 					   0x26001700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_RF_CURRENT, 0, 31,
 					   0x00002660);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VID_AUD_OVERRIDE, 0, 31,
 					   0x27000100);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AV_SEP_CTRL, 0, 31, 0x3F3530ec);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_COMP_FLT_CTRL, 0, 31,
 					   0x00000000);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_PHASE_INC, 0, 31,
 					   0x1befbf06);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_GAIN_CONTROL, 0, 31,
 					   0x000035e8);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_RPT_VARIANCE, 0, 31, 0x00000000);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VIDEO_AGC_CTRL, 0, 31,
 					   0xf4000000);
 
@@ -1881,62 +1640,45 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 	} else if (standard & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC)) {
 
 		/* Is it SECAM_L1? */
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL, 0, 31, 0x6503bc0c);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL1, 0, 31, 0xbd038c85);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL2, 0, 31, 0x1db4640a);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_PLL_CTRL3, 0, 31, 0x00008800);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_REF, 0, 31, 0x888C0380);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_IF, 0, 31, 0xe0262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_INT, 0, 31, 0xc2171700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_CTRL_RF, 0, 31, 0xc2262600);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_IF_INT_CURRENT, 0, 31,
 					   0x26001700);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AGC_RF_CURRENT, 0, 31,
 					   0x00002660);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VID_AUD_OVERRIDE, 0, 31,
 					   0x27000100);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_AV_SEP_CTRL, 0, 31, 0x3F3530ec);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_COMP_FLT_CTRL, 0, 31,
 					   0x00000000);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_PHASE_INC, 0, 31,
 					   0x1befbf06);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_SRC_GAIN_CONTROL, 0, 31,
 					   0x000035e8);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_RPT_VARIANCE, 0, 31, 0x00000000);
-		status =
-		    cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
+		status = cx231xx_reg_mask_write(dev, HAMMERHEAD_I2C_ADDRESS, 32,
 					   DIF_VIDEO_AGC_CTRL, 0, 31,
 					   0xf2560000);
 
@@ -1944,67 +1686,54 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 		dif_misc_ctrl_value &= FLD_DIF_SPEC_INV;
 		dif_misc_ctrl_value |= 0x3a023F11;
 
-	} else {		/* V4L2_STD_NTSC_M (75 IRE Setup) Or  V4L2_STD_NTSC_M_JP (Japan,  0 IRE Setup) */
+	} else {
+		/* V4L2_STD_NTSC_M (75 IRE Setup) Or
+		   V4L2_STD_NTSC_M_JP (Japan,  0 IRE Setup) */
 
-		/* For NTSC the centre frequency of video coming out of sidewinder is
-		   around 7.1MHz or 3.6MHz depending on the spectral inversion.
-		   so for a non spectrally inverted channel the pll freq word is 0x03420c49
+		/* For NTSC the centre frequency of video coming out of
+		   sidewinder is around 7.1MHz or 3.6MHz depending on the
+		   spectral inversion. so for a non spectrally inverted channel
+		   the pll freq word is 0x03420c49
 		 */
 
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL, 2, 0x6503BC0C, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL1, 2, 0xBD038C85, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL2, 2, 0x1DB4640A, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_PLL_CTRL3, 2, 0x00008800, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_IF_REF, 2, 0x444C0380, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_IF_INT_CURRENT, 2,
 					   0x26001700, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_RF_CURRENT, 2, 0x00002660,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_VIDEO_AGC_CTRL, 2, 0x04000800,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_VID_AUD_OVERRIDE, 2, 0x27000100,
 					   4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AV_SEP_CTRL, 2, 0x01296e1f, 4);
 
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_COMP_FLT_CTRL, 2, 0x009f50c1, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SRC_PHASE_INC, 2, 0x1befbf06, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_SRC_GAIN_CONTROL, 2, 0x000035e8,
 					   4);
 
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_CTRL_IF, 2, 0xC2262600, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_CTRL_INT, 2, 0xC2262600, 4);
-		status =
-		    cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+		status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					   DIF_AGC_CTRL_RF, 2, 0xC2262600, 4);
 
 		/* Save the Spec Inversion value */
@@ -2017,7 +1746,8 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
 	   AUD_SRC_SEL[19] should always be disabled    */
 	dif_misc_ctrl_value &= ~FLD_DIF_AUD_SRC_SEL;
 
-	/* It is still possible to get Set Standard calls even when we are in FM mode
+	/* It is still possible to get Set Standard calls even when we
+	   are in FM mode.
 	   This is done to override the value for FM. */
 	if (dev->active_mode == V4L2_TUNER_RADIO)
 		dif_misc_ctrl_value = 0x7a080000;
@@ -2057,12 +1787,11 @@ int cx231xx_tuner_post_channel_change(struct cx231xx *dev)
 				       DIF_AGC_IF_REF, 2, &dwval, 4);
 	dwval &= ~(FLD_DIF_K_AGC_RF | FLD_DIF_K_AGC_IF);
 
-	if (dev->
-	    norm & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_B | V4L2_STD_SECAM_D)) {
+	if (dev->norm & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_B |
+			 V4L2_STD_SECAM_D))
 		dwval |= 0x88000000;
-	} else {
+	else
 		dwval |= 0x44000000;
-	}
 
 	status = cx231xx_write_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
 					DIF_AGC_IF_REF, 2, dwval, 4);
@@ -2070,17 +1799,16 @@ int cx231xx_tuner_post_channel_change(struct cx231xx *dev)
 	return status;
 }
 
-/*************************************************************************************
- *            F L A T I R O N - B L O C K    C O N T R O L   functions               *
- *************************************************************************************/
+/******************************************************************************
+ *        F L A T I R O N - B L O C K    C O N T R O L   functions            *
+ ******************************************************************************/
 int cx231xx_flatiron_initialize(struct cx231xx *dev)
 {
 	int status = 0;
 	u32 value;
 
-	status =
-	    cx231xx_read_i2c_data(dev, Flatrion_DEVICE_ADDRESS, CH_PWR_CTRL1, 1,
-				  &value, 1);
+	status = cx231xx_read_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
+				       CH_PWR_CTRL1, 1, &value, 1);
 	/* enables clock to delta-sigma and decimation filter */
 	value |= 0x80;
 	status = cx231xx_write_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
@@ -2098,8 +1826,7 @@ int cx231xx_flatiron_update_power_control(struct cx231xx *dev, AV_MODE avmode)
 	u32 value = 0;
 
 	if (avmode != POLARIS_AVMODE_ENXTERNAL_AV) {
-		status =
-		    cx231xx_read_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
+		status = cx231xx_read_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
 					  CH_PWR_CTRL2, 1, &value, 1);
 		value |= 0xfe;
 		status = cx231xx_write_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
@@ -2119,7 +1846,6 @@ int cx231xx_flatiron_set_audio_input(struct cx231xx *dev, u8 audio_input)
 
 	switch (audio_input) {
 	case CX231XX_AMUX_LINE_IN:
-
 		status = cx231xx_write_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
 						CH_PWR_CTRL2, 1, 0x00, 1);
 		status = cx231xx_write_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
@@ -2135,9 +1861,9 @@ int cx231xx_flatiron_set_audio_input(struct cx231xx *dev, u8 audio_input)
 	return status;
 }
 
-/*************************************************************************************
- *                      P O W E R      C O N T R O L   functions                     *
- *************************************************************************************/
+/******************************************************************************
+ *                  P O W E R      C O N T R O L   functions                  *
+ ******************************************************************************/
 int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 {
 	u8 value[4] = { 0, 0, 0, 0 };
@@ -2154,8 +1880,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 
 	cx231xx_info(" setPowerMode::mode = %d\n", mode);
 
-	status =
-	    cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, value, 4);
+	status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, value,
+				       4);
 	if (status < 0)
 		return status;
 
@@ -2171,9 +1897,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 		value[1] = (u8) (tmp >> 8);
 		value[2] = (u8) (tmp >> 16);
 		value[3] = (u8) (tmp >> 24);
-		status =
-		    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN,
-					   value, 4);
+		status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+						PWR_CTL_EN, value, 4);
 		msleep(PWR_SLEEP_INTERVAL);
 
 		tmp |= PWR_ISO_EN;
@@ -2191,9 +1916,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 		value[1] = (u8) (tmp >> 8);
 		value[2] = (u8) (tmp >> 16);
 		value[3] = (u8) (tmp >> 24);
-		status =
-		    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN,
-					   value, 4);
+		status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+						PWR_CTL_EN, value, 4);
 
 		dev->xc_fw_load_done = 0;	/* reset state of xceive tuner */
 		break;
@@ -2206,9 +1930,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 		value[1] = (u8) (tmp >> 8);
 		value[2] = (u8) (tmp >> 16);
 		value[3] = (u8) (tmp >> 24);
-		status =
-		    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN,
-					   value, 4);
+		status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+						PWR_CTL_EN, value, 4);
 		msleep(PWR_SLEEP_INTERVAL);
 
 		if (!(tmp & PWR_TUNER_EN)) {
@@ -2217,9 +1940,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 
@@ -2229,9 +1951,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 		if (!(tmp & PWR_ISO_EN)) {
@@ -2240,9 +1961,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 
@@ -2252,15 +1972,13 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 
 		if ((dev->model == CX231XX_BOARD_CNXT_RDE_250) ||
 		    (dev->model == CX231XX_BOARD_CNXT_RDU_250)) {
-
 			/* tuner path to channel 1 from port 3 */
 			cx231xx_enable_i2c_for_tuner(dev, I2C_3);
 
@@ -2270,16 +1988,14 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 		break;
 
 	case POLARIS_AVMODE_DIGITAL:
-
 		if (!(tmp & PWR_TUNER_EN)) {
 			tmp |= (PWR_TUNER_EN);
 			value[0] = (u8) tmp;
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 		if (!(tmp & PWR_AV_EN)) {
@@ -2288,9 +2004,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 		if (!(tmp & PWR_ISO_EN)) {
@@ -2299,9 +2014,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 
@@ -2310,9 +2024,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 		value[1] = (u8) (tmp >> 8);
 		value[2] = (u8) (tmp >> 16);
 		value[3] = (u8) (tmp >> 24);
-		status =
-		    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN,
-					   value, 4);
+		status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+						PWR_CTL_EN, value, 4);
 		msleep(PWR_SLEEP_INTERVAL);
 
 		if (!(tmp & PWR_DEMOD_EN)) {
@@ -2321,15 +2034,13 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 			value[1] = (u8) (tmp >> 8);
 			value[2] = (u8) (tmp >> 16);
 			value[3] = (u8) (tmp >> 24);
-			status =
-			    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-						   PWR_CTL_EN, value, 4);
+			status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+							PWR_CTL_EN, value, 4);
 			msleep(PWR_SLEEP_INTERVAL);
 		}
 
 		if ((dev->model == CX231XX_BOARD_CNXT_RDE_250) ||
 		    (dev->model == CX231XX_BOARD_CNXT_RDU_250)) {
-
 			/* tuner path to channel 1 from port 3 */
 			cx231xx_enable_i2c_for_tuner(dev, I2C_3);
 
@@ -2344,16 +2055,16 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 
 	msleep(PWR_SLEEP_INTERVAL);
 
-	/* For power saving, only enable Pwr_resetout_n when digital TV is selected. */
+	/* For power saving, only enable Pwr_resetout_n
+	   when digital TV is selected. */
 	if (mode == POLARIS_AVMODE_DIGITAL) {
 		tmp |= PWR_RESETOUT_EN;
 		value[0] = (u8) tmp;
 		value[1] = (u8) (tmp >> 8);
 		value[2] = (u8) (tmp >> 16);
 		value[3] = (u8) (tmp >> 24);
-		status =
-		    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN,
-					   value, 4);
+		status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
+						PWR_CTL_EN, value, 4);
 		msleep(PWR_SLEEP_INTERVAL);
 	}
 
@@ -2363,11 +2074,10 @@ int cx231xx_set_power_mode(struct cx231xx *dev, AV_MODE mode)
 	/* update power control for flatiron */
 	status = cx231xx_flatiron_update_power_control(dev, mode);
 
-	status =
-	    cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, value, 4);
-	cx231xx_info
-	    (" The data of PWR_CTL_EN register 0x74=0x%0x,0x%0x,0x%0x,0x%0x\n",
-	     value[0], value[1], value[2], value[3]);
+	status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, value,
+				       4);
+	cx231xx_info(" The data of PWR_CTL_EN register 0x74=0x%0x,0x%0x,0x%0x,0x%0x\n",
+		     value[0], value[1], value[2], value[3]);
 
 	return status;
 }
@@ -2378,8 +2088,8 @@ int cx231xx_power_suspend(struct cx231xx *dev)
 	u32 tmp = 0;
 	int status = 0;
 
-	status =
-	    cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, value, 4);
+	status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN,
+				       value, 4);
 	if (status > 0)
 		return status;
 
@@ -2390,15 +2100,15 @@ int cx231xx_power_suspend(struct cx231xx *dev)
 	value[1] = (u8) (tmp >> 8);
 	value[2] = (u8) (tmp >> 16);
 	value[3] = (u8) (tmp >> 24);
-	status =
-	    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN, value, 4);
+	status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, PWR_CTL_EN,
+					value, 4);
 
 	return status;
 }
 
-/*************************************************************************************
- *                      S T R E A M    C O N T R O L   functions                     *
- *************************************************************************************/
+/******************************************************************************
+ *                  S T R E A M    C O N T R O L   functions                  *
+ ******************************************************************************/
 int cx231xx_start_stream(struct cx231xx *dev, u32 ep_mask)
 {
 	u8 value[4] = { 0x0, 0x0, 0x0, 0x0 };
@@ -2406,8 +2116,8 @@ int cx231xx_start_stream(struct cx231xx *dev, u32 ep_mask)
 	int status = 0;
 
 	cx231xx_info("cx231xx_start_stream():: ep_mask = %x\n", ep_mask);
-	status =
-	    cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, EP_MODE_SET, value, 4);
+	status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, EP_MODE_SET,
+				       value, 4);
 	if (status < 0)
 		return status;
 
@@ -2418,9 +2128,8 @@ int cx231xx_start_stream(struct cx231xx *dev, u32 ep_mask)
 	value[2] = (u8) (tmp >> 16);
 	value[3] = (u8) (tmp >> 24);
 
-	status =
-	    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, EP_MODE_SET, value,
-				   4);
+	status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, EP_MODE_SET,
+					value, 4);
 
 	return status;
 }
@@ -2444,9 +2153,8 @@ int cx231xx_stop_stream(struct cx231xx *dev, u32 ep_mask)
 	value[2] = (u8) (tmp >> 16);
 	value[3] = (u8) (tmp >> 24);
 
-	status =
-	    cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, EP_MODE_SET, value,
-				   4);
+	status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, EP_MODE_SET,
+					value, 4);
 
 	return status;
 }
@@ -2558,9 +2266,8 @@ int cx231xx_capture_start(struct cx231xx *dev, int start, u8 media_type)
 	if (start) {
 		rc = cx231xx_initialize_stream_xfer(dev, media_type);
 
-		if (rc < 0) {
+		if (rc < 0)
 			return rc;
-		}
 
 		/* enable video capture */
 		if (ep_mask > 0)
@@ -2571,20 +2278,14 @@ int cx231xx_capture_start(struct cx231xx *dev, int start, u8 media_type)
 			rc = cx231xx_stop_stream(dev, ep_mask);
 	}
 
-	if (dev->mode == CX231XX_ANALOG_MODE) {
-		/* do any in Analog mode */
-	} else {
-		/* do any in digital mode */
-	}
 
 	return rc;
 }
-
 EXPORT_SYMBOL_GPL(cx231xx_capture_start);
 
-/************************************************************************************
-*                       G P I O   B I T control functions                           *
-*************************************************************************************/
+/*****************************************************************************
+*                   G P I O   B I T control functions                        *
+******************************************************************************/
 int cx231xx_set_gpio_bit(struct cx231xx *dev, u32 gpio_bit, u8 * gpio_val)
 {
 	int status = 0;
@@ -2621,17 +2322,16 @@ int cx231xx_set_gpio_direction(struct cx231xx *dev,
 	u32 value = 0;
 
 	/* Check for valid pin_number - if 32 , bail out */
-	if (pin_number >= 32) {
+	if (pin_number >= 32)
 		return -EINVAL;
-	}
 
-	if (pin_value == 0) {	/* input */
+	/* input */
+	if (pin_value == 0)
 		value = dev->gpio_dir & (~(1 << pin_number));	/* clear */
-	} else {
+	else
 		value = dev->gpio_dir | (1 << pin_number);
-	}
 
-	status = cx231xx_set_gpio_bit(dev, value, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, value, (u8 *) &dev->gpio_val);
 
 	/* cache the value for future */
 	dev->gpio_dir = value;
@@ -2664,31 +2364,28 @@ int cx231xx_set_gpio_value(struct cx231xx *dev, int pin_number, int pin_value)
 		/* It was in input mode */
 		value = dev->gpio_dir | (1 << pin_number);
 		dev->gpio_dir = value;
-		status =
-		    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-					 (u8 *) & dev->gpio_val);
+		status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+					      (u8 *) &dev->gpio_val);
 		value = 0;
 	}
 
-	if (pin_value == 0) {
+	if (pin_value == 0)
 		value = dev->gpio_val & (~(1 << pin_number));
-	} else {
+	else
 		value = dev->gpio_val | (1 << pin_number);
-	}
 
 	/* store the value */
 	dev->gpio_val = value;
 
 	/* toggle bit0 of GP_IO */
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	return status;
 }
 
-/************************************************************************************
-*                          G P I O I2C related functions                            *
-*************************************************************************************/
+/*****************************************************************************
+*                      G P I O I2C related functions                         *
+******************************************************************************/
 int cx231xx_gpio_i2c_start(struct cx231xx *dev)
 {
 	int status = 0;
@@ -2699,31 +2396,25 @@ int cx231xx_gpio_i2c_start(struct cx231xx *dev)
 	dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
 	dev->gpio_val |= 1 << dev->board.tuner_sda_gpio;
 
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
-	if (status < 0) {
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
+	if (status < 0)
 		return -EINVAL;
-	}
 
 	/* set SCL to output 1; set SDA to output 0 */
 	dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
 	dev->gpio_val &= ~(1 << dev->board.tuner_sda_gpio);
 
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
-	if (status < 0) {
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
+	if (status < 0)
 		return -EINVAL;
-	}
 
 	/* set SCL to output 0; set SDA to output 0      */
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
 	dev->gpio_val &= ~(1 << dev->board.tuner_sda_gpio);
 
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
-	if (status < 0) {
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
+	if (status < 0)
 		return -EINVAL;
-	}
 
 	return status;
 }
@@ -2739,21 +2430,17 @@ int cx231xx_gpio_i2c_end(struct cx231xx *dev)
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
 	dev->gpio_val &= ~(1 << dev->board.tuner_sda_gpio);
 
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
-	if (status < 0) {
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
+	if (status < 0)
 		return -EINVAL;
-	}
 
 	/* set SCL to output 1; set SDA to output 0      */
 	dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
 	dev->gpio_val &= ~(1 << dev->board.tuner_sda_gpio);
 
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
-	if (status < 0) {
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
+	if (status < 0)
 		return -EINVAL;
-	}
 
 	/* set SCL to input ,release SCL cable control
 	   set SDA to input ,release SDA cable control */
@@ -2761,10 +2448,10 @@ int cx231xx_gpio_i2c_end(struct cx231xx *dev)
 	dev->gpio_dir &= ~(1 << dev->board.tuner_sda_gpio);
 
 	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
-	if (status < 0) {
+	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
+	if (status < 0)
 		return -EINVAL;
-	}
+
 	return status;
 }
 
@@ -2782,40 +2469,34 @@ int cx231xx_gpio_i2c_write_byte(struct cx231xx *dev, u8 data)
 			/* set SCL to output 0; set SDA to output 0     */
 			dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
 			dev->gpio_val &= ~(1 << dev->board.tuner_sda_gpio);
-			status =
-			    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-						 (u8 *) & dev->gpio_val);
+			status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+						      (u8 *)&dev->gpio_val);
 
 			/* set SCL to output 1; set SDA to output 0     */
 			dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
-			status =
-			    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-						 (u8 *) & dev->gpio_val);
+			status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+						      (u8 *)&dev->gpio_val);
 
 			/* set SCL to output 0; set SDA to output 0     */
 			dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-			status =
-			    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-						 (u8 *) & dev->gpio_val);
+			status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+						      (u8 *)&dev->gpio_val);
 		} else {
 			/* set SCL to output 0; set SDA to output 1     */
 			dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
 			dev->gpio_val |= 1 << dev->board.tuner_sda_gpio;
-			status =
-			    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-						 (u8 *) & dev->gpio_val);
+			status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+						      (u8 *)&dev->gpio_val);
 
 			/* set SCL to output 1; set SDA to output 1     */
 			dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
-			status =
-			    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-						 (u8 *) & dev->gpio_val);
+			status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+						      (u8 *)&dev->gpio_val);
 
 			/* set SCL to output 0; set SDA to output 1     */
 			dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-			status =
-			    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-						 (u8 *) & dev->gpio_val);
+			status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+						      (u8 *)&dev->gpio_val);
 		}
 	}
 	return status;
@@ -2833,33 +2514,29 @@ int cx231xx_gpio_i2c_read_byte(struct cx231xx *dev, u8 * buf)
 
 		/* set SCL to output 0; set SDA to input */
 		dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-		status =
-		    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-					 (u8 *) & dev->gpio_val);
+		status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+					      (u8 *)&dev->gpio_val);
 
 		/* set SCL to output 1; set SDA to input */
 		dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
-		status =
-		    cx231xx_set_gpio_bit(dev, dev->gpio_dir,
-					 (u8 *) & dev->gpio_val);
+		status = cx231xx_set_gpio_bit(dev, dev->gpio_dir,
+					      (u8 *)&dev->gpio_val);
 
 		/* get SDA data bit */
 		gpio_logic_value = dev->gpio_val;
-		status =
-		    cx231xx_get_gpio_bit(dev, dev->gpio_dir,
-					 (u8 *) & dev->gpio_val);
-		if ((dev->gpio_val & (1 << dev->board.tuner_sda_gpio)) != 0) {
+		status = cx231xx_get_gpio_bit(dev, dev->gpio_dir,
+					      (u8 *)&dev->gpio_val);
+		if ((dev->gpio_val & (1 << dev->board.tuner_sda_gpio)) != 0)
 			value |= (1 << (8 - i - 1));
-		}
 
 		dev->gpio_val = gpio_logic_value;
 	}
 
 	/* set SCL to output 0,finish the read latest SCL signal.
-	   !!!set SDA to input,never to modify SDA direction at the same times */
+	   !!!set SDA to input, never to modify SDA direction at
+	   the same times */
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* store the value */
 	*buf = value & 0xff;
@@ -2874,33 +2551,29 @@ int cx231xx_gpio_i2c_read_ack(struct cx231xx *dev)
 	int nCnt = 10;
 	int nInit = nCnt;
 
-	/* clock stretch; set SCL to input; set SDA to input; get SCL value till SCL = 1 */
+	/* clock stretch; set SCL to input; set SDA to input;
+	   get SCL value till SCL = 1 */
 	dev->gpio_dir &= ~(1 << dev->board.tuner_sda_gpio);
 	dev->gpio_dir &= ~(1 << dev->board.tuner_scl_gpio);
 
 	gpio_logic_value = dev->gpio_val;
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	do {
 		msleep(2);
-		status =
-		    cx231xx_get_gpio_bit(dev, dev->gpio_dir,
-					 (u8 *) & dev->gpio_val);
+		status = cx231xx_get_gpio_bit(dev, dev->gpio_dir,
+					      (u8 *)&dev->gpio_val);
 		nCnt--;
-	} while (((dev->gpio_val & (1 << dev->board.tuner_scl_gpio)) == 0)
-		 && (nCnt > 0));
+	} while (((dev->gpio_val & (1 << dev->board.tuner_scl_gpio)) == 0) && (nCnt > 0));
 
-	if (nCnt == 0) {
-		cx231xx_info
-		    ("No ACK after %d msec for clock stretch. GPIO I2C operation failed!",
-		     nInit * 10);
-	}
+	if (nCnt == 0)
+		cx231xx_info("No ACK after %d msec for clock stretch. GPIO I2C operation failed!",
+			     nInit * 10);
 
 	/* readAck
-	   throuth clock stretch ,slave has given a SCL signal,so the SDA data can be directly read.  */
-	status =
-	    cx231xx_get_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	   throuth clock stretch ,slave has given a SCL signal,
+	   so the SDA data can be directly read.  */
+	status = cx231xx_get_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	if ((dev->gpio_val & 1 << dev->board.tuner_sda_gpio) == 0) {
 		dev->gpio_val = gpio_logic_value;
@@ -2911,12 +2584,12 @@ int cx231xx_gpio_i2c_read_ack(struct cx231xx *dev)
 		dev->gpio_val |= (1 << dev->board.tuner_sda_gpio);
 	}
 
-	/* read SDA end, set the SCL to output 0, after this operation, SDA direction can be changed. */
+	/* read SDA end, set the SCL to output 0, after this operation,
+	   SDA direction can be changed. */
 	dev->gpio_val = gpio_logic_value;
 	dev->gpio_dir |= (1 << dev->board.tuner_scl_gpio);
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	return status;
 }
@@ -2927,29 +2600,24 @@ int cx231xx_gpio_i2c_write_ack(struct cx231xx *dev)
 
 	/* set SDA to ouput */
 	dev->gpio_dir |= 1 << dev->board.tuner_sda_gpio;
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* set SCL = 0 (output); set SDA = 0 (output) */
 	dev->gpio_val &= ~(1 << dev->board.tuner_sda_gpio);
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* set SCL = 1 (output); set SDA = 0 (output) */
 	dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* set SCL = 0 (output); set SDA = 0 (output) */
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* set SDA to input,and then the slave will read data from SDA. */
 	dev->gpio_dir &= ~(1 << dev->board.tuner_sda_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	return status;
 }
@@ -2961,25 +2629,22 @@ int cx231xx_gpio_i2c_write_nak(struct cx231xx *dev)
 	/* set scl to output ; set sda to input */
 	dev->gpio_dir |= 1 << dev->board.tuner_scl_gpio;
 	dev->gpio_dir &= ~(1 << dev->board.tuner_sda_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* set scl to output 0; set sda to input */
 	dev->gpio_val &= ~(1 << dev->board.tuner_scl_gpio);
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	/* set scl to output 1; set sda to input */
 	dev->gpio_val |= 1 << dev->board.tuner_scl_gpio;
-	status =
-	    cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *) & dev->gpio_val);
+	status = cx231xx_set_gpio_bit(dev, dev->gpio_dir, (u8 *)&dev->gpio_val);
 
 	return status;
 }
 
-/************************************************************************************
-*                          G P I O I2C related functions                            *
-*************************************************************************************/
+/*****************************************************************************
+*                      G P I O I2C related functions                         *
+******************************************************************************/
 /* cx231xx_gpio_i2c_read
  * Function to read data from gpio based I2C interface
  */
diff --git a/drivers/media/video/cx231xx/cx231xx-vbi.c b/drivers/media/video/cx231xx/cx231xx-vbi.c
index 87a77d53faa6..03059043744c 100644
--- a/drivers/media/video/cx231xx/cx231xx-vbi.c
+++ b/drivers/media/video/cx231xx/cx231xx-vbi.c
@@ -109,27 +109,29 @@ static inline int cx231xx_isoc_vbi_copy(struct cx231xx *dev, struct urb *urb)
 	buffer_size = urb->actual_length;
 
 	if (buffer_size > 0) {
-
 		bytes_parsed = 0;
 
 		if (dma_q->is_partial_line) {
-			/* Handle the case where we were working on a partial line */
+			/* Handle the case where we were working on a partial
+			   line */
 			sav_eav = dma_q->last_sav;
 		} else {
-			/* Check for a SAV/EAV overlapping the buffer boundary */
-			sav_eav =
-			    cx231xx_find_boundary_SAV_EAV(p_buffer,
+			/* Check for a SAV/EAV overlapping the
+			   buffer boundary */
+
+			sav_eav = cx231xx_find_boundary_SAV_EAV(p_buffer,
 							  dma_q->partial_buf,
 							  &bytes_parsed);
 		}
 
 		sav_eav &= 0xF0;
-		/* Get the first line if we have some portion of an SAV/EAV from the last buffer
-		   or a partial line */
+		/* Get the first line if we have some portion of an SAV/EAV from
+		   the last buffer or a partial line */
 		if (sav_eav) {
-			bytes_parsed += cx231xx_get_vbi_line(dev, dma_q, sav_eav,	/* SAV/EAV */
-							     p_buffer + bytes_parsed,	/* p_buffer */
-							     buffer_size - bytes_parsed);	/* buffer size */
+			bytes_parsed += cx231xx_get_vbi_line(dev, dma_q,
+				sav_eav,		       /* SAV/EAV */
+				p_buffer + bytes_parsed,       /* p_buffer */
+				buffer_size - bytes_parsed);   /* buffer size */
 		}
 
 		/* Now parse data that is completely in this buffer */
@@ -139,16 +141,17 @@ static inline int cx231xx_isoc_vbi_copy(struct cx231xx *dev, struct urb *urb)
 			u32 bytes_used = 0;
 
 			sav_eav = cx231xx_find_next_SAV_EAV(p_buffer + bytes_parsed,	/* p_buffer */
-							    buffer_size - bytes_parsed,	/* buffer size */
-							    &bytes_used);	/* Receives bytes used to get SAV/EAV */
+				buffer_size - bytes_parsed,   /* buffer size */
+				&bytes_used);	/* Receives bytes used to get SAV/EAV */
 
 			bytes_parsed += bytes_used;
 
 			sav_eav &= 0xF0;
 			if (sav_eav && (bytes_parsed < buffer_size)) {
-				bytes_parsed += cx231xx_get_vbi_line(dev, dma_q, sav_eav,	/* SAV/EAV */
-								     p_buffer + bytes_parsed,	/* p_buffer */
-								     buffer_size - bytes_parsed);	/* buffer size */
+				bytes_parsed += cx231xx_get_vbi_line(dev,
+						dma_q, sav_eav,	/* SAV/EAV */
+						p_buffer + bytes_parsed,	/* p_buffer */
+						buffer_size - bytes_parsed);	/* buffer size */
 			}
 		}
 
@@ -261,7 +264,7 @@ vbi_buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 	buf->vb.state = VIDEOBUF_PREPARED;
 	return 0;
 
-      fail:
+fail:
 	free_buffer(vq, buf);
 	return rc;
 }
@@ -285,20 +288,15 @@ static void vbi_buffer_release(struct videobuf_queue *vq,
 {
 	struct cx231xx_buffer *buf =
 	    container_of(vb, struct cx231xx_buffer, vb);
-	/*
-	   struct cx231xx_fh       *fh   = vq->priv_data;
-	   struct cx231xx          *dev  = (struct cx231xx *)fh->dev;
 
-	   cx231xx_info(DRIVER_NAME "cx231xx: called vbi_buffer_release\n");
-	 */
 
 	free_buffer(vq, buf);
 }
 
 struct videobuf_queue_ops cx231xx_vbi_qops = {
-	.buf_setup = vbi_buffer_setup,
+	.buf_setup   = vbi_buffer_setup,
 	.buf_prepare = vbi_buffer_prepare,
-	.buf_queue = vbi_buffer_queue,
+	.buf_queue   = vbi_buffer_queue,
 	.buf_release = vbi_buffer_release,
 };
 
@@ -387,7 +385,6 @@ void cx231xx_uninit_vbi_isoc(struct cx231xx *dev)
 
 	cx231xx_capture_start(dev, 0, Vbi);
 }
-
 EXPORT_SYMBOL_GPL(cx231xx_uninit_vbi_isoc);
 
 /*
@@ -395,8 +392,8 @@ EXPORT_SYMBOL_GPL(cx231xx_uninit_vbi_isoc);
  */
 int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
 			  int num_bufs, int max_pkt_size,
-			  int (*isoc_copy) (struct cx231xx * dev,
-					    struct urb * urb))
+			  int (*isoc_copy) (struct cx231xx *dev,
+					    struct urb *urb))
 {
 	struct cx231xx_dmaqueue *dma_q = &dev->vbi_mode.vidq;
 	int i;
@@ -427,8 +424,8 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
 	for (i = 0; i < 8; i++)
 		dma_q->partial_buf[i] = 0;
 
-	dev->vbi_mode.isoc_ctl.urb =
-	    kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
+	dev->vbi_mode.isoc_ctl.urb = kzalloc(sizeof(void *) * num_bufs,
+					     GFP_KERNEL);
 	if (!dev->vbi_mode.isoc_ctl.urb) {
 		cx231xx_errdev("cannot alloc memory for usb buffers\n");
 		return -ENOMEM;
@@ -466,7 +463,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
 			cx231xx_err(DRIVER_NAME
 				    ": unable to allocate %i bytes for transfer"
 				    " buffer %i%s\n", sb_size, i,
-				    in_interrupt()? " while in int" : "");
+				    in_interrupt() ? " while in int" : "");
 			cx231xx_uninit_vbi_isoc(dev);
 			return -ENOMEM;
 		}
@@ -495,11 +492,10 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
 
 	return 0;
 }
-
 EXPORT_SYMBOL_GPL(cx231xx_init_vbi_isoc);
 
-u32 cx231xx_get_vbi_line(struct cx231xx * dev, struct cx231xx_dmaqueue * dma_q,
-			 u8 sav_eav, u8 * p_buffer, u32 buffer_size)
+u32 cx231xx_get_vbi_line(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
+			 u8 sav_eav, u8 *p_buffer, u32 buffer_size)
 {
 	u32 bytes_copied = 0;
 	int current_field = -1;
@@ -550,15 +546,14 @@ static inline void vbi_buffer_filled(struct cx231xx *dev,
 }
 
 u32 cx231xx_copy_vbi_line(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
-			  u8 * p_line, u32 length, int field_number)
+			  u8 *p_line, u32 length, int field_number)
 {
 	u32 bytes_to_copy;
 	struct cx231xx_buffer *buf;
 	u32 _line_size = dev->width * 2;
 
-	if (dma_q->current_field != field_number) {
+	if (dma_q->current_field != field_number)
 		cx231xx_reset_vbi_buffer(dev, dma_q);
-	}
 
 	/* get the buffer pointer */
 	buf = dev->vbi_mode.isoc_ctl.buf;
@@ -651,7 +646,6 @@ void cx231xx_reset_vbi_buffer(struct cx231xx *dev,
 	buf = dev->vbi_mode.isoc_ctl.buf;
 
 	if (buf == NULL) {
-
 		/* first try to get the buffer */
 		get_next_vbi_buf(dma_q, &buf);
 
@@ -664,7 +658,7 @@ void cx231xx_reset_vbi_buffer(struct cx231xx *dev,
 }
 
 int cx231xx_do_vbi_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
-			u8 * p_buffer, u32 bytes_to_copy)
+			u8 *p_buffer, u32 bytes_to_copy)
 {
 	u8 *p_out_buffer = NULL;
 	u32 current_line_bytes_copied = 0;
@@ -675,9 +669,8 @@ int cx231xx_do_vbi_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
 
 	buf = dev->vbi_mode.isoc_ctl.buf;
 
-	if (buf == NULL) {
-		return -1;
-	}
+	if (buf == NULL)
+		return -EINVAL;
 
 	p_out_buffer = videobuf_to_vmalloc(&buf->vb);
 
@@ -686,23 +679,22 @@ int cx231xx_do_vbi_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
 		    _line_size - dma_q->bytes_left_in_line;
 	}
 
-	offset =
-	    (dma_q->lines_completed * _line_size) + current_line_bytes_copied;
+	offset = (dma_q->lines_completed * _line_size) +
+		 current_line_bytes_copied;
 
 	/* prepare destination address */
 	startwrite = p_out_buffer + offset;
 
-	lencopy =
-	    dma_q->bytes_left_in_line >
-	    bytes_to_copy ? bytes_to_copy : dma_q->bytes_left_in_line;
+	lencopy = dma_q->bytes_left_in_line > bytes_to_copy ?
+		  bytes_to_copy : dma_q->bytes_left_in_line;
 
 	memcpy(startwrite, p_buffer, lencopy);
 
 	return 0;
 }
 
-u8 cx231xx_is_vbi_buffer_done(struct cx231xx * dev,
-			      struct cx231xx_dmaqueue * dma_q)
+u8 cx231xx_is_vbi_buffer_done(struct cx231xx *dev,
+			      struct cx231xx_dmaqueue *dma_q)
 {
 	u32 height = 0;
 
diff --git a/drivers/media/video/cx231xx/cx231xx-video.c b/drivers/media/video/cx231xx/cx231xx-video.c
index 18919e0f0194..89cf57c5056a 100644
--- a/drivers/media/video/cx231xx/cx231xx-video.c
+++ b/drivers/media/video/cx231xx/cx231xx-video.c
@@ -1,5 +1,6 @@
 /*
-   cx231xx-video.c - driver for Conexant Cx23100/101/102 USB video capture devices
+   cx231xx-video.c - driver for Conexant Cx23100/101/102
+		     USB video capture devices
 
    Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
 	Based on em28xx driver
@@ -109,91 +110,91 @@ static const struct v4l2_queryctrl no_ctl = {
 static struct cx231xx_ctrl cx231xx_ctls[] = {
 	/* --- video --- */
 	{
-	 .v = {
-	       .id = V4L2_CID_BRIGHTNESS,
-	       .name = "Brightness",
-	       .minimum = 0x00,
-	       .maximum = 0xff,
-	       .step = 1,
-	       .default_value = 0x7f,
-	       .type = V4L2_CTRL_TYPE_INTEGER,
-	       },
-	 .off = 128,
-	 .reg = LUMA_CTRL,
-	 .mask = 0x00ff,
-	 .shift = 0,
-	 }, {
-	     .v = {
-		   .id = V4L2_CID_CONTRAST,
-		   .name = "Contrast",
-		   .minimum = 0,
-		   .maximum = 0xff,
-		   .step = 1,
-		   .default_value = 0x3f,
-		   .type = V4L2_CTRL_TYPE_INTEGER,
-		   },
-	     .off = 0,
-	     .reg = LUMA_CTRL,
-	     .mask = 0xff00,
-	     .shift = 8,
-	     }, {
-		 .v = {
-		       .id = V4L2_CID_HUE,
-		       .name = "Hue",
-		       .minimum = 0,
-		       .maximum = 0xff,
-		       .step = 1,
-		       .default_value = 0x7f,
-		       .type = V4L2_CTRL_TYPE_INTEGER,
-		       },
-		 .off = 128,
-		 .reg = CHROMA_CTRL,
-		 .mask = 0xff0000,
-		 .shift = 16,
-		 }, {
-		     /* strictly, this only describes only U saturation.
-		      * V saturation is handled specially through code.
-		      */
-		     .v = {
-			   .id = V4L2_CID_SATURATION,
-			   .name = "Saturation",
-			   .minimum = 0,
-			   .maximum = 0xff,
-			   .step = 1,
-			   .default_value = 0x7f,
-			   .type = V4L2_CTRL_TYPE_INTEGER,
-			   },
-		     .off = 0,
-		     .reg = CHROMA_CTRL,
-		     .mask = 0x00ff,
-		     .shift = 0,
-		     }, {
-			 /* --- audio --- */
-			 .v = {
-			       .id = V4L2_CID_AUDIO_MUTE,
-			       .name = "Mute",
-			       .minimum = 0,
-			       .maximum = 1,
-			       .default_value = 1,
-			       .type = V4L2_CTRL_TYPE_BOOLEAN,
-			       },
-			 .reg = PATH1_CTL1,
-			 .mask = (0x1f << 24),
-			 .shift = 24,
-			 }, {
-			     .v = {
-				   .id = V4L2_CID_AUDIO_VOLUME,
-				   .name = "Volume",
-				   .minimum = 0,
-				   .maximum = 0x3f,
-				   .step = 1,
-				   .default_value = 0x3f,
-				   .type = V4L2_CTRL_TYPE_INTEGER,
-				   },
-			     .reg = PATH1_VOL_CTL,
-			     .mask = 0xff,
-			     .shift = 0,
-			     }
+		.v = {
+			.id = V4L2_CID_BRIGHTNESS,
+			.name = "Brightness",
+			.minimum = 0x00,
+			.maximum = 0xff,
+			.step = 1,
+			.default_value = 0x7f,
+			.type = V4L2_CTRL_TYPE_INTEGER,
+		},
+		.off = 128,
+		.reg = LUMA_CTRL,
+		.mask = 0x00ff,
+		.shift = 0,
+	}, {
+		.v = {
+			.id = V4L2_CID_CONTRAST,
+			.name = "Contrast",
+			.minimum = 0,
+			.maximum = 0xff,
+			.step = 1,
+			.default_value = 0x3f,
+			.type = V4L2_CTRL_TYPE_INTEGER,
+		},
+		.off = 0,
+		.reg = LUMA_CTRL,
+		.mask = 0xff00,
+		.shift = 8,
+	}, {
+		.v = {
+			.id = V4L2_CID_HUE,
+			.name = "Hue",
+			.minimum = 0,
+			.maximum = 0xff,
+			.step = 1,
+			.default_value = 0x7f,
+			.type = V4L2_CTRL_TYPE_INTEGER,
+		},
+		.off = 128,
+		.reg = CHROMA_CTRL,
+		.mask = 0xff0000,
+		.shift = 16,
+	}, {
+	/* strictly, this only describes only U saturation.
+	* V saturation is handled specially through code.
+	*/
+		.v = {
+			.id = V4L2_CID_SATURATION,
+			.name = "Saturation",
+			.minimum = 0,
+			.maximum = 0xff,
+			.step = 1,
+			.default_value = 0x7f,
+			.type = V4L2_CTRL_TYPE_INTEGER,
+		},
+		.off = 0,
+		.reg = CHROMA_CTRL,
+		.mask = 0x00ff,
+		.shift = 0,
+	}, {
+		/* --- audio --- */
+		.v = {
+			.id = V4L2_CID_AUDIO_MUTE,
+			.name = "Mute",
+			.minimum = 0,
+			.maximum = 1,
+			.default_value = 1,
+			.type = V4L2_CTRL_TYPE_BOOLEAN,
+		},
+		.reg = PATH1_CTL1,
+		.mask = (0x1f << 24),
+		.shift = 24,
+	}, {
+		.v = {
+			.id = V4L2_CID_AUDIO_VOLUME,
+			.name = "Volume",
+			.minimum = 0,
+			.maximum = 0x3f,
+			.step = 1,
+			.default_value = 0x3f,
+			.type = V4L2_CTRL_TYPE_INTEGER,
+		},
+		.reg = PATH1_VOL_CTL,
+		.mask = 0xff,
+		.shift = 0,
+	}
 };
 static const int CX231XX_CTLS = ARRAY_SIZE(cx231xx_ctls);
 
@@ -373,12 +374,13 @@ static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
 		}
 
 		sav_eav &= 0xF0;
-		/* Get the first line if we have some portion of an SAV/EAV from the last buffer
-		   or a partial line  */
+		/* Get the first line if we have some portion of an SAV/EAV from
+		   the last buffer or a partial line  */
 		if (sav_eav) {
-			bytes_parsed += cx231xx_get_video_line(dev, dma_q, sav_eav,	/* SAV/EAV */
-							       p_buffer + bytes_parsed,	/* p_buffer */
-							       buffer_size - bytes_parsed);	/* buffer size */
+			bytes_parsed += cx231xx_get_video_line(dev, dma_q,
+						sav_eav,	/* SAV/EAV */
+						p_buffer + bytes_parsed,	/* p_buffer */
+						buffer_size - bytes_parsed);	/* buffer size */
 		}
 
 		/* Now parse data that is completely in this buffer */
@@ -388,21 +390,22 @@ static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
 			u32 bytes_used = 0;
 
 			sav_eav = cx231xx_find_next_SAV_EAV(p_buffer + bytes_parsed,	/* p_buffer */
-							    buffer_size - bytes_parsed,	/* buffer size */
-							    &bytes_used);	/* Receives bytes used to get SAV/EAV */
+						buffer_size - bytes_parsed,	/* buffer size */
+						&bytes_used);	/* Receives bytes used to get SAV/EAV */
 
 			bytes_parsed += bytes_used;
 
 			sav_eav &= 0xF0;
 			if (sav_eav && (bytes_parsed < buffer_size)) {
-				bytes_parsed += cx231xx_get_video_line(dev, dma_q, sav_eav,	/* SAV/EAV */
-								       p_buffer + bytes_parsed,	/* p_buffer */
-								       buffer_size - bytes_parsed);	/* buffer size */
+				bytes_parsed += cx231xx_get_video_line(dev,
+						dma_q, sav_eav,	/* SAV/EAV */
+						p_buffer + bytes_parsed,	/* p_buffer */
+						buffer_size - bytes_parsed);	/* buffer size */
 			}
 		}
 
-		/* Save the last four bytes of the buffer so we can check the buffer boundary
-		   condition next time */
+		/* Save the last four bytes of the buffer so we can check the
+		   buffer boundary condition next time */
 		memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4);
 		bytes_parsed = 0;
 
@@ -410,8 +413,8 @@ static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
 	return rc;
 }
 
-u8 cx231xx_find_boundary_SAV_EAV(u8 * p_buffer, u8 * partial_buf,
-				 u32 * p_bytes_used)
+u8 cx231xx_find_boundary_SAV_EAV(u8 *p_buffer, u8 *partial_buf,
+				 u32 *p_bytes_used)
 {
 	u32 bytes_used;
 	u8 boundary_bytes[8];
@@ -426,8 +429,8 @@ u8 cx231xx_find_boundary_SAV_EAV(u8 * p_buffer, u8 * partial_buf,
 	memcpy(boundary_bytes + 4, p_buffer, 4);
 
 	/* Check for the SAV/EAV in the boundary buffer */
-	sav_eav =
-	    cx231xx_find_next_SAV_EAV((u8 *) & boundary_bytes, 8, &bytes_used);
+	sav_eav = cx231xx_find_next_SAV_EAV((u8 *)&boundary_bytes, 8,
+					    &bytes_used);
 
 	if (sav_eav) {
 		/* found a boundary SAV/EAV.  Updates the bytes used to reflect
@@ -438,13 +441,16 @@ u8 cx231xx_find_boundary_SAV_EAV(u8 * p_buffer, u8 * partial_buf,
 	return sav_eav;
 }
 
-u8 cx231xx_find_next_SAV_EAV(u8 * p_buffer, u32 buffer_size, u32 * p_bytes_used)
+u8 cx231xx_find_next_SAV_EAV(u8 *p_buffer, u32 buffer_size, u32 *p_bytes_used)
 {
 	u32 i;
 	u8 sav_eav = 0;
 
-	/* Don't search if the buffer size is less than 4.  It causes a page fault since
-	   buffer_size - 4 evaluates to a large number in that case. */
+	/*
+	 * Don't search if the buffer size is less than 4.  It causes a page
+	 * fault since buffer_size - 4 evaluates to a large number in that
+	 * case.
+	 */
 	if (buffer_size < 4) {
 		*p_bytes_used = buffer_size;
 		return 0;
@@ -465,69 +471,61 @@ u8 cx231xx_find_next_SAV_EAV(u8 * p_buffer, u32 buffer_size, u32 * p_bytes_used)
 	return 0;
 }
 
-u32 cx231xx_get_video_line(struct cx231xx * dev,
-			   struct cx231xx_dmaqueue * dma_q, u8 sav_eav,
-			   u8 * p_buffer, u32 buffer_size)
+u32 cx231xx_get_video_line(struct cx231xx *dev,
+			   struct cx231xx_dmaqueue *dma_q, u8 sav_eav,
+			   u8 *p_buffer, u32 buffer_size)
 {
 	u32 bytes_copied = 0;
 	int current_field = -1;
 
 	switch (sav_eav) {
 	case SAV_ACTIVE_VIDEO_FIELD1:
-		/* looking for skipped line which occurred in PAL 720x480 mode. In this case,
-		   there will be no active data contained between the SAV and EAV */
-		if ((buffer_size > 3) &&
-		    (p_buffer[0] == 0xFF) && (p_buffer[1] == 0x00)
-		    && (p_buffer[2] == 0x00)
-		    && ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1)
-			|| (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2)
-			|| (p_buffer[3] == EAV_VBLANK_FIELD1)
-			|| (p_buffer[3] == EAV_VBLANK_FIELD2)
-		    )
-		    ) {
+		/* looking for skipped line which occurred in PAL 720x480 mode.
+		   In this case, there will be no active data contained
+		   between the SAV and EAV */
+		if ((buffer_size > 3) && (p_buffer[0] == 0xFF) &&
+		    (p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) &&
+		    ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) ||
+		     (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) ||
+		     (p_buffer[3] == EAV_VBLANK_FIELD1) ||
+		     (p_buffer[3] == EAV_VBLANK_FIELD2)))
 			return bytes_copied;
-		}
 		current_field = 1;
 		break;
 
 	case SAV_ACTIVE_VIDEO_FIELD2:
-		/* looking for skipped line which occurred in PAL 720x480 mode. In this case,
-		   there will be no active data contained between the SAV and EAV */
-		if ((buffer_size > 3) &&
-		    (p_buffer[0] == 0xFF) && (p_buffer[1] == 0x00)
-		    && (p_buffer[2] == 0x00)
-		    && ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1)
-			|| (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2)
-			|| (p_buffer[3] == EAV_VBLANK_FIELD1)
-			|| (p_buffer[3] == EAV_VBLANK_FIELD2)
-		    )
-		    ) {
+		/* looking for skipped line which occurred in PAL 720x480 mode.
+		   In this case, there will be no active data contained between
+		   the SAV and EAV */
+		if ((buffer_size > 3) && (p_buffer[0] == 0xFF) &&
+		    (p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) &&
+		    ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) ||
+		     (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) ||
+		     (p_buffer[3] == EAV_VBLANK_FIELD1)       ||
+		     (p_buffer[3] == EAV_VBLANK_FIELD2)))
 			return bytes_copied;
-		}
 		current_field = 2;
 		break;
 	}
 
 	dma_q->last_sav = sav_eav;
 
-	bytes_copied =
-	    cx231xx_copy_video_line(dev, dma_q, p_buffer, buffer_size,
-				    current_field);
+	bytes_copied = cx231xx_copy_video_line(dev, dma_q, p_buffer,
+					       buffer_size, current_field);
 
 	return bytes_copied;
 }
 
-u32 cx231xx_copy_video_line(struct cx231xx * dev,
-			    struct cx231xx_dmaqueue * dma_q, u8 * p_line,
+u32 cx231xx_copy_video_line(struct cx231xx *dev,
+			    struct cx231xx_dmaqueue *dma_q, u8 *p_line,
 			    u32 length, int field_number)
 {
 	u32 bytes_to_copy;
 	struct cx231xx_buffer *buf;
 	u32 _line_size = dev->width * 2;
 
-	if (dma_q->current_field != field_number) {
+	if (dma_q->current_field != field_number)
 		cx231xx_reset_video_buffer(dev, dma_q);
-	}
 
 	/* get the buffer pointer */
 	buf = dev->video_mode.isoc_ctl.buf;
@@ -541,8 +539,8 @@ u32 cx231xx_copy_video_line(struct cx231xx * dev,
 
 	if (dma_q->lines_completed >= dma_q->lines_per_field) {
 		dma_q->bytes_left_in_line -= bytes_to_copy;
-		dma_q->is_partial_line =
-		    (dma_q->bytes_left_in_line == 0) ? 0 : 1;
+		dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0) ?
+					  0 : 1;
 		return 0;
 	}
 
@@ -552,8 +550,8 @@ u32 cx231xx_copy_video_line(struct cx231xx * dev,
 	   have copied if we had a buffer. */
 	if (!buf) {
 		dma_q->bytes_left_in_line -= bytes_to_copy;
-		dma_q->is_partial_line =
-		    (dma_q->bytes_left_in_line == 0) ? 0 : 1;
+		dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0)
+					 ? 0 : 1;
 		return bytes_to_copy;
 	}
 
@@ -564,13 +562,11 @@ u32 cx231xx_copy_video_line(struct cx231xx * dev,
 	dma_q->bytes_left_in_line -= bytes_to_copy;
 
 	if (dma_q->bytes_left_in_line == 0) {
-
 		dma_q->bytes_left_in_line = _line_size;
 		dma_q->lines_completed++;
 		dma_q->is_partial_line = 0;
 
 		if (cx231xx_is_buffer_done(dev, dma_q) && buf) {
-
 			buffer_filled(dev, dma_q, buf);
 
 			dma_q->pos = 0;
@@ -589,11 +585,10 @@ void cx231xx_reset_video_buffer(struct cx231xx *dev,
 
 	/* handle the switch from field 1 to field 2 */
 	if (dma_q->current_field == 1) {
-		if (dma_q->lines_completed >= dma_q->lines_per_field) {
+		if (dma_q->lines_completed >= dma_q->lines_per_field)
 			dma_q->field1_done = 1;
-		} else {
+		else
 			dma_q->field1_done = 0;
-		}
 	}
 
 	buf = dev->video_mode.isoc_ctl.buf;
@@ -617,7 +612,7 @@ void cx231xx_reset_video_buffer(struct cx231xx *dev,
 }
 
 int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
-		    u8 * p_buffer, u32 bytes_to_copy)
+		    u8 *p_buffer, u32 bytes_to_copy)
 {
 	u8 *p_out_buffer = NULL;
 	u32 current_line_bytes_copied = 0;
@@ -647,14 +642,11 @@ int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
 	/* bytes already completed in the current line */
 	startwrite += current_line_bytes_copied;
 
-	lencopy =
-	    dma_q->bytes_left_in_line >
-	    bytes_to_copy ? bytes_to_copy : dma_q->bytes_left_in_line;
+	lencopy = dma_q->bytes_left_in_line > bytes_to_copy ?
+		  bytes_to_copy : dma_q->bytes_left_in_line;
 
-	if ((u8 *) (startwrite + lencopy) >
-	    (u8 *) (p_out_buffer + buf->vb.size)) {
+	if ((u8 *)(startwrite + lencopy) > (u8 *)(p_out_buffer + buf->vb.size))
 		return 0;
-	}
 
 	/* The below copies the UYVY data straight into video buffer */
 	cx231xx_swab((u16 *) p_buffer, (u16 *) startwrite, (u16) lencopy);
@@ -662,16 +654,15 @@ int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
 	return 0;
 }
 
-void cx231xx_swab(u16 * from, u16 * to, u16 len)
+void cx231xx_swab(u16 *from, u16 *to, u16 len)
 {
 	u16 i;
 
 	if (len <= 0)
 		return;
 
-	for (i = 0; i < len / 2; i++) {
+	for (i = 0; i < len / 2; i++)
 		to[i] = (from[i] << 8) | (from[i] >> 8);
-	}
 }
 
 u8 cx231xx_is_buffer_done(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q)
@@ -679,10 +670,9 @@ u8 cx231xx_is_buffer_done(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q)
 	u8 buffer_complete = 0;
 
 	/* Dual field stream */
-	buffer_complete =
-	    ((dma_q->current_field == 2) &&
-	     (dma_q->lines_completed >= dma_q->lines_per_field) &&
-	     dma_q->field1_done);
+	buffer_complete = ((dma_q->current_field == 2) &&
+			   (dma_q->lines_completed >= dma_q->lines_per_field) &&
+			    dma_q->field1_done);
 
 	return buffer_complete;
 }
@@ -698,8 +688,7 @@ buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
 	struct cx231xx *dev = fh->dev;
 	struct v4l2_frequency f;
 
-	*size =
-	    (fh->dev->width * fh->dev->height * dev->format->depth + 7) >> 3;
+	*size = (fh->dev->width * fh->dev->height * dev->format->depth + 7)>>3;
 	if (0 == *count)
 		*count = CX231XX_DEF_BUF;
 
@@ -722,6 +711,7 @@ static void free_buffer(struct videobuf_queue *vq, struct cx231xx_buffer *buf)
 	struct cx231xx_fh *fh = vq->priv_data;
 	struct cx231xx *dev = fh->dev;
 	unsigned long flags = 0;
+
 	if (in_interrupt())
 		BUG();
 
@@ -754,9 +744,8 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 	int rc = 0, urb_init = 0;
 
 	/* The only currently supported format is 16 bits/pixel */
-	buf->vb.size =
-	    (fh->dev->width * fh->dev->height * dev->format->depth + 7) >> 3;
-
+	buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth
+			+ 7) >> 3;
 	if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
 		return -EINVAL;
 
@@ -785,7 +774,7 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 	buf->vb.state = VIDEOBUF_PREPARED;
 	return 0;
 
-      fail:
+fail:
 	free_buffer(vq, buf);
 	return rc;
 }
@@ -876,7 +865,7 @@ static int res_get(struct cx231xx_fh *fh)
 
 static int res_check(struct cx231xx_fh *fh)
 {
-	return (fh->stream_on);
+	return fh->stream_on;
 }
 
 static void res_free(struct cx231xx_fh *fh)
@@ -948,6 +937,7 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 	f->fmt.pix.field = V4L2_FIELD_INTERLACED;
 
 	mutex_unlock(&dev->lock);
+
 	return 0;
 }
 
@@ -1056,7 +1046,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 	/* Set the correct alternate setting for this resolution */
 	cx231xx_resolution_set(dev);
 
-      out:
+out:
 	mutex_unlock(&dev->lock);
 	return rc;
 }
@@ -1110,11 +1100,11 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id * norm)
 
 static const char *iname[] = {
 	[CX231XX_VMUX_COMPOSITE1] = "Composite1",
-	[CX231XX_VMUX_SVIDEO] = "S-Video",
+	[CX231XX_VMUX_SVIDEO]     = "S-Video",
 	[CX231XX_VMUX_TELEVISION] = "Television",
-	[CX231XX_VMUX_CABLE] = "Cable TV",
-	[CX231XX_VMUX_DVB] = "DVB",
-	[CX231XX_VMUX_DEBUG] = "for debug only",
+	[CX231XX_VMUX_CABLE]      = "Cable TV",
+	[CX231XX_VMUX_DVB]        = "DVB",
+	[CX231XX_VMUX_DEBUG]      = "for debug only",
 };
 
 static int vidioc_enum_input(struct file *file, void *priv,
@@ -1386,12 +1376,11 @@ static int vidioc_s_frequency(struct file *file, void *priv,
 	dev->ctl_freq = f->frequency;
 
 	if (dev->tuner_type == TUNER_XC5000) {
-		if (dev->cx231xx_set_analog_freq != NULL) {
+		if (dev->cx231xx_set_analog_freq != NULL)
 			dev->cx231xx_set_analog_freq(dev, f->frequency);
-		}
 	} else {
-		cx231xx_i2c_call_clients(&dev->i2c_bus[1], VIDIOC_S_FREQUENCY,
-					 f);
+		cx231xx_i2c_call_clients(&dev->i2c_bus[1],
+					 VIDIOC_S_FREQUENCY, f);
 	}
 
 	mutex_unlock(&dev->lock);
@@ -1430,47 +1419,42 @@ static int vidioc_g_register(struct file *file, void *priv,
 	case V4L2_CHIP_MATCH_HOST:
 		switch (reg->match.addr) {
 		case 0:	/* Cx231xx - internal registers */
-			ret =
-			    cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER,
-						  (u16) reg->reg, value, 4);
-			reg->val =
-			    value[0] | value[1] << 8 | value[2] << 16 | value[3]
-			    << 24;
+			ret = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER,
+						  (u16)reg->reg, value, 4);
+			reg->val = value[0] | value[1] << 8 |
+				   value[2] << 16 | value[3] << 24;
 			break;
 		case 1:	/* Colibri - read byte */
-			ret =
-			    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						  (u16) reg->reg, 2, &data, 1);
+			ret = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+						  (u16)reg->reg, 2, &data, 1);
 			reg->val = le32_to_cpu(data & 0xff);
 			break;
 		case 14:	/* Colibri - read dword */
-			ret =
-			    cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
-						  (u16) reg->reg, 2, &data, 4);
+			ret = cx231xx_read_i2c_data(dev, Colibri_DEVICE_ADDRESS,
+						  (u16)reg->reg, 2, &data, 4);
 			reg->val = le32_to_cpu(data);
 			break;
 		case 2:	/* Hammerhead - read byte */
-			ret =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  (u16) reg->reg, 2, &data, 1);
+			ret = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						  (u16)reg->reg, 2, &data, 1);
 			reg->val = le32_to_cpu(data & 0xff);
 			break;
 		case 24:	/* Hammerhead - read dword */
-			ret =
-			    cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
-						  (u16) reg->reg, 2, &data, 4);
+			ret = cx231xx_read_i2c_data(dev, HAMMERHEAD_I2C_ADDRESS,
+						  (u16)reg->reg, 2, &data, 4);
 			reg->val = le32_to_cpu(data);
 			break;
 		case 3:	/* flatiron - read byte */
-			ret =
-			    cx231xx_read_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
-						  (u16) reg->reg, 1, &data, 1);
+			ret = cx231xx_read_i2c_data(dev,
+						    Flatrion_DEVICE_ADDRESS,
+						    (u16)reg->reg, 1,
+						    &data, 1);
 			reg->val = le32_to_cpu(data & 0xff);
 			break;
 		case 34:	/* flatiron - read dword */
 			ret =
 			    cx231xx_read_i2c_data(dev, Flatrion_DEVICE_ADDRESS,
-						  (u16) reg->reg, 1, &data, 4);
+						  (u16)reg->reg, 1, &data, 4);
 			reg->val = le32_to_cpu(data);
 			break;
 		}
@@ -1489,9 +1473,7 @@ static int vidioc_g_register(struct file *file, void *priv,
 	}
 
 	mutex_lock(&dev->lock);
-
 	cx231xx_i2c_call_clients(&dev->i2c_bus[0], VIDIOC_DBG_G_REGISTER, reg);
-
 	mutex_unlock(&dev->lock);
 
 	return ret;
@@ -1520,53 +1502,50 @@ static int vidioc_s_register(struct file *file, void *priv,
 				data[1] = (u8) (value >> 8);
 				data[2] = (u8) (value >> 16);
 				data[3] = (u8) (value >> 24);
-				ret =
-				    cx231xx_write_ctrl_reg(dev,
+				ret = cx231xx_write_ctrl_reg(dev,
 							   VRT_SET_REGISTER,
-							   (u16) reg->reg, data,
+							   (u16)reg->reg, data,
 							   4);
 				break;
 			case 1:	/* Colibri - read byte */
-				ret =
-				    cx231xx_write_i2c_data(dev,
-							   Colibri_DEVICE_ADDRESS,
-							   (u16) reg->reg, 2,
-							   value, 1);
+				ret = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							(u16)reg->reg, 2,
+							value, 1);
 				break;
 			case 14:	/* Colibri - read dword */
-				ret =
-				    cx231xx_write_i2c_data(dev,
-							   Colibri_DEVICE_ADDRESS,
-							   (u16) reg->reg, 2,
-							   value, 4);
+				ret = cx231xx_write_i2c_data(dev,
+							Colibri_DEVICE_ADDRESS,
+							(u16)reg->reg, 2,
+							value, 4);
 				break;
 			case 2:	/* Hammerhead - read byte */
 				ret =
 				    cx231xx_write_i2c_data(dev,
-							   HAMMERHEAD_I2C_ADDRESS,
-							   (u16) reg->reg, 2,
-							   value, 1);
+							HAMMERHEAD_I2C_ADDRESS,
+							(u16)reg->reg, 2,
+							value, 1);
 				break;
 			case 24:	/* Hammerhead - read dword */
 				ret =
 				    cx231xx_write_i2c_data(dev,
-							   HAMMERHEAD_I2C_ADDRESS,
-							   (u16) reg->reg, 2,
-							   value, 4);
+							HAMMERHEAD_I2C_ADDRESS,
+							(u16)reg->reg, 2,
+							value, 4);
 				break;
 			case 3:	/* flatiron - read byte */
 				ret =
 				    cx231xx_write_i2c_data(dev,
-							   Flatrion_DEVICE_ADDRESS,
-							   (u16) reg->reg, 1,
-							   value, 1);
+							Flatrion_DEVICE_ADDRESS,
+							(u16)reg->reg, 1,
+							value, 1);
 				break;
 			case 34:	/* flatiron - read dword */
 				ret =
 				    cx231xx_write_i2c_data(dev,
-							   Flatrion_DEVICE_ADDRESS,
-							   (u16) reg->reg, 1,
-							   value, 4);
+							Flatrion_DEVICE_ADDRESS,
+							(u16)reg->reg, 1,
+							value, 4);
 				break;
 			}
 		}
@@ -1805,7 +1784,7 @@ static int vidioc_reqbufs(struct file *file, void *priv,
 	if (rc < 0)
 		return rc;
 
-	return (videobuf_reqbufs(&fh->vb_vidq, rb));
+	return videobuf_reqbufs(&fh->vb_vidq, rb);
 }
 
 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *b)
@@ -1818,7 +1797,7 @@ static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *b)
 	if (rc < 0)
 		return rc;
 
-	return (videobuf_querybuf(&fh->vb_vidq, b));
+	return videobuf_querybuf(&fh->vb_vidq, b);
 }
 
 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
@@ -1831,7 +1810,7 @@ static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 	if (rc < 0)
 		return rc;
 
-	return (videobuf_qbuf(&fh->vb_vidq, b));
+	return videobuf_qbuf(&fh->vb_vidq, b);
 }
 
 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
@@ -1844,7 +1823,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 	if (rc < 0)
 		return rc;
 
-	return (videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK));
+	return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
 }
 
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
@@ -2030,17 +2009,19 @@ static int cx231xx_v4l2_open(struct file *filp)
 
 	dev->users++;
 
-	if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-		videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_video_qops, NULL, &dev->video_mode.slock, fh->type, V4L2_FIELD_INTERLACED,	/* V4L2_FIELD_SEQ_TB, */
+	if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+		videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_video_qops,
+					    NULL, &dev->video_mode.slock,
+					    fh->type, V4L2_FIELD_INTERLACED,
 					    sizeof(struct cx231xx_buffer), fh);
-	}
-
 	if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
-
-		/* Set the required alternate setting  VBI interface works in Bulk mode only */
+		/* Set the required alternate setting  VBI interface works in
+		   Bulk mode only */
 		cx231xx_set_alt_setting(dev, INDEX_VANC, 0);
 
-		videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_vbi_qops, NULL, &dev->vbi_mode.slock, fh->type, V4L2_FIELD_SEQ_TB,	/* V4L2_FIELD_INTERLACED,  */
+		videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_vbi_qops,
+					    NULL, &dev->vbi_mode.slock,
+					    fh->type, V4L2_FIELD_SEQ_TB,
 					    sizeof(struct cx231xx_buffer), fh);
 	}
 
@@ -2120,11 +2101,10 @@ static int cx231xx_v4l2_close(struct file *filp)
 		cx231xx_uninit_vbi_isoc(dev);
 
 		/* set alternate 0 */
-		if (!dev->vbi_or_sliced_cc_mode) {
+		if (!dev->vbi_or_sliced_cc_mode)
 			cx231xx_set_alt_setting(dev, INDEX_VANC, 0);
-		} else {
+		else
 			cx231xx_set_alt_setting(dev, INDEX_HANC, 0);
-		}
 
 		kfree(fh);
 		dev->users--;
@@ -2169,8 +2149,8 @@ static int cx231xx_v4l2_close(struct file *filp)
  * will allocate buffers when called for the first time
  */
 static ssize_t
-cx231xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
-		  loff_t * pos)
+cx231xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
+		  loff_t *pos)
 {
 	struct cx231xx_fh *fh = filp->private_data;
 	struct cx231xx *dev = fh->dev;
@@ -2254,98 +2234,98 @@ static int cx231xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
 }
 
 static const struct v4l2_file_operations cx231xx_v4l_fops = {
-	.owner = THIS_MODULE,
-	.open = cx231xx_v4l2_open,
+	.owner   = THIS_MODULE,
+	.open    = cx231xx_v4l2_open,
 	.release = cx231xx_v4l2_close,
-	.read = cx231xx_v4l2_read,
-	.poll = cx231xx_v4l2_poll,
-	.mmap = cx231xx_v4l2_mmap,
-	.ioctl = video_ioctl2,
+	.read    = cx231xx_v4l2_read,
+	.poll    = cx231xx_v4l2_poll,
+	.mmap    = cx231xx_v4l2_mmap,
+	.ioctl   = video_ioctl2,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
-	.vidioc_querycap = vidioc_querycap,
-	.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
-	.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
-	.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
-	.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
-	.vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
-	.vidioc_try_fmt_vbi_cap = vidioc_try_fmt_vbi_cap,
-	.vidioc_s_fmt_vbi_cap = vidioc_try_fmt_vbi_cap,
-	.vidioc_g_audio = vidioc_g_audio,
-	.vidioc_s_audio = vidioc_s_audio,
-	.vidioc_cropcap = vidioc_cropcap,
-	.vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
+	.vidioc_querycap               = vidioc_querycap,
+	.vidioc_enum_fmt_vid_cap       = vidioc_enum_fmt_vid_cap,
+	.vidioc_g_fmt_vid_cap          = vidioc_g_fmt_vid_cap,
+	.vidioc_try_fmt_vid_cap        = vidioc_try_fmt_vid_cap,
+	.vidioc_s_fmt_vid_cap          = vidioc_s_fmt_vid_cap,
+	.vidioc_g_fmt_vbi_cap          = vidioc_g_fmt_vbi_cap,
+	.vidioc_try_fmt_vbi_cap        = vidioc_try_fmt_vbi_cap,
+	.vidioc_s_fmt_vbi_cap          = vidioc_try_fmt_vbi_cap,
+	.vidioc_g_audio                =  vidioc_g_audio,
+	.vidioc_s_audio                = vidioc_s_audio,
+	.vidioc_cropcap                = vidioc_cropcap,
+	.vidioc_g_fmt_sliced_vbi_cap   = vidioc_g_fmt_sliced_vbi_cap,
 	.vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
-	.vidioc_reqbufs = vidioc_reqbufs,
-	.vidioc_querybuf = vidioc_querybuf,
-	.vidioc_qbuf = vidioc_qbuf,
-	.vidioc_dqbuf = vidioc_dqbuf,
-	.vidioc_s_std = vidioc_s_std,
-	.vidioc_g_std = vidioc_g_std,
-	.vidioc_enum_input = vidioc_enum_input,
-	.vidioc_g_input = vidioc_g_input,
-	.vidioc_s_input = vidioc_s_input,
-	.vidioc_queryctrl = vidioc_queryctrl,
-	.vidioc_g_ctrl = vidioc_g_ctrl,
-	.vidioc_s_ctrl = vidioc_s_ctrl,
-	.vidioc_streamon = vidioc_streamon,
-	.vidioc_streamoff = vidioc_streamoff,
-	.vidioc_g_tuner = vidioc_g_tuner,
-	.vidioc_s_tuner = vidioc_s_tuner,
-	.vidioc_g_frequency = vidioc_g_frequency,
-	.vidioc_s_frequency = vidioc_s_frequency,
+	.vidioc_reqbufs                = vidioc_reqbufs,
+	.vidioc_querybuf               = vidioc_querybuf,
+	.vidioc_qbuf                   = vidioc_qbuf,
+	.vidioc_dqbuf                  = vidioc_dqbuf,
+	.vidioc_s_std                  = vidioc_s_std,
+	.vidioc_g_std                  = vidioc_g_std,
+	.vidioc_enum_input             = vidioc_enum_input,
+	.vidioc_g_input                = vidioc_g_input,
+	.vidioc_s_input                = vidioc_s_input,
+	.vidioc_queryctrl              = vidioc_queryctrl,
+	.vidioc_g_ctrl                 = vidioc_g_ctrl,
+	.vidioc_s_ctrl                 = vidioc_s_ctrl,
+	.vidioc_streamon               = vidioc_streamon,
+	.vidioc_streamoff              = vidioc_streamoff,
+	.vidioc_g_tuner                = vidioc_g_tuner,
+	.vidioc_s_tuner                = vidioc_s_tuner,
+	.vidioc_g_frequency            = vidioc_g_frequency,
+	.vidioc_s_frequency            = vidioc_s_frequency,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-	.vidioc_g_register = vidioc_g_register,
-	.vidioc_s_register = vidioc_s_register,
+	.vidioc_g_register             = vidioc_g_register,
+	.vidioc_s_register             = vidioc_s_register,
 #endif
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
-	.vidiocgmbuf = vidiocgmbuf,
+	.vidiocgmbuf                   = vidiocgmbuf,
 #endif
 };
 
 static struct video_device cx231xx_vbi_template;
 
 static const struct video_device cx231xx_video_template = {
-	.fops = &cx231xx_v4l_fops,
-	.release = video_device_release,
-	.ioctl_ops = &video_ioctl_ops,
-	.minor = -1,
-	.tvnorms = V4L2_STD_ALL,
+	.fops         = &cx231xx_v4l_fops,
+	.release      = video_device_release,
+	.ioctl_ops    = &video_ioctl_ops,
+	.minor        = -1,
+	.tvnorms      = V4L2_STD_ALL,
 	.current_norm = V4L2_STD_PAL,
 };
 
 static const struct v4l2_file_operations radio_fops = {
-	.owner = THIS_MODULE,
-	.open = cx231xx_v4l2_open,
+	.owner   = THIS_MODULE,
+	.open   = cx231xx_v4l2_open,
 	.release = cx231xx_v4l2_close,
-	.ioctl = video_ioctl2,
+	.ioctl   = video_ioctl2,
 };
 
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
-	.vidioc_querycap = radio_querycap,
-	.vidioc_g_tuner = radio_g_tuner,
-	.vidioc_enum_input = radio_enum_input,
-	.vidioc_g_audio = radio_g_audio,
-	.vidioc_s_tuner = radio_s_tuner,
-	.vidioc_s_audio = radio_s_audio,
-	.vidioc_s_input = radio_s_input,
-	.vidioc_queryctrl = radio_queryctrl,
-	.vidioc_g_ctrl = vidioc_g_ctrl,
-	.vidioc_s_ctrl = vidioc_s_ctrl,
+	.vidioc_querycap    = radio_querycap,
+	.vidioc_g_tuner     = radio_g_tuner,
+	.vidioc_enum_input  = radio_enum_input,
+	.vidioc_g_audio     = radio_g_audio,
+	.vidioc_s_tuner     = radio_s_tuner,
+	.vidioc_s_audio     = radio_s_audio,
+	.vidioc_s_input     = radio_s_input,
+	.vidioc_queryctrl   = radio_queryctrl,
+	.vidioc_g_ctrl      = vidioc_g_ctrl,
+	.vidioc_s_ctrl      = vidioc_s_ctrl,
 	.vidioc_g_frequency = vidioc_g_frequency,
 	.vidioc_s_frequency = vidioc_s_frequency,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-	.vidioc_g_register = vidioc_g_register,
-	.vidioc_s_register = vidioc_s_register,
+	.vidioc_g_register  = vidioc_g_register,
+	.vidioc_s_register  = vidioc_s_register,
 #endif
 };
 
 static struct video_device cx231xx_radio_template = {
-	.name = "cx231xx-radio",
-	.fops = &radio_fops,
+	.name      = "cx231xx-radio",
+	.fops      = &radio_fops,
 	.ioctl_ops = &radio_ioctl_ops,
-	.minor = -1,
+	.minor     = -1,
 };
 
 /******************************** usb interface ******************************/
@@ -2358,6 +2338,7 @@ static struct video_device *cx231xx_vdev_init(struct cx231xx *dev, const struct
 	vfd = video_device_alloc();
 	if (NULL == vfd)
 		return NULL;
+
 	*vfd = *template;
 	vfd->minor = -1;
 	vfd->parent = &dev->udev->dev;
@@ -2439,8 +2420,8 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
 		     dev->name, dev->vbi_dev->num);
 
 	if (cx231xx_boards[dev->model].radio.type == CX231XX_RADIO) {
-		dev->radio_dev =
-		    cx231xx_vdev_init(dev, &cx231xx_radio_template, "radio");
+		dev->radio_dev = cx231xx_vdev_init(dev, &cx231xx_radio_template,
+						   "radio");
 		if (!dev->radio_dev) {
 			cx231xx_errdev("cannot allocate video_device.\n");
 			return -ENODEV;
diff --git a/drivers/media/video/cx231xx/cx231xx.h b/drivers/media/video/cx231xx/cx231xx.h
index 1f6c5be65a55..d98b36d772bd 100644
--- a/drivers/media/video/cx231xx/cx231xx.h
+++ b/drivers/media/video/cx231xx/cx231xx.h
@@ -140,8 +140,7 @@ struct cx231xx_usb_isoc_ctl {
 	int nfields;
 
 	/* isoc urb callback */
-	int (*isoc_copy) (struct cx231xx * dev, struct urb * urb);
-
+	int (*isoc_copy) (struct cx231xx *dev, struct urb *urb);
 };
 
 struct cx231xx_fmt {
@@ -497,20 +496,19 @@ struct cx231xx {
 	char urb_buf[URB_MAX_CTRL_SIZE];	/* urb control msg buffer */
 
 	/* helper funcs that call usb_control_msg */
-	int (*cx231xx_read_ctrl_reg) (struct cx231xx * dev, u8 req, u16 reg,
+	int (*cx231xx_read_ctrl_reg) (struct cx231xx *dev, u8 req, u16 reg,
 				      char *buf, int len);
-	int (*cx231xx_write_ctrl_reg) (struct cx231xx * dev, u8 req, u16 reg,
+	int (*cx231xx_write_ctrl_reg) (struct cx231xx *dev, u8 req, u16 reg,
 				       char *buf, int len);
-	int (*cx231xx_send_usb_command) (struct cx231xx_i2c * i2c_bus,
-					 struct cx231xx_i2c_xfer_data *
-					 req_data);
-	int (*cx231xx_gpio_i2c_read) (struct cx231xx * dev, u8 dev_addr,
-				      u8 * buf, u8 len);
-	int (*cx231xx_gpio_i2c_write) (struct cx231xx * dev, u8 dev_addr,
-				       u8 * buf, u8 len);
+	int (*cx231xx_send_usb_command) (struct cx231xx_i2c *i2c_bus,
+					 struct cx231xx_i2c_xfer_data *req_data);
+	int (*cx231xx_gpio_i2c_read) (struct cx231xx *dev, u8 dev_addr,
+				      u8 *buf, u8 len);
+	int (*cx231xx_gpio_i2c_write) (struct cx231xx *dev, u8 dev_addr,
+				       u8 *buf, u8 len);
 
-	int (*cx231xx_set_analog_freq) (struct cx231xx * dev, u32 freq);
-	int (*cx231xx_reset_analog_tuner) (struct cx231xx * dev);
+	int (*cx231xx_set_analog_freq) (struct cx231xx *dev, u32 freq);
+	int (*cx231xx_reset_analog_tuner) (struct cx231xx *dev);
 
 	enum cx231xx_mode mode;
 
@@ -562,7 +560,7 @@ int cx231xx_i2c_unregister(struct cx231xx_i2c *bus);
 
 /* Internal block control functions */
 int cx231xx_read_i2c_data(struct cx231xx *dev, u8 dev_addr,
-			  u16 saddr, u8 saddr_len, u32 * data, u8 data_len);
+			  u16 saddr, u8 saddr_len, u32 *data, u8 data_len);
 int cx231xx_write_i2c_data(struct cx231xx *dev, u8 dev_addr,
 			   u16 saddr, u8 saddr_len, u32 data, u8 data_len);
 int cx231xx_reg_mask_write(struct cx231xx *dev, u8 dev_addr, u8 size,
@@ -594,20 +592,20 @@ int cx231xx_tuner_pre_channel_change(struct cx231xx *dev);
 int cx231xx_tuner_post_channel_change(struct cx231xx *dev);
 
 /* video parser functions */
-u8 cx231xx_find_next_SAV_EAV(u8 * p_buffer, u32 buffer_size,
-			     u32 * p_bytes_used);
-u8 cx231xx_find_boundary_SAV_EAV(u8 * p_buffer, u8 * partial_buf,
-				 u32 * p_bytes_used);
+u8 cx231xx_find_next_SAV_EAV(u8 *p_buffer, u32 buffer_size,
+			     u32 *p_bytes_used);
+u8 cx231xx_find_boundary_SAV_EAV(u8 *p_buffer, u8 *partial_buf,
+				 u32 *p_bytes_used);
 int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
-		    u8 * p_buffer, u32 bytes_to_copy);
+		    u8 *p_buffer, u32 bytes_to_copy);
 void cx231xx_reset_video_buffer(struct cx231xx *dev,
 				struct cx231xx_dmaqueue *dma_q);
 u8 cx231xx_is_buffer_done(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q);
 u32 cx231xx_copy_video_line(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
-			    u8 * p_line, u32 length, int field_number);
+			    u8 *p_line, u32 length, int field_number);
 u32 cx231xx_get_video_line(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
-			   u8 sav_eav, u8 * p_buffer, u32 buffer_size);
-void cx231xx_swab(u16 * from, u16 * to, u16 len);
+			   u8 sav_eav, u8 *p_buffer, u32 buffer_size);
+void cx231xx_swab(u16 *from, u16 *to, u16 len);
 
 /* Provided by cx231xx-core.c */
 
@@ -624,15 +622,15 @@ int cx231xx_write_ctrl_reg(struct cx231xx *dev, u8 req, u16 reg,
 			   char *buf, int len);
 int cx231xx_mode_register(struct cx231xx *dev, u16 address, u32 mode);
 
-int cx231xx_send_vendor_cmd(struct cx231xx *dev, VENDOR_REQUEST_IN * ven_req);
+int cx231xx_send_vendor_cmd(struct cx231xx *dev, VENDOR_REQUEST_IN *ven_req);
 int cx231xx_send_usb_command(struct cx231xx_i2c *i2c_bus,
 			     struct cx231xx_i2c_xfer_data *req_data);
 
 /* Gpio related functions */
-int cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 * gpio_val,
+int cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val,
 			  u8 len, u8 request, u8 direction);
-int cx231xx_set_gpio_bit(struct cx231xx *dev, u32 gpio_bit, u8 * gpio_val);
-int cx231xx_get_gpio_bit(struct cx231xx *dev, u32 gpio_bit, u8 * gpio_val);
+int cx231xx_set_gpio_bit(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val);
+int cx231xx_get_gpio_bit(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val);
 int cx231xx_set_gpio_value(struct cx231xx *dev, int pin_number, int pin_value);
 int cx231xx_set_gpio_direction(struct cx231xx *dev, int pin_number,
 			       int pin_value);
@@ -640,13 +638,13 @@ int cx231xx_set_gpio_direction(struct cx231xx *dev, int pin_number,
 int cx231xx_gpio_i2c_start(struct cx231xx *dev);
 int cx231xx_gpio_i2c_end(struct cx231xx *dev);
 int cx231xx_gpio_i2c_write_byte(struct cx231xx *dev, u8 data);
-int cx231xx_gpio_i2c_read_byte(struct cx231xx *dev, u8 * buf);
+int cx231xx_gpio_i2c_read_byte(struct cx231xx *dev, u8 *buf);
 int cx231xx_gpio_i2c_read_ack(struct cx231xx *dev);
 int cx231xx_gpio_i2c_write_ack(struct cx231xx *dev);
 int cx231xx_gpio_i2c_write_nak(struct cx231xx *dev);
 
-int cx231xx_gpio_i2c_read(struct cx231xx *dev, u8 dev_addr, u8 * buf, u8 len);
-int cx231xx_gpio_i2c_write(struct cx231xx *dev, u8 dev_addr, u8 * buf, u8 len);
+int cx231xx_gpio_i2c_read(struct cx231xx *dev, u8 dev_addr, u8 *buf, u8 len);
+int cx231xx_gpio_i2c_write(struct cx231xx *dev, u8 dev_addr, u8 *buf, u8 len);
 
 /* audio related functions */
 int cx231xx_set_audio_decoder_input(struct cx231xx *dev,
@@ -658,8 +656,8 @@ int cx231xx_set_video_alternate(struct cx231xx *dev);
 int cx231xx_set_alt_setting(struct cx231xx *dev, u8 index, u8 alt);
 int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
 		      int num_bufs, int max_pkt_size,
-		      int (*isoc_copy) (struct cx231xx * dev,
-					struct urb * urb));
+		      int (*isoc_copy) (struct cx231xx *dev,
+					struct urb *urb));
 void cx231xx_uninit_isoc(struct cx231xx *dev);
 int cx231xx_set_mode(struct cx231xx *dev, enum cx231xx_mode set_mode);
 int cx231xx_gpio_set(struct cx231xx *dev, struct cx231xx_reg_seq *gpio);
-- 
cgit v1.2.3