Merge tag 'of_videomode_helper' of git://git.pengutronix.de/git/str/linux into drm-next

videomode helpers for of + devicetree stuff, required for new kms drivers

(not the fbdev maintainer).

* tag 'of_videomode_helper' of git://git.pengutronix.de/git/str/linux:
  drm_modes: add of_videomode helpers
  drm_modes: add videomode helpers
  fbmon: add of_videomode helpers
  fbmon: add videomode helpers
  video: add of helper for display timings/videomode
  video: add display_timing and videomode
  viafb: rename display_timing to via_display_timing

13 files changed, 488 insertions, 13 deletions

diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index e7068c508800..807c7fa689fa 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -33,6 +33,27 @@ config VIDEO_OUTPUT_CONTROL
           This framework adds support for low-level control of the video 
           output switch.
 
+config DISPLAY_TIMING
+       bool
+
+config VIDEOMODE
+       bool
+
+config OF_DISPLAY_TIMING
+        bool "Enable device tree display timing support"
+        depends on OF
+        select DISPLAY_TIMING
+        help
+          helper to parse display timings from the devicetree
+
+config OF_VIDEOMODE
+        bool "Enable device tree videomode support"
+        depends on OF
+        select VIDEOMODE
+        select OF_DISPLAY_TIMING
+        help
+          helper to get videomodes from the devicetree
+
 menuconfig FB
         tristate "Support for frame buffer devices"
         ---help---
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 768a137a1bac..f592f3b32ec7 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -168,3 +168,7 @@ obj-$(CONFIG_FB_VIRTUAL)          += vfb.o
 
 #video output switch sysfs driver
 obj-$(CONFIG_VIDEO_OUTPUT_CONTROL) += output.o
+obj-$(CONFIG_DISPLAY_TIMING) += display_timing.o
+obj-$(CONFIG_OF_DISPLAY_TIMING) += of_display_timing.o
+obj-$(CONFIG_VIDEOMODE) += videomode.o
+obj-$(CONFIG_OF_VIDEOMODE) += of_videomode.o
diff --git a/drivers/video/display_timing.c b/drivers/video/display_timing.c
new file mode 100644
index 000000000000..5e1822cef571
--- /dev/null
+++ b/drivers/video/display_timing.c
@@ -0,0 +1,24 @@
+/*
+ * generic display timing functions
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * This file is released under the GPLv2
+ */
+
+#include <linux/export.h>
+#include <linux/slab.h>
+#include <video/display_timing.h>
+
+void display_timings_release(struct display_timings *disp)
+{
+        if (disp->timings) {
+                unsigned int i;
+
+                for (i = 0; i < disp->num_timings; i++)
+                        kfree(disp->timings[i]);
+                kfree(disp->timings);
+        }
+        kfree(disp);
+}
+EXPORT_SYMBOL_GPL(display_timings_release);
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index cef65574db6c..94ad0f71383c 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -31,6 +31,8 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <video/edid.h>
+#include <video/of_videomode.h>
+#include <video/videomode.h>
 #ifdef CONFIG_PPC_OF
 #include <asm/prom.h>
 #include <asm/pci-bridge.h>
@@ -1373,6 +1375,98 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
         kfree(timings);
         return err;
 }
+
+#if IS_ENABLED(CONFIG_VIDEOMODE)
+int fb_videomode_from_videomode(const struct videomode *vm,
+                                struct fb_videomode *fbmode)
+{
+        unsigned int htotal, vtotal;
+
+        fbmode->xres = vm->hactive;
+        fbmode->left_margin = vm->hback_porch;
+        fbmode->right_margin = vm->hfront_porch;
+        fbmode->hsync_len = vm->hsync_len;
+
+        fbmode->yres = vm->vactive;
+        fbmode->upper_margin = vm->vback_porch;
+        fbmode->lower_margin = vm->vfront_porch;
+        fbmode->vsync_len = vm->vsync_len;
+
+        /* prevent division by zero in KHZ2PICOS macro */
+        fbmode->pixclock = vm->pixelclock ?
+                        KHZ2PICOS(vm->pixelclock / 1000) : 0;
+
+        fbmode->sync = 0;
+        fbmode->vmode = 0;
+        if (vm->dmt_flags & VESA_DMT_HSYNC_HIGH)
+                fbmode->sync |= FB_SYNC_HOR_HIGH_ACT;
+        if (vm->dmt_flags & VESA_DMT_HSYNC_HIGH)
+                fbmode->sync |= FB_SYNC_VERT_HIGH_ACT;
+        if (vm->data_flags & DISPLAY_FLAGS_INTERLACED)
+                fbmode->vmode |= FB_VMODE_INTERLACED;
+        if (vm->data_flags & DISPLAY_FLAGS_DOUBLESCAN)
+                fbmode->vmode |= FB_VMODE_DOUBLE;
+        fbmode->flag = 0;
+
+        htotal = vm->hactive + vm->hfront_porch + vm->hback_porch +
+                 vm->hsync_len;
+        vtotal = vm->vactive + vm->vfront_porch + vm->vback_porch +
+                 vm->vsync_len;
+        /* prevent division by zero */
+        if (htotal && vtotal) {
+                fbmode->refresh = vm->pixelclock / (htotal * vtotal);
+        /* a mode must have htotal and vtotal != 0 or it is invalid */
+        } else {
+                fbmode->refresh = 0;
+                return -EINVAL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(fb_videomode_from_videomode);
+#endif
+
+#if IS_ENABLED(CONFIG_OF_VIDEOMODE)
+static inline void dump_fb_videomode(const struct fb_videomode *m)
+{
+        pr_debug("fb_videomode = %ux%u@%uHz (%ukHz) %u %u %u %u %u %u %u %u %u\n",
+                 m->xres, m->yres, m->refresh, m->pixclock, m->left_margin,
+                 m->right_margin, m->upper_margin, m->lower_margin,
+                 m->hsync_len, m->vsync_len, m->sync, m->vmode, m->flag);
+}
+
+/**
+ * of_get_fb_videomode - get a fb_videomode from devicetree
+ * @np: device_node with the timing specification
+ * @fb: will be set to the return value
+ * @index: index into the list of display timings in devicetree
+ *
+ * DESCRIPTION:
+ * This function is expensive and should only be used, if only one mode is to be
+ * read from DT. To get multiple modes start with of_get_display_timings ond
+ * work with that instead.
+ */
+int of_get_fb_videomode(struct device_node *np, struct fb_videomode *fb,
+                        int index)
+{
+        struct videomode vm;
+        int ret;
+
+        ret = of_get_videomode(np, &vm, index);
+        if (ret)
+                return ret;
+
+        fb_videomode_from_videomode(&vm, fb);
+
+        pr_debug("%s: got %dx%d display mode from %s\n",
+                of_node_full_name(np), vm.hactive, vm.vactive, np->name);
+        dump_fb_videomode(fb);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_get_fb_videomode);
+#endif
+
 #else
 int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
 {
diff --git a/drivers/video/of_display_timing.c b/drivers/video/of_display_timing.c
new file mode 100644
index 000000000000..13ecd9897010
--- /dev/null
+++ b/drivers/video/of_display_timing.c
@@ -0,0 +1,239 @@
+/*
+ * OF helpers for parsing display timings
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * based on of_videomode.c by Sascha Hauer <s.hauer@pengutronix.de>
+ *
+ * This file is released under the GPLv2
+ */
+#include <linux/export.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+#include <video/display_timing.h>
+#include <video/of_display_timing.h>
+
+/**
+ * parse_timing_property - parse timing_entry from device_node
+ * @np: device_node with the property
+ * @name: name of the property
+ * @result: will be set to the return value
+ *
+ * DESCRIPTION:
+ * Every display_timing can be specified with either just the typical value or
+ * a range consisting of min/typ/max. This function helps handling this
+ **/
+static int parse_timing_property(struct device_node *np, const char *name,
+                          struct timing_entry *result)
+{
+        struct property *prop;
+        int length, cells, ret;
+
+        prop = of_find_property(np, name, &length);
+        if (!prop) {
+                pr_err("%s: could not find property %s\n",
+                        of_node_full_name(np), name);
+                return -EINVAL;
+        }
+
+        cells = length / sizeof(u32);
+        if (cells == 1) {
+                ret = of_property_read_u32(np, name, &result->typ);
+                result->min = result->typ;
+                result->max = result->typ;
+        } else if (cells == 3) {
+                ret = of_property_read_u32_array(np, name, &result->min, cells);
+        } else {
+                pr_err("%s: illegal timing specification in %s\n",
+                        of_node_full_name(np), name);
+                return -EINVAL;
+        }
+
+        return ret;
+}
+
+/**
+ * of_get_display_timing - parse display_timing entry from device_node
+ * @np: device_node with the properties
+ **/
+static struct display_timing *of_get_display_timing(struct device_node *np)
+{
+        struct display_timing *dt;
+        u32 val = 0;
+        int ret = 0;
+
+        dt = kzalloc(sizeof(*dt), GFP_KERNEL);
+        if (!dt) {
+                pr_err("%s: could not allocate display_timing struct\n",
+                        of_node_full_name(np));
+                return NULL;
+        }
+
+        ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
+        ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
+        ret |= parse_timing_property(np, "hactive", &dt->hactive);
+        ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
+        ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
+        ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
+        ret |= parse_timing_property(np, "vactive", &dt->vactive);
+        ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
+        ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
+
+        dt->dmt_flags = 0;
+        dt->data_flags = 0;
+        if (!of_property_read_u32(np, "vsync-active", &val))
+                dt->dmt_flags |= val ? VESA_DMT_VSYNC_HIGH :
+                                VESA_DMT_VSYNC_LOW;
+        if (!of_property_read_u32(np, "hsync-active", &val))
+                dt->dmt_flags |= val ? VESA_DMT_HSYNC_HIGH :
+                                VESA_DMT_HSYNC_LOW;
+        if (!of_property_read_u32(np, "de-active", &val))
+                dt->data_flags |= val ? DISPLAY_FLAGS_DE_HIGH :
+                                DISPLAY_FLAGS_DE_LOW;
+        if (!of_property_read_u32(np, "pixelclk-active", &val))
+                dt->data_flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
+                                DISPLAY_FLAGS_PIXDATA_NEGEDGE;
+
+        if (of_property_read_bool(np, "interlaced"))
+                dt->data_flags |= DISPLAY_FLAGS_INTERLACED;
+        if (of_property_read_bool(np, "doublescan"))
+                dt->data_flags |= DISPLAY_FLAGS_DOUBLESCAN;
+
+        if (ret) {
+                pr_err("%s: error reading timing properties\n",
+                        of_node_full_name(np));
+                kfree(dt);
+                return NULL;
+        }
+
+        return dt;
+}
+
+/**
+ * of_get_display_timings - parse all display_timing entries from a device_node
+ * @np: device_node with the subnodes
+ **/
+struct display_timings *of_get_display_timings(struct device_node *np)
+{
+        struct device_node *timings_np;
+        struct device_node *entry;
+        struct device_node *native_mode;
+        struct display_timings *disp;
+
+        if (!np) {
+                pr_err("%s: no devicenode given\n", of_node_full_name(np));
+                return NULL;
+        }
+
+        timings_np = of_find_node_by_name(np, "display-timings");
+        if (!timings_np) {
+                pr_err("%s: could not find display-timings node\n",
+                        of_node_full_name(np));
+                return NULL;
+        }
+
+        disp = kzalloc(sizeof(*disp), GFP_KERNEL);
+        if (!disp) {
+                pr_err("%s: could not allocate struct disp'\n",
+                        of_node_full_name(np));
+                goto dispfail;
+        }
+
+        entry = of_parse_phandle(timings_np, "native-mode", 0);
+        /* assume first child as native mode if none provided */
+        if (!entry)
+                entry = of_get_next_child(np, NULL);
+        /* if there is no child, it is useless to go on */
+        if (!entry) {
+                pr_err("%s: no timing specifications given\n",
+                        of_node_full_name(np));
+                goto entryfail;
+        }
+
+        pr_debug("%s: using %s as default timing\n",
+                of_node_full_name(np), entry->name);
+
+        native_mode = entry;
+
+        disp->num_timings = of_get_child_count(timings_np);
+        if (disp->num_timings == 0) {
+                /* should never happen, as entry was already found above */
+                pr_err("%s: no timings specified\n", of_node_full_name(np));
+                goto entryfail;
+        }
+
+        disp->timings = kzalloc(sizeof(struct display_timing *) *
+                                disp->num_timings, GFP_KERNEL);
+        if (!disp->timings) {
+                pr_err("%s: could not allocate timings array\n",
+                        of_node_full_name(np));
+                goto entryfail;
+        }
+
+        disp->num_timings = 0;
+        disp->native_mode = 0;
+
+        for_each_child_of_node(timings_np, entry) {
+                struct display_timing *dt;
+
+                dt = of_get_display_timing(entry);
+                if (!dt) {
+                        /*
+                         * to not encourage wrong devicetrees, fail in case of
+                         * an error
+                         */
+                        pr_err("%s: error in timing %d\n",
+                                of_node_full_name(np), disp->num_timings + 1);
+                        goto timingfail;
+                }
+
+                if (native_mode == entry)
+                        disp->native_mode = disp->num_timings;
+
+                disp->timings[disp->num_timings] = dt;
+                disp->num_timings++;
+        }
+        of_node_put(timings_np);
+        /*
+         * native_mode points to the device_node returned by of_parse_phandle
+         * therefore call of_node_put on it
+         */
+        of_node_put(native_mode);
+
+        pr_debug("%s: got %d timings. Using timing #%d as default\n",
+                of_node_full_name(np), disp->num_timings,
+                disp->native_mode + 1);
+
+        return disp;
+
+timingfail:
+        if (native_mode)
+                of_node_put(native_mode);
+        display_timings_release(disp);
+entryfail:
+        kfree(disp);
+dispfail:
+        of_node_put(timings_np);
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(of_get_display_timings);
+
+/**
+ * of_display_timings_exist - check if a display-timings node is provided
+ * @np: device_node with the timing
+ **/
+int of_display_timings_exist(struct device_node *np)
+{
+        struct device_node *timings_np;
+
+        if (!np)
+                return -EINVAL;
+
+        timings_np = of_parse_phandle(np, "display-timings", 0);
+        if (!timings_np)
+                return -EINVAL;
+
+        of_node_put(timings_np);
+        return 1;
+}
+EXPORT_SYMBOL_GPL(of_display_timings_exist);
diff --git a/drivers/video/of_videomode.c b/drivers/video/of_videomode.c
new file mode 100644
index 000000000000..5b8066cd397f
--- /dev/null
+++ b/drivers/video/of_videomode.c
@@ -0,0 +1,54 @@
+/*
+ * generic videomode helper
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * This file is released under the GPLv2
+ */
+#include <linux/errno.h>
+#include <linux/export.h>
+#include <linux/of.h>
+#include <video/display_timing.h>
+#include <video/of_display_timing.h>
+#include <video/of_videomode.h>
+#include <video/videomode.h>
+
+/**
+ * of_get_videomode - get the videomode #<index> from devicetree
+ * @np - devicenode with the display_timings
+ * @vm - set to return value
+ * @index - index into list of display_timings
+ *          (Set this to OF_USE_NATIVE_MODE to use whatever mode is
+ *           specified as native mode in the DT.)
+ *
+ * DESCRIPTION:
+ * Get a list of all display timings and put the one
+ * specified by index into *vm. This function should only be used, if
+ * only one videomode is to be retrieved. A driver that needs to work
+ * with multiple/all videomodes should work with
+ * of_get_display_timings instead.
+ **/
+int of_get_videomode(struct device_node *np, struct videomode *vm,
+                     int index)
+{
+        struct display_timings *disp;
+        int ret;
+
+        disp = of_get_display_timings(np);
+        if (!disp) {
+                pr_err("%s: no timings specified\n", of_node_full_name(np));
+                return -EINVAL;
+        }
+
+        if (index == OF_USE_NATIVE_MODE)
+                index = disp->native_mode;
+
+        ret = videomode_from_timing(disp, vm, index);
+        if (ret)
+                return ret;
+
+        display_timings_release(disp);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_get_videomode);
diff --git a/drivers/video/via/hw.c b/drivers/video/via/hw.c
index 80233dae358a..22450908306c 100644
--- a/drivers/video/via/hw.c
+++ b/drivers/video/via/hw.c
@@ -1467,10 +1467,10 @@ void viafb_set_vclock(u32 clk, int set_iga)
         via_write_misc_reg_mask(0x0C, 0x0C); /* select external clock */
 }
 
-struct display_timing var_to_timing(const struct fb_var_screeninfo *var,
+struct via_display_timing var_to_timing(const struct fb_var_screeninfo *var,
         u16 cxres, u16 cyres)
 {
-        struct display_timing timing;
+        struct via_display_timing timing;
         u16 dx = (var->xres - cxres) / 2, dy = (var->yres - cyres) / 2;
 
         timing.hor_addr = cxres;
@@ -1491,7 +1491,7 @@ struct display_timing var_to_timing(const struct fb_var_screeninfo *var,
 void viafb_fill_crtc_timing(const struct fb_var_screeninfo *var,
         u16 cxres, u16 cyres, int iga)
 {
-        struct display_timing crt_reg = var_to_timing(var,
+        struct via_display_timing crt_reg = var_to_timing(var,
                 cxres ? cxres : var->xres, cyres ? cyres : var->yres);
 
         if (iga == IGA1)
diff --git a/drivers/video/via/hw.h b/drivers/video/via/hw.h
index a8205754c736..3be073c58b03 100644
--- a/drivers/video/via/hw.h
+++ b/drivers/video/via/hw.h
@@ -637,7 +637,7 @@ extern int viafb_LCD_ON;
 extern int viafb_DVI_ON;
 extern int viafb_hotplug;
 
-struct display_timing var_to_timing(const struct fb_var_screeninfo *var,
+struct via_display_timing var_to_timing(const struct fb_var_screeninfo *var,
         u16 cxres, u16 cyres);
 void viafb_fill_crtc_timing(const struct fb_var_screeninfo *var,
         u16 cxres, u16 cyres, int iga);
diff --git a/drivers/video/via/lcd.c b/drivers/video/via/lcd.c
index 980ee1b1dcf3..5d21ff436ec8 100644
--- a/drivers/video/via/lcd.c
+++ b/drivers/video/via/lcd.c
@@ -549,7 +549,7 @@ void viafb_lcd_set_mode(const struct fb_var_screeninfo *var, u16 cxres,
         int panel_hres = plvds_setting_info->lcd_panel_hres;
         int panel_vres = plvds_setting_info->lcd_panel_vres;
         u32 clock;
-        struct display_timing timing;
+        struct via_display_timing timing;
         struct fb_var_screeninfo panel_var;
         const struct fb_videomode *mode_crt_table, *panel_crt_table;
 
diff --git a/drivers/video/via/share.h b/drivers/video/via/share.h
index 3158dfc90bed..65c65c611e0a 100644
--- a/drivers/video/via/share.h
+++ b/drivers/video/via/share.h
@@ -319,7 +319,7 @@ struct crt_mode_table {
         int refresh_rate;
         int h_sync_polarity;
         int v_sync_polarity;
-        struct display_timing crtc;
+        struct via_display_timing crtc;
 };
 
 struct io_reg {
diff --git a/drivers/video/via/via_modesetting.c b/drivers/video/via/via_modesetting.c
index 0e431aee17bb..0b414b09b9b4 100644
--- a/drivers/video/via/via_modesetting.c
+++ b/drivers/video/via/via_modesetting.c
@@ -30,9 +30,9 @@
 #include "debug.h"
 
 
-void via_set_primary_timing(const struct display_timing *timing)
+void via_set_primary_timing(const struct via_display_timing *timing)
 {
-        struct display_timing raw;
+        struct via_display_timing raw;
 
         raw.hor_total = timing->hor_total / 8 - 5;
         raw.hor_addr = timing->hor_addr / 8 - 1;
@@ -88,9 +88,9 @@ void via_set_primary_timing(const struct display_timing *timing)
         via_write_reg_mask(VIACR, 0x17, 0x80, 0x80);
 }
 
-void via_set_secondary_timing(const struct display_timing *timing)
+void via_set_secondary_timing(const struct via_display_timing *timing)
 {
-        struct display_timing raw;
+        struct via_display_timing raw;
 
         raw.hor_total = timing->hor_total - 1;
         raw.hor_addr = timing->hor_addr - 1;
diff --git a/drivers/video/via/via_modesetting.h b/drivers/video/via/via_modesetting.h
index 06e09fe351ae..f6a6503da3b3 100644
--- a/drivers/video/via/via_modesetting.h
+++ b/drivers/video/via/via_modesetting.h
@@ -33,7 +33,7 @@
 #define VIA_PITCH_MAX   0x3FF8
 
 
-struct display_timing {
+struct via_display_timing {
         u16 hor_total;
         u16 hor_addr;
         u16 hor_blank_start;
@@ -49,8 +49,8 @@ struct display_timing {
 };
 
 
-void via_set_primary_timing(const struct display_timing *timing);
-void via_set_secondary_timing(const struct display_timing *timing);
+void via_set_primary_timing(const struct via_display_timing *timing);
+void via_set_secondary_timing(const struct via_display_timing *timing);
 void via_set_primary_address(u32 addr);
 void via_set_secondary_address(u32 addr);
 void via_set_primary_pitch(u32 pitch);
diff --git a/drivers/video/videomode.c b/drivers/video/videomode.c
new file mode 100644
index 000000000000..21c47a202afa
--- /dev/null
+++ b/drivers/video/videomode.c
@@ -0,0 +1,39 @@
+/*
+ * generic display timing functions
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * This file is released under the GPLv2
+ */
+
+#include <linux/errno.h>
+#include <linux/export.h>
+#include <video/display_timing.h>
+#include <video/videomode.h>
+
+int videomode_from_timing(const struct display_timings *disp,
+                          struct videomode *vm, unsigned int index)
+{
+        struct display_timing *dt;
+
+        dt = display_timings_get(disp, index);
+        if (!dt)
+                return -EINVAL;
+
+        vm->pixelclock = display_timing_get_value(&dt->pixelclock, TE_TYP);
+        vm->hactive = display_timing_get_value(&dt->hactive, TE_TYP);
+        vm->hfront_porch = display_timing_get_value(&dt->hfront_porch, TE_TYP);
+        vm->hback_porch = display_timing_get_value(&dt->hback_porch, TE_TYP);
+        vm->hsync_len = display_timing_get_value(&dt->hsync_len, TE_TYP);
+
+        vm->vactive = display_timing_get_value(&dt->vactive, TE_TYP);
+        vm->vfront_porch = display_timing_get_value(&dt->vfront_porch, TE_TYP);
+        vm->vback_porch = display_timing_get_value(&dt->vback_porch, TE_TYP);
+        vm->vsync_len = display_timing_get_value(&dt->vsync_len, TE_TYP);
+
+        vm->dmt_flags = dt->dmt_flags;
+        vm->data_flags = dt->data_flags;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(videomode_from_timing);