dm: core: Update of_read_fmap_entry() for livetree

[u-boot] / drivers / video / video-uclass.c

diff --git a/drivers/video/video-uclass.c b/drivers/video/video-uclass.c
index 24d537e6c44ff37236e1b8b41049417c8f13147f..dd0873767ba5ef6c38ea771ce2e51d1cc13f7c53 100644 (file)
--- a/drivers/video/video-uclass.c
+++ b/drivers/video/video-uclass.c
@@ -1,7 +1,6 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright (c) 2015 Google, Inc
- *
- * SPDX-License-Identifier:    GPL-2.0+
  */
 
 #include <common.h>
@@ -54,6 +53,9 @@ static ulong alloc_fb(struct udevice *dev, ulong *addrp)
        struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
        ulong base, align, size;
 
+       if (!plat->size)
+               return 0;
+
        align = plat->align ? plat->align : 1 << 20;
        base = *addrp - plat->size;
        base &= ~(align - 1);
@@ -84,21 +86,45 @@ int video_reserve(ulong *addrp)
        return 0;
 }
 
-static int video_clear(struct udevice *dev)
+void video_clear(struct udevice *dev)
 {
        struct video_priv *priv = dev_get_uclass_priv(dev);
 
-       if (priv->bpix == VIDEO_BPP32) {
+       switch (priv->bpix) {
+       case VIDEO_BPP16: {
+               u16 *ppix = priv->fb;
+               u16 *end = priv->fb + priv->fb_size;
+
+               while (ppix < end)
+                       *ppix++ = priv->colour_bg;
+               break;
+       }
+       case VIDEO_BPP32: {
                u32 *ppix = priv->fb;
                u32 *end = priv->fb + priv->fb_size;
 
                while (ppix < end)
                        *ppix++ = priv->colour_bg;
-       } else {
+               break;
+       }
+       default:
                memset(priv->fb, priv->colour_bg, priv->fb_size);
+               break;
        }
+}
 
-       return 0;
+void video_set_default_colors(struct video_priv *priv)
+{
+#ifdef CONFIG_SYS_WHITE_ON_BLACK
+       /* White is used when switching to bold, use light gray here */
+       priv->fg_col_idx = VID_LIGHT_GRAY;
+       priv->colour_fg = vid_console_color(priv, VID_LIGHT_GRAY);
+       priv->colour_bg = vid_console_color(priv, VID_BLACK);
+#else
+       priv->fg_col_idx = VID_BLACK;
+       priv->colour_fg = vid_console_color(priv, VID_BLACK);
+       priv->colour_bg = vid_console_color(priv, VID_WHITE);
+#endif
 }
 
 /* Flush video activity to the caches */
@@ -114,7 +140,8 @@ void video_sync(struct udevice *vid)
 
        if (priv->flush_dcache) {
                flush_dcache_range((ulong)priv->fb,
-                                  (ulong)priv->fb + priv->fb_size);
+                                  ALIGN((ulong)priv->fb + priv->fb_size,
+                                        CONFIG_SYS_CACHELINE_SIZE));
        }
 #elif defined(CONFIG_VIDEO_SANDBOX_SDL)
        struct video_priv *priv = dev_get_uclass_priv(vid);
@@ -180,6 +207,7 @@ static int video_post_probe(struct udevice *dev)
        struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
        struct video_priv *priv = dev_get_uclass_priv(dev);
        char name[30], drv[15], *str;
+       const char *drv_name = drv;
        struct udevice *cons;
        int ret;
 
@@ -188,29 +216,45 @@ static int video_post_probe(struct udevice *dev)
        priv->line_length = priv->xsize * VNBYTES(priv->bpix);
        priv->fb_size = priv->line_length * priv->ysize;
 
-       /* Set up colours - we could in future support other colours */
-#ifdef CONFIG_SYS_WHITE_ON_BLACK
-       priv->colour_fg = 0xffffff;
-#else
-       priv->colour_bg = 0xffffff;
-#endif
-       video_clear(dev);
+       /* Set up colors  */
+       video_set_default_colors(priv);
+
+       if (!CONFIG_IS_ENABLED(NO_FB_CLEAR))
+               video_clear(dev);
 
        /*
-        * Create a text console devices. For now we always do this, although
+        * Create a text console device. For now we always do this, although
         * it might be useful to support only bitmap drawing on the device
-        * for boards that don't need to display text.
+        * for boards that don't need to display text. We create a TrueType
+        * console if enabled, a rotated console if the video driver requests
+        * it, otherwise a normal console.
+        *
+        * The console can be override by setting vidconsole_drv_name before
+        * probing this video driver, or in the probe() method.
+        *
+        * TrueType does not support rotation at present so fall back to the
+        * rotated console in that case.
         */
-       snprintf(name, sizeof(name), "%s.vidconsole", dev->name);
+       if (!priv->rot && IS_ENABLED(CONFIG_CONSOLE_TRUETYPE)) {
+               snprintf(name, sizeof(name), "%s.vidconsole_tt", dev->name);
+               strcpy(drv, "vidconsole_tt");
+       } else {
+               snprintf(name, sizeof(name), "%s.vidconsole%d", dev->name,
+                        priv->rot);
+               snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
+       }
+
        str = strdup(name);
        if (!str)
                return -ENOMEM;
-       snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
-       ret = device_bind_driver(dev, drv, str, &cons);
+       if (priv->vidconsole_drv_name)
+               drv_name = priv->vidconsole_drv_name;
+       ret = device_bind_driver(dev, drv_name, str, &cons);
        if (ret) {
                debug("%s: Cannot bind console driver\n", __func__);
                return ret;
        }
+
        ret = device_probe(cons);
        if (ret) {
                debug("%s: Cannot probe console driver\n", __func__);
@@ -227,7 +271,7 @@ static int video_post_bind(struct udevice *dev)
        ulong size;
 
        /* Before relocation there is nothing to do here */
-       if ((!gd->flags & GD_FLG_RELOC))
+       if (!(gd->flags & GD_FLG_RELOC))
                return 0;
        size = alloc_fb(dev, &addr);
        if (addr < gd->video_bottom) {