mmc: fsl_esdhc: workaround for hardware 3.3v IO reliability issue

[oweals/u-boot.git] / drivers / video / videomodes.c

diff --git a/drivers/video/videomodes.c b/drivers/video/videomodes.c
index 40c3315aa9ef89ed54887169f6a5b7a3eb076e29..89003eea7276972b202abe9a56c622b7e21336a5 100644 (file)
--- a/drivers/video/videomodes.c
+++ b/drivers/video/videomodes.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  * (C) Copyright 2004
  * Pierre Aubert, Staubli Faverges , <p.aubert@staubli.com>
  * Copyright 2011 Freescale Semiconductor, Inc.
- *
- * SPDX-License-Identifier:    GPL-2.0+
  */
 
 /************************************************************************
@@ -58,6 +57,9 @@
 ****************************************************************************/
 
 #include <common.h>
+#include <edid.h>
+#include <env.h>
+#include <errno.h>
 #include <linux/ctype.h>
 
 #include "videomodes.h"
@@ -163,7 +165,8 @@ int video_get_params (struct ctfb_res_modes *pPar, char *penv)
        /* first search for the environment containing the real param string */
        s = penv;
 
-       if ((p = getenv (s)) != NULL)
+       p = env_get(s);
+       if (p)
                s = p;
 
        /*
@@ -232,7 +235,7 @@ int video_get_params (struct ctfb_res_modes *pPar, char *penv)
 int video_get_video_mode(unsigned int *xres, unsigned int *yres,
        unsigned int *depth, unsigned int *freq, const char **options)
 {
-       char *p = getenv("video-mode");
+       char *p = env_get("video-mode");
        if (!p)
                return 0;
 
@@ -373,3 +376,100 @@ int video_get_option_int(const char *options, const char *name, int def)
        }
        return def;
 }
+
+/**
+ * Convert an EDID detailed timing to a struct ctfb_res_modes
+ *
+ * @param t            The EDID detailed timing to be converted
+ * @param mode         Returns the converted timing
+ *
+ * @return 0 on success, or a negative errno on error
+ */
+int video_edid_dtd_to_ctfb_res_modes(struct edid_detailed_timing *t,
+                                    struct ctfb_res_modes *mode)
+{
+       int margin, h_total, v_total;
+
+       /* Check all timings are non 0 */
+       if (EDID_DETAILED_TIMING_PIXEL_CLOCK(*t) == 0 ||
+           EDID_DETAILED_TIMING_HORIZONTAL_ACTIVE(*t) == 0 ||
+           EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*t) == 0 ||
+           EDID_DETAILED_TIMING_VERTICAL_ACTIVE(*t) == 0 ||
+           EDID_DETAILED_TIMING_VERTICAL_BLANKING(*t) == 0 ||
+           EDID_DETAILED_TIMING_HSYNC_OFFSET(*t) == 0 ||
+           EDID_DETAILED_TIMING_VSYNC_OFFSET(*t) == 0 ||
+           /* 3d formats are not supported */
+           EDID_DETAILED_TIMING_FLAG_STEREO(*t) != 0)
+               return -EINVAL;
+
+       mode->xres = EDID_DETAILED_TIMING_HORIZONTAL_ACTIVE(*t);
+       mode->yres = EDID_DETAILED_TIMING_VERTICAL_ACTIVE(*t);
+
+       h_total = mode->xres + EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*t);
+       v_total = mode->yres + EDID_DETAILED_TIMING_VERTICAL_BLANKING(*t);
+       mode->refresh = EDID_DETAILED_TIMING_PIXEL_CLOCK(*t) /
+                       (h_total * v_total);
+
+       mode->pixclock_khz = EDID_DETAILED_TIMING_PIXEL_CLOCK(*t) / 1000;
+       mode->pixclock = 1000000000L / mode->pixclock_khz;
+
+       mode->right_margin = EDID_DETAILED_TIMING_HSYNC_OFFSET(*t);
+       mode->hsync_len = EDID_DETAILED_TIMING_HSYNC_PULSE_WIDTH(*t);
+       margin = EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*t) -
+                       (mode->right_margin + mode->hsync_len);
+       if (margin <= 0)
+               return -EINVAL;
+
+       mode->left_margin = margin;
+
+       mode->lower_margin = EDID_DETAILED_TIMING_VSYNC_OFFSET(*t);
+       mode->vsync_len = EDID_DETAILED_TIMING_VSYNC_PULSE_WIDTH(*t);
+       margin = EDID_DETAILED_TIMING_VERTICAL_BLANKING(*t) -
+                       (mode->lower_margin + mode->vsync_len);
+       if (margin <= 0)
+               return -EINVAL;
+
+       mode->upper_margin = margin;
+
+       mode->sync = 0;
+       if (EDID_DETAILED_TIMING_FLAG_HSYNC_POLARITY(*t))
+               mode->sync |= FB_SYNC_HOR_HIGH_ACT;
+       if (EDID_DETAILED_TIMING_FLAG_VSYNC_POLARITY(*t))
+               mode->sync |= FB_SYNC_VERT_HIGH_ACT;
+
+       if (EDID_DETAILED_TIMING_FLAG_INTERLACED(*t))
+               mode->vmode = FB_VMODE_INTERLACED;
+       else
+               mode->vmode = FB_VMODE_NONINTERLACED;
+
+       return 0;
+}
+
+void video_ctfb_mode_to_display_timing(const struct ctfb_res_modes *mode,
+                                      struct display_timing *timing)
+{
+       timing->pixelclock.typ = mode->pixclock_khz * 1000;
+
+       timing->hactive.typ = mode->xres;
+       timing->hfront_porch.typ = mode->right_margin;
+       timing->hback_porch.typ = mode->left_margin;
+       timing->hsync_len.typ = mode->hsync_len;
+
+       timing->vactive.typ = mode->yres;
+       timing->vfront_porch.typ = mode->lower_margin;
+       timing->vback_porch.typ = mode->upper_margin;
+       timing->vsync_len.typ = mode->vsync_len;
+
+       timing->flags = 0;
+
+       if (mode->sync & FB_SYNC_HOR_HIGH_ACT)
+               timing->flags |= DISPLAY_FLAGS_HSYNC_HIGH;
+       else
+               timing->flags |= DISPLAY_FLAGS_HSYNC_LOW;
+       if (mode->sync & FB_SYNC_VERT_HIGH_ACT)
+               timing->flags |= DISPLAY_FLAGS_VSYNC_HIGH;
+       else
+               timing->flags |= DISPLAY_FLAGS_VSYNC_LOW;
+       if (mode->vmode == FB_VMODE_INTERLACED)
+               timing->flags |= DISPLAY_FLAGS_INTERLACED;
+}