[media] cx25821,medusa: incorrect check on decoder type

[firefly-linux-kernel-4.4.55.git] / drivers / media / video / cx25821 / cx25821-medusa-video.c

diff --git a/drivers/media/video/cx25821/cx25821-medusa-video.c b/drivers/media/video/cx25821/cx25821-medusa-video.c
index fc780d0908dc61e54f255f7f7ca6c290df598274..6a92e5c70c2a95b10d16e57cfea87e2651f77069 100644 (file)
--- a/drivers/media/video/cx25821/cx25821-medusa-video.c
+++ b/drivers/media/video/cx25821/cx25821-medusa-video.c
@@ -35,7 +35,6 @@
 static void medusa_enable_bluefield_output(struct cx25821_dev *dev, int channel,
                                           int enable)
 {
-       int ret_val = 1;
        u32 value = 0;
        u32 tmp = 0;
        int out_ctrl = OUT_CTRL1;
@@ -79,13 +78,13 @@ static void medusa_enable_bluefield_output(struct cx25821_dev *dev, int channel,
        value &= 0xFFFFFF7F;    /* clear BLUE_FIELD_EN */
        if (enable)
                value |= 0x00000080;    /* set BLUE_FIELD_EN */
-       ret_val = cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl, value);
+       cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl, value);
 
        value = cx25821_i2c_read(&dev->i2c_bus[0], out_ctrl_ns, &tmp);
        value &= 0xFFFFFF7F;
        if (enable)
                value |= 0x00000080;    /* set BLUE_FIELD_EN */
-       ret_val = cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl_ns, value);
+       cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl_ns, value);
 }
 
 static int medusa_initialize_ntsc(struct cx25821_dev *dev)
@@ -99,82 +98,67 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
 
        for (i = 0; i < MAX_DECODERS; i++) {
                /* set video format NTSC-M */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                    &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               MODE_CTRL + (0x200 * i), &tmp);
                value &= 0xFFFFFFF0;
                /* enable the fast locking mode bit[16] */
                value |= 0x10001;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                     value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               MODE_CTRL + (0x200 * i), value);
 
                /* resolution NTSC 720x480 */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    HORIZ_TIM_CTRL + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               HORIZ_TIM_CTRL + (0x200 * i), &tmp);
                value &= 0x00C00C00;
                value |= 0x612D0074;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     HORIZ_TIM_CTRL + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               HORIZ_TIM_CTRL + (0x200 * i), value);
 
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    VERT_TIM_CTRL + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               VERT_TIM_CTRL + (0x200 * i), &tmp);
                value &= 0x00C00C00;
                value |= 0x1C1E001A;    /* vblank_cnt + 2 to get camera ID */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     VERT_TIM_CTRL + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               VERT_TIM_CTRL + (0x200 * i), value);
 
                /* chroma subcarrier step size */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     SC_STEP_SIZE + (0x200 * i), 0x43E00000);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               SC_STEP_SIZE + (0x200 * i), 0x43E00000);
 
                /* enable VIP optional active */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    OUT_CTRL_NS + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               OUT_CTRL_NS + (0x200 * i), &tmp);
                value &= 0xFFFBFFFF;
                value |= 0x00040000;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     OUT_CTRL_NS + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               OUT_CTRL_NS + (0x200 * i), value);
 
                /* enable VIP optional active (VIP_OPT_AL) for direct output. */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                    &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               OUT_CTRL1 + (0x200 * i), &tmp);
                value &= 0xFFFBFFFF;
                value |= 0x00040000;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                     value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               OUT_CTRL1 + (0x200 * i), value);
 
                /*
                 * clear VPRES_VERT_EN bit, fixes the chroma run away problem
                 * when the input switching rate < 16 fields
                */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    MISC_TIM_CTRL + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               MISC_TIM_CTRL + (0x200 * i), &tmp);
                /* disable special play detection */
                value = setBitAtPos(value, 14);
                value = clearBitAtPos(value, 15);
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     MISC_TIM_CTRL + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               MISC_TIM_CTRL + (0x200 * i), value);
 
                /* set vbi_gate_en to 0 */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                    &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DFE_CTRL1 + (0x200 * i), &tmp);
                value = clearBitAtPos(value, 29);
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                     value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DFE_CTRL1 + (0x200 * i), value);
 
                /* Enable the generation of blue field output if no video */
                medusa_enable_bluefield_output(dev, i, 1);
@@ -182,61 +166,49 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
 
        for (i = 0; i < MAX_ENCODERS; i++) {
                /* NTSC hclock */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_1 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_1 + (0x100 * i), &tmp);
                value &= 0xF000FC00;
                value |= 0x06B402D0;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_1 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_1 + (0x100 * i), value);
 
                /* burst begin and burst end */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_2 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_2 + (0x100 * i), &tmp);
                value &= 0xFF000000;
                value |= 0x007E9054;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_2 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_2 + (0x100 * i), value);
 
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_3 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_3 + (0x100 * i), &tmp);
                value &= 0xFC00FE00;
                value |= 0x00EC00F0;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_3 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_3 + (0x100 * i), value);
 
                /* set NTSC vblank, no phase alternation, 7.5 IRE pedestal */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_4 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_4 + (0x100 * i), &tmp);
                value &= 0x00FCFFFF;
                value |= 0x13020000;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_4 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_4 + (0x100 * i), value);
 
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_5 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_5 + (0x100 * i), &tmp);
                value &= 0xFFFF0000;
                value |= 0x0000E575;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_5 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_5 + (0x100 * i), value);
 
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_6 + (0x100 * i), 0x009A89C1);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_6 + (0x100 * i), 0x009A89C1);
 
                /* Subcarrier Increment */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_7 + (0x100 * i), 0x21F07C1F);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_7 + (0x100 * i), 0x21F07C1F);
        }
 
        /* set picture resolutions */
@@ -261,34 +233,27 @@ static int medusa_PALCombInit(struct cx25821_dev *dev, int dec)
        u32 value = 0, tmp = 0;
 
        /* Setup for 2D threshold */
-       ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFS_CFG + (0x200 * dec),
-                             0x20002861);
-       ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFD_CFG + (0x200 * dec),
-                             0x20002861);
-       ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_LF_CFG + (0x200 * dec),
-                             0x200A1023);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                       COMB_2D_HFS_CFG + (0x200 * dec), 0x20002861);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                       COMB_2D_HFD_CFG + (0x200 * dec), 0x20002861);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                       COMB_2D_LF_CFG + (0x200 * dec), 0x200A1023);
 
        /* Setup flat chroma and luma thresholds */
-       value =
-           cx25821_i2c_read(&dev->i2c_bus[0],
-                            COMB_FLAT_THRESH_CTRL + (0x200 * dec), &tmp);
+       value = cx25821_i2c_read(&dev->i2c_bus[0],
+                       COMB_FLAT_THRESH_CTRL + (0x200 * dec), &tmp);
        value &= 0x06230000;
-       ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0],
-                             COMB_FLAT_THRESH_CTRL + (0x200 * dec), value);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                       COMB_FLAT_THRESH_CTRL + (0x200 * dec), value);
 
        /* set comb 2D blend */
-       ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_BLEND + (0x200 * dec),
-                             0x210F0F0F);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                       COMB_2D_BLEND + (0x200 * dec), 0x210F0F0F);
 
        /* COMB MISC CONTROL */
-       ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0], COMB_MISC_CTRL + (0x200 * dec),
-                             0x41120A7F);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                       COMB_MISC_CTRL + (0x200 * dec), 0x41120A7F);
 
        return ret_val;
 }
@@ -304,83 +269,68 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
 
        for (i = 0; i < MAX_DECODERS; i++) {
                /* set video format PAL-BDGHI */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                    &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               MODE_CTRL + (0x200 * i), &tmp);
                value &= 0xFFFFFFF0;
                /* enable the fast locking mode bit[16] */
                value |= 0x10004;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                     value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               MODE_CTRL + (0x200 * i), value);
 
                /* resolution PAL 720x576 */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    HORIZ_TIM_CTRL + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               HORIZ_TIM_CTRL + (0x200 * i), &tmp);
                value &= 0x00C00C00;
                value |= 0x632D007D;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     HORIZ_TIM_CTRL + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               HORIZ_TIM_CTRL + (0x200 * i), value);
 
                /* vblank656_cnt=x26, vactive_cnt=240h, vblank_cnt=x24 */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    VERT_TIM_CTRL + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               VERT_TIM_CTRL + (0x200 * i), &tmp);
                value &= 0x00C00C00;
                value |= 0x28240026;    /* vblank_cnt + 2 to get camera ID */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     VERT_TIM_CTRL + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               VERT_TIM_CTRL + (0x200 * i), value);
 
                /* chroma subcarrier step size */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     SC_STEP_SIZE + (0x200 * i), 0x5411E2D0);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               SC_STEP_SIZE + (0x200 * i), 0x5411E2D0);
 
                /* enable VIP optional active */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    OUT_CTRL_NS + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               OUT_CTRL_NS + (0x200 * i), &tmp);
                value &= 0xFFFBFFFF;
                value |= 0x00040000;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     OUT_CTRL_NS + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               OUT_CTRL_NS + (0x200 * i), value);
 
                /* enable VIP optional active (VIP_OPT_AL) for direct output. */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                    &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               OUT_CTRL1 + (0x200 * i), &tmp);
                value &= 0xFFFBFFFF;
                value |= 0x00040000;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                     value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               OUT_CTRL1 + (0x200 * i), value);
 
                /*
                 * clear VPRES_VERT_EN bit, fixes the chroma run away problem
                 * when the input switching rate < 16 fields
                 */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    MISC_TIM_CTRL + (0x200 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               MISC_TIM_CTRL + (0x200 * i), &tmp);
                /* disable special play detection */
                value = setBitAtPos(value, 14);
                value = clearBitAtPos(value, 15);
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     MISC_TIM_CTRL + (0x200 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               MISC_TIM_CTRL + (0x200 * i), value);
 
                /* set vbi_gate_en to 0 */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                    &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DFE_CTRL1 + (0x200 * i), &tmp);
                value = clearBitAtPos(value, 29);
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                     value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DFE_CTRL1 + (0x200 * i), value);
 
                medusa_PALCombInit(dev, i);
 
@@ -390,62 +340,50 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
 
        for (i = 0; i < MAX_ENCODERS; i++) {
                /* PAL hclock */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_1 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_1 + (0x100 * i), &tmp);
                value &= 0xF000FC00;
                value |= 0x06C002D0;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_1 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_1 + (0x100 * i), value);
 
                /* burst begin and burst end */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_2 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_2 + (0x100 * i), &tmp);
                value &= 0xFF000000;
                value |= 0x007E9754;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_2 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_2 + (0x100 * i), value);
 
                /* hblank and vactive */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_3 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_3 + (0x100 * i), &tmp);
                value &= 0xFC00FE00;
                value |= 0x00FC0120;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_3 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_3 + (0x100 * i), value);
 
                /* set PAL vblank, phase alternation, 0 IRE pedestal */
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_4 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_4 + (0x100 * i), &tmp);
                value &= 0x00FCFFFF;
                value |= 0x14010000;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_4 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_4 + (0x100 * i), value);
 
-               value =
-                   cx25821_i2c_read(&dev->i2c_bus[0],
-                                    DENC_A_REG_5 + (0x100 * i), &tmp);
+               value = cx25821_i2c_read(&dev->i2c_bus[0],
+                               DENC_A_REG_5 + (0x100 * i), &tmp);
                value &= 0xFFFF0000;
                value |= 0x0000F078;
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_5 + (0x100 * i), value);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_5 + (0x100 * i), value);
 
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_6 + (0x100 * i), 0x00A493CF);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_6 + (0x100 * i), 0x00A493CF);
 
                /* Subcarrier Increment */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     DENC_A_REG_7 + (0x100 * i), 0x2A098ACB);
+               ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                               DENC_A_REG_7 + (0x100 * i), 0x2A098ACB);
        }
 
        /* set picture resolutions */
@@ -492,14 +430,13 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
 {
        int decoder = 0;
        int decoder_count = 0;
-       int ret_val = 0;
        u32 hscale = 0x0;
        u32 vscale = 0x0;
        const int MAX_WIDTH = 720;
 
        mutex_lock(&dev->lock);
 
-       /* validate the width - cannot be negative */
+       /* validate the width */
        if (width > MAX_WIDTH) {
                pr_info("%s(): width %d > MAX_WIDTH %d ! resetting to MAX_WIDTH\n",
                        __func__, width, MAX_WIDTH);
@@ -543,12 +480,10 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
 
        for (; decoder < decoder_count; decoder++) {
                /* write scaling values for each decoder */
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     HSCALE_CTRL + (0x200 * decoder), hscale);
-               ret_val =
-                   cx25821_i2c_write(&dev->i2c_bus[0],
-                                     VSCALE_CTRL + (0x200 * decoder), vscale);
+               cx25821_i2c_write(&dev->i2c_bus[0],
+                               HSCALE_CTRL + (0x200 * decoder), hscale);
+               cx25821_i2c_write(&dev->i2c_bus[0],
+                               VSCALE_CTRL + (0x200 * decoder), vscale);
        }
 
        mutex_unlock(&dev->lock);
@@ -557,7 +492,6 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
 static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
                                       int duration)
 {
-       int ret_val = 0;
        u32 fld_cnt = 0;
        u32 tmp = 0;
        u32 disp_cnt_reg = DISP_AB_CNT;
@@ -565,7 +499,7 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
        mutex_lock(&dev->lock);
 
        /* no support */
-       if (decoder < VDEC_A && decoder > VDEC_H) {
+       if (decoder < VDEC_A || decoder > VDEC_H) {
                mutex_unlock(&dev->lock);
                return;
        }
@@ -600,14 +534,14 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
                fld_cnt |= ((u32) duration) << 16;
        }
 
-       ret_val = cx25821_i2c_write(&dev->i2c_bus[0], disp_cnt_reg, fld_cnt);
+       cx25821_i2c_write(&dev->i2c_bus[0], disp_cnt_reg, fld_cnt);
 
        mutex_unlock(&dev->lock);
 }
 
 /* Map to Medusa register setting */
-static int mapM(int srcMin,
-               int srcMax, int srcVal, int dstMin, int dstMax, int *dstVal)
+static int mapM(int srcMin, int srcMax, int srcVal, int dstMin, int dstMax,
+               int *dstVal)
 {
        int numerator;
        int denominator;
@@ -654,23 +588,19 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder)
        u32 val = 0, tmp = 0;
 
        mutex_lock(&dev->lock);
-       if ((brightness > VIDEO_PROCAMP_MAX)
-           || (brightness < VIDEO_PROCAMP_MIN)) {
+       if ((brightness > VIDEO_PROCAMP_MAX) ||
+           (brightness < VIDEO_PROCAMP_MIN)) {
                mutex_unlock(&dev->lock);
                return -1;
        }
-       ret_val =
-           mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness,
-                SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
+       ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness,
+                       SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
        value = convert_to_twos(value, 8);
-       val =
-           cx25821_i2c_read(&dev->i2c_bus[0],
-                            VDEC_A_BRITE_CTRL + (0x200 * decoder), &tmp);
+       val = cx25821_i2c_read(&dev->i2c_bus[0],
+                       VDEC_A_BRITE_CTRL + (0x200 * decoder), &tmp);
        val &= 0xFFFFFF00;
-       ret_val |=
-           cx25821_i2c_write(&dev->i2c_bus[0],
-                             VDEC_A_BRITE_CTRL + (0x200 * decoder),
-                             val | value);
+       ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                       VDEC_A_BRITE_CTRL + (0x200 * decoder), val | value);
        mutex_unlock(&dev->lock);
        return ret_val;
 }
@@ -688,17 +618,13 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder)
                return -1;
        }
 
-       ret_val =
-           mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, contrast,
-                UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
-       val =
-           cx25821_i2c_read(&dev->i2c_bus[0],
-                            VDEC_A_CNTRST_CTRL + (0x200 * decoder), &tmp);
+       ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, contrast,
+                       UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
+       val = cx25821_i2c_read(&dev->i2c_bus[0],
+                       VDEC_A_CNTRST_CTRL + (0x200 * decoder), &tmp);
        val &= 0xFFFFFF00;
-       ret_val |=
-           cx25821_i2c_write(&dev->i2c_bus[0],
-                             VDEC_A_CNTRST_CTRL + (0x200 * decoder),
-                             val | value);
+       ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                       VDEC_A_CNTRST_CTRL + (0x200 * decoder), val | value);
 
        mutex_unlock(&dev->lock);
        return ret_val;
@@ -717,19 +643,16 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder)
                return -1;
        }
 
-       ret_val =
-           mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, hue, SIGNED_BYTE_MIN,
-                SIGNED_BYTE_MAX, &value);
+       ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, hue,
+                       SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
 
        value = convert_to_twos(value, 8);
-       val =
-           cx25821_i2c_read(&dev->i2c_bus[0],
-                            VDEC_A_HUE_CTRL + (0x200 * decoder), &tmp);
+       val = cx25821_i2c_read(&dev->i2c_bus[0],
+                       VDEC_A_HUE_CTRL + (0x200 * decoder), &tmp);
        val &= 0xFFFFFF00;
 
-       ret_val |=
-           cx25821_i2c_write(&dev->i2c_bus[0],
-                             VDEC_A_HUE_CTRL + (0x200 * decoder), val | value);
+       ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                       VDEC_A_HUE_CTRL + (0x200 * decoder), val | value);
 
        mutex_unlock(&dev->lock);
        return ret_val;
@@ -743,33 +666,26 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder)
 
        mutex_lock(&dev->lock);
 
-       if ((saturation > VIDEO_PROCAMP_MAX)
-           || (saturation < VIDEO_PROCAMP_MIN)) {
+       if ((saturation > VIDEO_PROCAMP_MAX) ||
+           (saturation < VIDEO_PROCAMP_MIN)) {
                mutex_unlock(&dev->lock);
                return -1;
        }
 
-       ret_val =
-           mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, saturation,
-                UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
+       ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, saturation,
+                       UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
 
-       val =
-           cx25821_i2c_read(&dev->i2c_bus[0],
-                            VDEC_A_USAT_CTRL + (0x200 * decoder), &tmp);
+       val = cx25821_i2c_read(&dev->i2c_bus[0],
+                       VDEC_A_USAT_CTRL + (0x200 * decoder), &tmp);
        val &= 0xFFFFFF00;
-       ret_val |=
-           cx25821_i2c_write(&dev->i2c_bus[0],
-                             VDEC_A_USAT_CTRL + (0x200 * decoder),
-                             val | value);
-
-       val =
-           cx25821_i2c_read(&dev->i2c_bus[0],
-                            VDEC_A_VSAT_CTRL + (0x200 * decoder), &tmp);
+       ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                       VDEC_A_USAT_CTRL + (0x200 * decoder), val | value);
+
+       val = cx25821_i2c_read(&dev->i2c_bus[0],
+                       VDEC_A_VSAT_CTRL + (0x200 * decoder), &tmp);
        val &= 0xFFFFFF00;
-       ret_val |=
-           cx25821_i2c_write(&dev->i2c_bus[0],
-                             VDEC_A_VSAT_CTRL + (0x200 * decoder),
-                             val | value);
+       ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                       VDEC_A_VSAT_CTRL + (0x200 * decoder), val | value);
 
        mutex_unlock(&dev->lock);
        return ret_val;
@@ -830,9 +746,8 @@ int medusa_video_init(struct cx25821_dev *dev)
        /* select AFE clock to output mode */
        value = cx25821_i2c_read(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, &tmp);
        value &= 0x83FFFFFF;
-       ret_val =
-          cx25821_i2c_write(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL,
-                            value | 0x10000000);
+       ret_val = cx25821_i2c_write(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL,
+                       value | 0x10000000);
 
        if (ret_val < 0)
                goto error;