[media] v4l2-dv-timings: fix overflow in gtf timings calculation

[firefly-linux-kernel-4.4.55.git] / drivers / media / v4l2-core / v4l2-dv-timings.c

diff --git a/drivers/media/v4l2-core/v4l2-dv-timings.c b/drivers/media/v4l2-core/v4l2-dv-timings.c
index b1d8dbb39665eab512f8dd59abdfac63fbed43e2..5792192bce6ccd3c14cf9ec01cdced4fbeb0dcc3 100644 (file)
--- a/drivers/media/v4l2-core/v4l2-dv-timings.c
+++ b/drivers/media/v4l2-core/v4l2-dv-timings.c
@@ -25,6 +25,7 @@
 #include <linux/videodev2.h>
 #include <linux/v4l2-dv-timings.h>
 #include <media/v4l2-dv-timings.h>
+#include <linux/math64.h>
 
 MODULE_AUTHOR("Hans Verkuil");
 MODULE_DESCRIPTION("V4L2 DV Timings Helper Functions");
@@ -282,7 +283,7 @@ void v4l2_print_dv_timings(const char *dev_prefix, const char *prefix,
                        (bt->polarities & V4L2_DV_VSYNC_POS_POL) ? "+" : "-",
                        bt->vsync, bt->vbackporch);
        pr_info("%s: pixelclock: %llu\n", dev_prefix, bt->pixelclock);
-       pr_info("%s: flags (0x%x):%s%s%s%s\n", dev_prefix, bt->flags,
+       pr_info("%s: flags (0x%x):%s%s%s%s%s\n", dev_prefix, bt->flags,
                        (bt->flags & V4L2_DV_FL_REDUCED_BLANKING) ?
                        " REDUCED_BLANKING" : "",
                        (bt->flags & V4L2_DV_FL_CAN_REDUCE_FPS) ?
@@ -290,7 +291,9 @@ void v4l2_print_dv_timings(const char *dev_prefix, const char *prefix,
                        (bt->flags & V4L2_DV_FL_REDUCED_FPS) ?
                        " REDUCED_FPS" : "",
                        (bt->flags & V4L2_DV_FL_HALF_LINE) ?
-                       " HALF_LINE" : "");
+                       " HALF_LINE" : "",
+                       (bt->flags & V4L2_DV_FL_IS_CE_VIDEO) ?
+                       " CE_VIDEO" : "");
        pr_info("%s: standards (0x%x):%s%s%s%s\n", dev_prefix, bt->standards,
                        (bt->standards & V4L2_DV_BT_STD_CEA861) ?  " CEA" : "",
                        (bt->standards & V4L2_DV_BT_STD_DMT) ?  " DMT" : "",
@@ -311,6 +314,7 @@ EXPORT_SYMBOL_GPL(v4l2_print_dv_timings);
 #define CVT_MIN_V_BPORCH       7       /* lines */
 #define CVT_MIN_V_PORCH_RND    3       /* lines */
 #define CVT_MIN_VSYNC_BP       550     /* min time of vsync + back porch (us) */
+#define CVT_HSYNC_PERCENT       8       /* nominal hsync as percentage of line */
 
 /* Normal blanking for CVT uses GTF to calculate horizontal blanking */
 #define CVT_CELL_GRAN          8       /* character cell granularity */
@@ -363,23 +367,29 @@ bool v4l2_detect_cvt(unsigned frame_height, unsigned hfreq, unsigned vsync,
        else
                return false;
 
+       if (hfreq == 0)
+               return false;
+
        /* Vertical */
        if (reduced_blanking) {
                v_fp = CVT_RB_V_FPORCH;
-               v_bp = (CVT_RB_MIN_V_BLANK * hfreq + 1999999) / 1000000;
+               v_bp = (CVT_RB_MIN_V_BLANK * hfreq) / 1000000 + 1;
                v_bp -= vsync + v_fp;
 
                if (v_bp < CVT_RB_MIN_V_BPORCH)
                        v_bp = CVT_RB_MIN_V_BPORCH;
        } else {
                v_fp = CVT_MIN_V_PORCH_RND;
-               v_bp = (CVT_MIN_VSYNC_BP * hfreq + 1999999) / 1000000 - vsync;
+               v_bp = (CVT_MIN_VSYNC_BP * hfreq) / 1000000 + 1 - vsync;
 
                if (v_bp < CVT_MIN_V_BPORCH)
                        v_bp = CVT_MIN_V_BPORCH;
        }
        image_height = (frame_height - v_fp - vsync - v_bp + 1) & ~0x1;
 
+       if (image_height < 0)
+               return false;
+
        /* Aspect ratio based on vsync */
        switch (vsync) {
        case 4:
@@ -434,8 +444,8 @@ bool v4l2_detect_cvt(unsigned frame_height, unsigned hfreq, unsigned vsync,
                h_bp = h_blank / 2;
                frame_width = image_width + h_blank;
 
-               hsync = (frame_width * 8 + 50) / 100;
-               hsync = hsync - hsync % CVT_CELL_GRAN;
+               hsync = frame_width * CVT_HSYNC_PERCENT / 100;
+               hsync = (hsync / CVT_CELL_GRAN) * CVT_CELL_GRAN;
                h_fp = h_blank - hsync - h_bp;
        }
 
@@ -525,11 +535,18 @@ bool v4l2_detect_gtf(unsigned frame_height,
        else
                return false;
 
+       if (hfreq == 0)
+               return false;
+
        /* Vertical */
        v_fp = GTF_V_FP;
-       v_bp = (GTF_MIN_VSYNC_BP * hfreq + 999999) / 1000000 - vsync;
+
+       v_bp = (GTF_MIN_VSYNC_BP * hfreq + 500000) / 1000000 - vsync;
        image_height = (frame_height - v_fp - vsync - v_bp + 1) & ~0x1;
 
+       if (image_height < 0)
+               return false;
+
        if (aspect.numerator == 0 || aspect.denominator == 0) {
                aspect.numerator = 16;
                aspect.denominator = 9;
@@ -538,25 +555,33 @@ bool v4l2_detect_gtf(unsigned frame_height,
        image_width = (image_width + GTF_CELL_GRAN/2) & ~(GTF_CELL_GRAN - 1);
 
        /* Horizontal */
-       if (default_gtf)
-               h_blank = ((image_width * GTF_D_C_PRIME * hfreq) -
-                                       (image_width * GTF_D_M_PRIME * 1000) +
-                       (hfreq * (100 - GTF_D_C_PRIME) + GTF_D_M_PRIME * 1000) / 2) /
-                       (hfreq * (100 - GTF_D_C_PRIME) + GTF_D_M_PRIME * 1000);
-       else
-               h_blank = ((image_width * GTF_S_C_PRIME * hfreq) -
-                                       (image_width * GTF_S_M_PRIME * 1000) +
-                       (hfreq * (100 - GTF_S_C_PRIME) + GTF_S_M_PRIME * 1000) / 2) /
-                       (hfreq * (100 - GTF_S_C_PRIME) + GTF_S_M_PRIME * 1000);
+       if (default_gtf) {
+               u64 num;
+               u32 den;
+
+               num = ((image_width * GTF_D_C_PRIME * (u64)hfreq) -
+                     ((u64)image_width * GTF_D_M_PRIME * 1000));
+               den = hfreq * (100 - GTF_D_C_PRIME) + GTF_D_M_PRIME * 1000;
+               h_blank = div_u64((num + (den >> 1)), den);
+       } else {
+               u64 num;
+               u32 den;
+
+               num = ((image_width * GTF_S_C_PRIME * (u64)hfreq) -
+                     ((u64)image_width * GTF_S_M_PRIME * 1000));
+               den = hfreq * (100 - GTF_S_C_PRIME) + GTF_S_M_PRIME * 1000;
+               h_blank = div_u64((num + (den >> 1)), den);
+       }
 
-       h_blank = h_blank - h_blank % (2 * GTF_CELL_GRAN);
+       h_blank = ((h_blank + GTF_CELL_GRAN) / (2 * GTF_CELL_GRAN)) *
+                 (2 * GTF_CELL_GRAN);
        frame_width = image_width + h_blank;
 
        pix_clk = (image_width + h_blank) * hfreq;
        pix_clk = pix_clk / GTF_PXL_CLK_GRAN * GTF_PXL_CLK_GRAN;
 
        hsync = (frame_width * 8 + 50) / 100;
-       hsync = hsync - hsync % GTF_CELL_GRAN;
+       hsync = ((hsync + GTF_CELL_GRAN / 2) / GTF_CELL_GRAN) * GTF_CELL_GRAN;
 
        h_fp = h_blank / 2 - hsync;