video: tegra: default mode support for fbconsole

First mode from EDID is chosen for fbconsole without applying any
sort of filtering. This lead to choosing modes which were not
always guaranteed to be supported by our hardware. To overcome such
cases, we are adding support for users to specify a default mode for
fbconsole. Other userspace applications will have to choose the best
mode based on their requirements.

To avoid any impact on platforms that might prefer the earlier logic
of using the first mode from monitor's modelist, default mode for
fbconsole will be set only if a mode is specified through
"nvidia,fbcon-default-mode" property in DT.

Refactored code. Created a new function for fbcon default mode parsing
logic and used tegra_dc_set_fbcon_boot_mode() to set early dc mode for
fbconsole. Added edid parameter to tegra_dc_set_fbcon_boot_mode() and
moved its declaration to dc_privs.h as edid.h is already available in
this header file.

bug 200308135

Change-Id: Id69a10b8b7b85176dacc4a9127ef0707aea3c4ca
Signed-off-by: Naveen Kumar S <nkumars@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1563131
(cherry picked from commit a5e01c17dbc55fd0153790ddbded5e017a6f7999)
Reviewed-on: https://git-master.nvidia.com/r/1780977
Reviewed-by: Shu Zhong <shuz@nvidia.com>
GVS: Gerrit_Virtual_Submit
Reviewed-by: Bibek Basu <bbasu@nvidia.com>
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

8 files changed, 156 insertions, 82 deletions

diff --git a/drivers/video/tegra/dc/dc.c b/drivers/video/tegra/dc/dc.c
index 9dfc890e9..0c0437e4a 100644
--- a/drivers/video/tegra/dc/dc.c
+++ b/drivers/video/tegra/dc/dc.c
@@ -6770,7 +6770,7 @@ static int tegra_dc_probe(struct platform_device *ndev)
                 hotplug_init_status = dc->out_ops->hotplug_init(dc);
 
         if (dc->out->type == TEGRA_DC_OUT_DP) {
-                ret = tegra_dc_set_fbcon_boot_mode(dc);
+                ret = tegra_dc_set_fbcon_boot_mode(dc, dc->edid);
                 if (ret)
                         dev_err(&dc->ndev->dev,
                                 "Failed to set fbcon mode for DC %d\n",
diff --git a/drivers/video/tegra/dc/dc.h b/drivers/video/tegra/dc/dc.h
index f7859ea54..7a94afad1 100644
--- a/drivers/video/tegra/dc/dc.h
+++ b/drivers/video/tegra/dc/dc.h
@@ -677,6 +677,8 @@ struct tegra_dc_out {
         struct completion       user_vblank_comp;
 
         bool                            is_ext_dp_panel;
+        /* Default mode for fbconsole */
+        struct fb_videomode     *fbcon_default_mode;
 
         int     (*enable)(struct device *);
         int     (*postpoweron)(struct device *);
@@ -981,7 +983,6 @@ int tegra_dc_to_fb_videomode(struct fb_videomode *fbmode,
         const struct tegra_dc_mode *mode);
 int tegra_dc_set_fb_mode(struct tegra_dc *dc, const struct fb_videomode *fbmode,
         bool stereo_mode);
-int tegra_dc_set_fbcon_boot_mode(struct tegra_dc *dc);
 
 unsigned tegra_dc_get_out_height(const struct tegra_dc *dc);
 unsigned tegra_dc_get_out_width(const struct tegra_dc *dc);
diff --git a/drivers/video/tegra/dc/dc_priv.h b/drivers/video/tegra/dc/dc_priv.h
index dd73cd03f..9e8634432 100644
--- a/drivers/video/tegra/dc/dc_priv.h
+++ b/drivers/video/tegra/dc/dc_priv.h
@@ -976,6 +976,8 @@ static inline void tegra_dc_set_edid(struct tegra_dc *dc,
         dc->edid = edid;
 }
 
+int tegra_dc_set_fbcon_boot_mode(struct tegra_dc *dc, struct tegra_edid *edid);
+
 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 static inline u32 tegra_dc_reg_l32(dma_addr_t v)
 {
diff --git a/drivers/video/tegra/dc/dp.c b/drivers/video/tegra/dc/dp.c
index 320a6e298..f76b7f8d7 100644
--- a/drivers/video/tegra/dc/dp.c
+++ b/drivers/video/tegra/dc/dp.c
@@ -2021,8 +2021,13 @@ static int tegra_dc_dp_init(struct tegra_dc *dc)
                 tegra_hda_init(dc, dp);
 #endif
 
-        if (!(dc->mode.pclk) && IS_ENABLED(CONFIG_FRAMEBUFFER_CONSOLE))
-                tegra_dc_set_fb_mode(dc, &tegra_dc_vga_mode, false);
+        if (!(dc->mode.pclk) && IS_ENABLED(CONFIG_FRAMEBUFFER_CONSOLE)) {
+                if (dc->out->fbcon_default_mode)
+                        tegra_dc_set_fb_mode(dc,
+                                        dc->out->fbcon_default_mode, false);
+                else
+                        tegra_dc_set_fb_mode(dc, &tegra_dc_vga_mode, false);
+        }
 
         tegra_dc_dp_debugfs_create(dp);
         dp_instance++;
diff --git a/drivers/video/tegra/dc/hdmi2.0.c b/drivers/video/tegra/dc/hdmi2.0.c
index f866db8f4..af10156ad 100644
--- a/drivers/video/tegra/dc/hdmi2.0.c
+++ b/drivers/video/tegra/dc/hdmi2.0.c
@@ -1687,57 +1687,16 @@ static int tegra_dc_hdmi_init(struct tegra_dc *dc)
         }
 
         /* NOTE: Below code is applicable to L4T or embedded systems and is
-         * protected accordingly. This section early enables DC with first mode
-         * from the monitor specs.
-         * In case there is no hotplug we are falling back
-         * to default VGA mode.
+         * protected accordingly. This section chooses a mode to early
+         * enable DC.
          */
         if ((IS_ENABLED(CONFIG_FRAMEBUFFER_CONSOLE) ||
                         ((dc->pdata->flags & TEGRA_DC_FLAG_ENABLED) &&
                          (dc->pdata->flags & TEGRA_DC_FLAG_SET_EARLY_MODE))) &&
                         dc->out && (dc->out->type == TEGRA_DC_OUT_HDMI)) {
-                struct fb_monspecs specs;
-
-                specs.modedb = NULL;
-
-                /* If dc is initialized by bootloader or if display-timings
-                 * are specified in DT, dc mode would already be set.
-                 */
-                if (!dc->initialized && !dc->out->n_modes) {
-                        if (tegra_dc_hpd(dc)) {
-                                if (!tegra_edid_get_monspecs(hdmi->edid,
-                                                                &specs)) {
-                                        err = tegra_dc_set_fb_mode(dc,
-                                                specs.modedb, false);
-                                        if (err) {
-                                                dev_err(&dc->ndev->dev,
-                                                "%s: set DC mode from modedb,"
-                                                " err = %d\n", __func__, err);
-                                        }
-                                } else {
-                                        /* Reading edid from monitor failed */
-                                        err = tegra_dc_set_fb_mode(dc,
-                                                &tegra_dc_vga_mode, false);
-                                        if (err) {
-                                                dev_err(&dc->ndev->dev,
-                                                "%s: no edid, set VGA mode,"
-                                                " err=%d\n", __func__, err);
-                                        }
-                                }
-                        } else {
-                                /* No DT mode and HPD not detected */
-                                err = tegra_dc_set_fb_mode(dc,
-                                        &tegra_dc_vga_mode, false);
-                                if (err) {
-                                        dev_err(&dc->ndev->dev,
-                                        "%s: fallback to VGA mode, err=%d\n",
-                                        __func__, err);
-                                }
-                        }
-
-                        if (specs.modedb != NULL)
-                                kfree(specs.modedb);
-                }
+                /* In case of seamless display, dc mode would already be set */
+                if (!dc->initialized)
+                        tegra_dc_set_fbcon_boot_mode(dc, hdmi->edid);
         }
 
 #ifdef CONFIG_SWITCH
diff --git a/drivers/video/tegra/dc/mode.c b/drivers/video/tegra/dc/mode.c
index ab3b2f523..d08af12aa 100644
--- a/drivers/video/tegra/dc/mode.c
+++ b/drivers/video/tegra/dc/mode.c
@@ -906,35 +906,66 @@ int tegra_dc_set_fb_mode(struct tegra_dc *dc,
 }
 EXPORT_SYMBOL(tegra_dc_set_fb_mode);
 
-int tegra_dc_set_fbcon_boot_mode(struct tegra_dc *dc)
+int tegra_dc_set_fbcon_boot_mode(struct tegra_dc *dc, struct tegra_edid *edid)
 {
-        struct tegra_edid *edid = NULL;
         struct fb_monspecs specs;
-        int     ret = 0;
+        int ret = 0;
 
         specs.modedb = NULL;
-        if (tegra_fb_is_console_enabled(dc->pdata) &&
-                (!dc->initialized) && tegra_dc_hpd(dc)) {
+        if (tegra_fb_is_console_enabled(dc->pdata)) {
                 switch (dc->out->type) {
                 case TEGRA_DC_OUT_HDMI:
                         break;
-
                 case TEGRA_DC_OUT_DP:
                         if (!tegra_dc_is_ext_dp_panel(dc))
                                 return 0;
-
-                        edid = dc->edid;
                         break;
                 default:
                         return -EINVAL;
                 }
 
-                if (edid && !tegra_edid_get_monspecs(edid, &specs))
-                        ret = tegra_dc_set_fb_mode(dc, specs.modedb, false);
-                else
-                        ret = tegra_dc_set_fb_mode(dc, &tegra_dc_vga_mode,
-                                                                        false);
+                /* In case of seamless display, dc mode would already be set */
+                if (!dc->initialized) {
+                        if (dc->out->fbcon_default_mode) {
+                                ret = tegra_dc_set_fb_mode(dc,
+                                        dc->out->fbcon_default_mode, false);
+                                if (ret) {
+                                        dev_err(&dc->ndev->dev,
+                                        "%s: setting default fbcon mode failed,"
+                                        " err = %d\n", __func__, ret);
+                                        }
+                        } else if (edid && tegra_dc_hpd(dc)) {
+                                if (!tegra_edid_get_monspecs(edid, &specs)) {
+                                        ret = tegra_dc_set_fb_mode(dc,
+                                                specs.modedb, false);
+                                        if (ret) {
+                                                dev_err(&dc->ndev->dev,
+                                                "%s: set DC mode from modedb,"
+                                                " err = %d\n", __func__, ret);
+                                        }
+                                } else {
+                                        /* Reading edid from monitor failed */
+                                        ret = tegra_dc_set_fb_mode(dc,
+                                                &tegra_dc_vga_mode, false);
+                                        if (ret) {
+                                                dev_err(&dc->ndev->dev,
+                                                "%s: no edid, set VGA mode,"
+                                                " err=%d\n", __func__, ret);
+                                        }
+                                }
+                        } else {
+                                /* HPD not detected */
+                                ret = tegra_dc_set_fb_mode(dc,
+                                        &tegra_dc_vga_mode, false);
+                                if (ret) {
+                                        dev_err(&dc->ndev->dev,
+                                        "%s: fallback to VGA mode, err=%d\n",
+                                        __func__, ret);
+                                }
+                        }
+                }
         }
+
         if (specs.modedb != NULL)
                 kfree(specs.modedb);
         return ret;
diff --git a/drivers/video/tegra/dc/of_dc.c b/drivers/video/tegra/dc/of_dc.c
index b42c7042f..6e18a9371 100644
--- a/drivers/video/tegra/dc/of_dc.c
+++ b/drivers/video/tegra/dc/of_dc.c
@@ -931,25 +931,38 @@ static int parse_modes(struct tegra_dc_out *default_out,
                 OF_DC_LOG("of v_front_porch %d\n", temp);
                 goto parse_modes_fail;
         }
-
-        for (i = 0; pins && (i < default_out->n_out_pins); i++) {
-                switch (pins[i].name) {
-                case TEGRA_DC_OUT_PIN_DATA_ENABLE:
-                        if (pins[i].pol == TEGRA_DC_OUT_PIN_POL_LOW)
-                                modes->flags |= TEGRA_DC_MODE_FLAG_NEG_DE;
-                        break;
-                case TEGRA_DC_OUT_PIN_H_SYNC:
-                        if (pins[i].pol == TEGRA_DC_OUT_PIN_POL_LOW)
-                                modes->flags |= TEGRA_DC_MODE_FLAG_NEG_H_SYNC;
-                        break;
-                case TEGRA_DC_OUT_PIN_V_SYNC:
-                        if (pins[i].pol == TEGRA_DC_OUT_PIN_POL_LOW)
-                                modes->flags |= TEGRA_DC_MODE_FLAG_NEG_V_SYNC;
-                        break;
-                default:
-                        /* Ignore other pin setting */
-                        break;
+        /* Optional property. Don't fail if not specified */
+        if (!of_property_read_u32(np, "vmode", &temp)) {
+                modes->vmode = temp;
+        }
+
+        if (pins && default_out->n_out_pins) {
+                for (i = 0; i < default_out->n_out_pins; i++) {
+                        switch (pins[i].name) {
+                        case TEGRA_DC_OUT_PIN_DATA_ENABLE:
+                                if (pins[i].pol == TEGRA_DC_OUT_PIN_POL_LOW)
+                                        modes->flags |=
+                                                TEGRA_DC_MODE_FLAG_NEG_DE;
+                                break;
+                        case TEGRA_DC_OUT_PIN_H_SYNC:
+                                if (pins[i].pol == TEGRA_DC_OUT_PIN_POL_LOW)
+                                        modes->flags |=
+                                                TEGRA_DC_MODE_FLAG_NEG_H_SYNC;
+                                break;
+                        case TEGRA_DC_OUT_PIN_V_SYNC:
+                                if (pins[i].pol == TEGRA_DC_OUT_PIN_POL_LOW)
+                                        modes->flags |=
+                                                TEGRA_DC_MODE_FLAG_NEG_V_SYNC;
+                                break;
+                        default:
+                                /* Ignore other pin setting */
+                                break;
+                        }
                 }
+        } else {
+                /* Optional property. Don't fail if not specified */
+                if (!of_property_read_u32(np, "flags", &temp))
+                        modes->flags = temp;
         }
 
         return 0;
@@ -958,6 +971,53 @@ parse_modes_fail:
         return -EINVAL;
 }
 
+#if defined(CONFIG_FRAMEBUFFER_CONSOLE)
+int parse_fbcon_default_mode(struct device_node *np_target_disp,
+                        struct platform_device *ndev,
+                        struct tegra_dc_platform_data *pdata)
+{
+        struct device_node *fbcon_default_mode_np = NULL;
+        int err = 0;
+
+        fbcon_default_mode_np = of_get_child_by_name(np_target_disp,
+                                        "nvidia,fbcon-default-mode");
+
+        if (!fbcon_default_mode_np) {
+                pdata->default_out->fbcon_default_mode = NULL;
+        } else {
+                struct tegra_dc_mode fbcon_dc_mode;
+                memset(&fbcon_dc_mode, 0x0,
+                                sizeof(struct tegra_dc_mode));
+                pdata->default_out->fbcon_default_mode =
+                        devm_kzalloc(&ndev->dev,
+                                sizeof(struct fb_videomode), GFP_KERNEL);
+                if (!pdata->default_out->fbcon_default_mode) {
+                        pr_err("%s: not enough memory for fbcon mode\n",
+                                                __func__);
+                        err = -ENOMEM;
+                        goto fail_fbcon_parse;
+                }
+
+                err = parse_modes(pdata->default_out,
+                                fbcon_default_mode_np, &fbcon_dc_mode);
+                if (err) {
+                        pr_err("%s: failed to parse fbcon mode\n", __func__);
+                        goto fail_fbcon_parse;
+                }
+
+                err = tegra_dc_to_fb_videomode(
+                        pdata->default_out->fbcon_default_mode, &fbcon_dc_mode);
+                if (err) {
+                        pr_err("%s: error converting fbcon mode\n", __func__);
+                        goto fail_fbcon_parse;
+                }
+        }
+
+fail_fbcon_parse:
+        return err;
+}
+#endif
+
 static int parse_cmu_data(struct device_node *np,
         struct tegra_dc_cmu *cmu)
 {
@@ -3019,6 +3079,18 @@ struct tegra_dc_platform_data *of_dc_parse_platform_data(
                 }
         }
 
+#if defined(CONFIG_FRAMEBUFFER_CONSOLE)
+        /* Default mode for fbconsole */
+        if ((pdata->default_out->type == TEGRA_DC_OUT_HDMI) ||
+                (pdata->default_out->type == TEGRA_DC_OUT_DP)) {
+                err = parse_fbcon_default_mode(np_target_disp, ndev, pdata);
+                if (err) {
+                        pr_err("%s: parsing fbcon mode failed\n", __func__);
+                        goto fail_parse;
+                }
+        }
+#endif
+
         vrr_np = of_get_child_by_name(np_target_disp, "vrr-settings");
         if (!vrr_np || (def_out->n_modes < 2)) {
                 pr_debug("%s: could not find vrr-settings node\n", __func__);
diff --git a/drivers/video/tegra/fb.c b/drivers/video/tegra/fb.c
index 94dbf8f90..0573bfeb1 100644
--- a/drivers/video/tegra/fb.c
+++ b/drivers/video/tegra/fb.c
@@ -927,7 +927,11 @@ void tegra_fb_update_monspecs(struct tegra_fb_info *fb_info,
                 tegra_dc_to_fb_videomode(&fb_mode, &dc->cached_mode);
                 dc->use_cached_mode = false;
         } else {
-                memcpy(&fb_mode, &specs->modedb[0],
+                if (!dc->out->fbcon_default_mode)
+                        memcpy(&fb_mode, &specs->modedb[0],
+                                sizeof(struct fb_videomode));
+                else
+                        memcpy(&fb_mode, dc->out->fbcon_default_mode,
                                 sizeof(struct fb_videomode));
         }