* [RFC PATCH 0/4] drm/tilcdc: Implement state readout
@ 2026-11-16 14:27 Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 1/4] drm/bridge: Add atomic_sro_install_state hook Màxim Pedraza Padilla
` (3 more replies)
0 siblings, 4 replies; 5+ messages in thread
From: Màxim Pedraza Padilla @ 2026-11-16 14:27 UTC (permalink / raw)
To: Maxime Ripard
Cc: Neil Armstrong, Jessica Zhang, Jyri Sarha, Tomi Valkeinen,
Uwe Kleine-König, Andrzej Hajda, Robert Foss,
Laurent Pinchart, Jonas Karlman, Jernej Skrabec, Luca Ceresoli,
Maarten Lankhorst, Thomas Zimmermann, David Airlie,
Simona Vetter, dri-devel, linux-kernel
Hi Maxime,
Following your suggestion in the boot logo thread ("just implement readout
then"), this implements hardware state readout for tilcdc on top of your
v7:
https://lore.kernel.org/r/20261029-drm-state-readout-v7-0-25e5163d75c3@kernel.org
The goal is that the kernel takes over the display as U-Boot left it, so
the boot logo stays on screen with no blanking or flicker until userspace
replaces it.
Patch 1 adds an atomic_sro_install_state hook to bridges, and patch 2 uses
it in the panel bridge, which also reads out the connector and bridge
state: without that, the core discards the readout of any driver behind a
panel. Patch 3 is the tilcdc readout itself: CRTC mode from the raster
timings, primary plane with a non-GEM framebuffer (as tidss does), encoder
and hw_reset. Patch 4 keeps panel-simple from turning the panel off at
probe by driving its enable GPIO low.
For the backlight, pwm-tiecap needs a .get_state(), otherwise pwm_bl sees
the PWM disabled and sets duty 0 until the panel is enabled. I sent that
one separately to Uwe and linux-pwm:
https://lore.kernel.org/r/20261116142251.1296742-1-maximpedraza@gmail.com
Tested on an AM335x board (Fides T075, out-of-tree DT) with U-Boot
leaving an 800x480 RGB565 logo:
- The logo stays on screen, untouched, from U-Boot to userspace, with the
backlight on all along.
- The U-Boot mode doesn't match the one in the DT (16.94 MHz pixel clock
and slightly different timings), so the first commit with the panel
mode does a full modeset, as expected.
- First commits from userspace: a framebuffer flip without modeset, a full
modeset to the panel mode, and ACTIVE=0 then 1. No WARN or oops.
- With drm.atomic_readout=0 the old behaviour comes back: the raster stops
and the first commit does a full modeset.
- Without video set up by U-Boot nothing is adopted and the normal path is
taken.
- The SGX530 driver and a Qt EGLFS application take over from the adopted
logo without visible glitches.
The DT needs a reserved-memory node for the U-Boot framebuffer, and
ti,no-reset-on-init on the GPIO banks (and on the PWMSS) so that ti-sysc
doesn't reset the panel enable and backlight lines.
The backlight needs some care. With the PWM configured by the bootloader
and the pin muxed to it, the handover is seamless. If the bootloader drives
the backlight some other way, for instance with the pin as a plain GPIO and
the PWM stopped, the light goes off when the kernel muxes the pin to the
PWM, until the panel is enabled. The bootloader has to leave the backlight
in the state the kernel will read back.
After each commit, the comparison still reports some mismatches. As far as
I can tell they come from the core rather than from tilcdc, but I'd
appreciate your view:
- connector_mask and encoder_mask, on a commit that only changes the
framebuffer: the connector is not part of the commit, so it's not read
back.
- mode_blob, after a modeset: the memcmp() includes the mode type, and
DRM_MODE_TYPE_PREFERRED can't be read from the hardware.
- With ACTIVE=0: crtc, fb, enable, best_encoder and the bridge bus_cfg.
The readout sees the raster stopped and can't tell enable=1/active=0
from disabled.
Thanks,
Màxim
Màxim Pedraza Padilla (4):
drm/bridge: Add atomic_sro_install_state hook
drm/panel: Implement state readout in the panel bridge
drm/tilcdc: Implement state readout support
drm/panel: simple: Keep the enable GPIO as left by the bootloader
drivers/gpu/drm/drm_bridge.c | 12 ++
drivers/gpu/drm/drm_panel.c | 92 ++++++++++++-
drivers/gpu/drm/panel/panel-simple.c | 4 +-
drivers/gpu/drm/tilcdc/tilcdc_crtc.c | 173 ++++++++++++++++++++++++
drivers/gpu/drm/tilcdc/tilcdc_drv.c | 22 ++-
drivers/gpu/drm/tilcdc/tilcdc_encoder.c | 29 +++-
drivers/gpu/drm/tilcdc/tilcdc_plane.c | 106 +++++++++++++++
include/drm/drm_bridge.h | 12 ++
8 files changed, 442 insertions(+), 8 deletions(-)
base-commit: cf5d8e390e2ac2cfa24a50645efdbb9f0eebe65f
prerequisite-patch-id: dd600a02afa073bedc54e8b973d6bfdad7594dcf
prerequisite-patch-id: cb32051331d83506b8e6fd512f93595724905a9f
prerequisite-patch-id: 72acc5f5b50b767484ff995256e7fb155c05f6eb
prerequisite-patch-id: 20859bdf469e990a0d7dae3498bc90452afac2b6
prerequisite-patch-id: ca629fbb440fc4bddbf5594161eb44aadacbffdc
prerequisite-patch-id: 1a6e113d6f412d798052a924269a7dc876d91ded
prerequisite-patch-id: 8eacf9b84574fe303134a78ce9c3fcc4ec1c8dbf
prerequisite-patch-id: be45e01b10b8b0050199e379d51d80866c9bd60f
prerequisite-patch-id: 0ab25f681f68659f8a0e4f0da80fdf70952dcf8d
prerequisite-patch-id: cd456ec3d0c297910f46bbc02fdf105dc1881528
prerequisite-patch-id: 8f0adc84c688489feb0cba21f1f2292be4229095
prerequisite-patch-id: 86ba5aa9cdc784c0b7f1a63beb76925ef26a51f4
prerequisite-patch-id: 797d3d2c63a2772528c850d5058e11d064e13b81
prerequisite-patch-id: a1f2f5aa788a1615c521496408c8380bb076a906
prerequisite-patch-id: c9f90931b72f402916621991a8a8abf6f4b5ffb5
prerequisite-patch-id: e0e184d52d20bd622b3752ea73516698bedf554f
prerequisite-patch-id: 9779c50d8b08c7d2ac14017fe2825d148350e434
prerequisite-patch-id: 2dfe6357a636b3662dbd8db80bc29bd36a0329ad
prerequisite-patch-id: 704fb943477b1a761312b0ec16e9291cad7c9769
prerequisite-patch-id: 0409704173cb408067b9e69071c0af7efe299492
prerequisite-patch-id: 455ce6bd7b211ef9c772ba06efefdffd27058a87
prerequisite-patch-id: 5ed7b0ed4e054ecbd8c84e622dbac0f42d60e4a6
prerequisite-patch-id: 563c77055b805b0d640cd8517627a8c491bce385
prerequisite-patch-id: ad8a0534dbcf96480f5020f50fd68d5b78c5fac5
prerequisite-patch-id: 8fe899b77403121b41514f93b859b5e4528a79d9
prerequisite-patch-id: 4fafee08b92675ea8a6f7fb5e27ff5a769325208
prerequisite-patch-id: d7abc61edebf4b3a87d94806301a99db4e28c036
prerequisite-patch-id: 615c6d4def91d820c55f9f05afb0086734c770fa
prerequisite-patch-id: 67a600dbc806b7426a5f48b11413d3716d4729e5
prerequisite-patch-id: 86db1a90ea3b2e47a0e082b33d4f9ee5c79782e4
prerequisite-patch-id: dffc8a4bbcf134bf21a86cd197deefe5143b7210
prerequisite-patch-id: d1dea459f43a2541077a882c3282b806a7dd5ecc
prerequisite-patch-id: 0c8a54b1f9bf053b817e949eb82538e7a0630d01
prerequisite-patch-id: 4582389780efd509f9713da8c161f497f2d89bc8
--
2.39.5
^ permalink raw reply [flat|nested] 5+ messages in thread
* [RFC PATCH 1/4] drm/bridge: Add atomic_sro_install_state hook
2026-11-16 14:27 [RFC PATCH 0/4] drm/tilcdc: Implement state readout Màxim Pedraza Padilla
@ 2026-11-16 14:27 ` Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 2/4] drm/panel: Implement state readout in the panel bridge Màxim Pedraza Padilla
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Màxim Pedraza Padilla @ 2026-11-16 14:27 UTC (permalink / raw)
To: Maxime Ripard
Cc: Neil Armstrong, Jessica Zhang, Jyri Sarha, Tomi Valkeinen,
Uwe Kleine-König, Andrzej Hajda, Robert Foss,
Laurent Pinchart, Jonas Karlman, Jernej Skrabec, Luca Ceresoli,
Maarten Lankhorst, Thomas Zimmermann, David Airlie,
Simona Vetter, dri-devel, linux-kernel
The state readout core lets private objects take the resources needed to
keep the hardware running when the state read out becomes current, but
bridges have no way to use it. A panel left on by the firmware, for one,
would stay marked as disabled.
Add a bridge hook and call it from the bridge private object.
Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Màxim Pedraza Padilla <maximpedraza@gmail.com>
---
drivers/gpu/drm/drm_bridge.c | 12 ++++++++++++
include/drm/drm_bridge.h | 12 ++++++++++++
2 files changed, 24 insertions(+)
diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c
index 45a34bbb8f14..cdfd6d44c8d5 100644
--- a/drivers/gpu/drm/drm_bridge.c
+++ b/drivers/gpu/drm/drm_bridge.c
@@ -629,6 +629,17 @@ drm_bridge_atomic_readout_priv_state(struct drm_private_obj *obj,
return 0;
}
+static void
+drm_bridge_atomic_install_priv_state(struct drm_private_obj *obj,
+ struct drm_private_state *state)
+{
+ struct drm_bridge *bridge = drm_priv_to_bridge(obj);
+
+ if (bridge->funcs->atomic_sro_install_state)
+ bridge->funcs->atomic_sro_install_state(bridge,
+ drm_priv_to_bridge_state(state));
+}
+
static bool drm_bridge_atomic_compare_priv_state(struct drm_private_obj *obj,
struct drm_printer *p,
struct drm_private_state *a,
@@ -674,6 +685,7 @@ static const struct drm_private_state_funcs drm_bridge_priv_state_funcs = {
static const struct drm_private_state_funcs drm_bridge_priv_state_funcs_with_sro = {
.atomic_sro_compare_state = drm_bridge_atomic_compare_priv_state,
.atomic_sro_readout_state = drm_bridge_atomic_readout_priv_state,
+ .atomic_sro_install_state = drm_bridge_atomic_install_priv_state,
.atomic_create_state = drm_bridge_atomic_create_priv_state,
.atomic_duplicate_state = drm_bridge_atomic_duplicate_priv_state,
.atomic_destroy_state = drm_bridge_atomic_destroy_priv_state,
diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h
index b73f3424ed62..630af5b3fcf2 100644
--- a/include/drm/drm_bridge.h
+++ b/include/drm/drm_bridge.h
@@ -967,6 +967,18 @@ struct drm_bridge_funcs {
struct drm_atomic_sro_state *state,
struct drm_connector_state *conn_state);
+ /**
+ * @atomic_sro_install_state:
+ *
+ * This optional hook is called when the state read out from the
+ * hardware becomes the current state of the bridge, once the CRTCs
+ * and planes have been installed. It gives the bridge a chance to
+ * take the resources needed to keep the hardware running. It can't
+ * fail.
+ */
+ void (*atomic_sro_install_state)(struct drm_bridge *bridge,
+ struct drm_bridge_state *state);
+
/**
* @debugfs_init:
*
--
2.39.5
^ permalink raw reply [flat|nested] 5+ messages in thread
* [RFC PATCH 2/4] drm/panel: Implement state readout in the panel bridge
2026-11-16 14:27 [RFC PATCH 0/4] drm/tilcdc: Implement state readout Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 1/4] drm/bridge: Add atomic_sro_install_state hook Màxim Pedraza Padilla
@ 2026-11-16 14:27 ` Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 3/4] drm/tilcdc: Implement state readout support Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 4/4] drm/panel: simple: Keep the enable GPIO as left by the bootloader Màxim Pedraza Padilla
3 siblings, 0 replies; 5+ messages in thread
From: Màxim Pedraza Padilla @ 2026-11-16 14:27 UTC (permalink / raw)
To: Maxime Ripard
Cc: Neil Armstrong, Jessica Zhang, Jyri Sarha, Tomi Valkeinen,
Uwe Kleine-König, Andrzej Hajda, Robert Foss,
Laurent Pinchart, Jonas Karlman, Jernej Skrabec, Luca Ceresoli,
Maarten Lankhorst, Thomas Zimmermann, David Airlie,
Simona Vetter, dri-devel, linux-kernel
The state readout core gives up if a private object doesn't implement
readout, so a driver using a panel bridge can't adopt the firmware state,
even if it implements readout itself.
A panel has no state to read back: it's part of the pipeline if the CRTC
feeding its encoder is active. Implement the connector and bridge readout
on that assumption, relying on the encoder's
atomic_sro_get_current_crtc hook, and fill the bus configuration with what
the commit negotiation would give.
When the state is installed, prepare and enable the panel, since nothing
else would until the first modeset.
Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Màxim Pedraza Padilla <maximpedraza@gmail.com>
---
drivers/gpu/drm/drm_panel.c | 92 ++++++++++++++++++++++++++++++++++++-
1 file changed, 91 insertions(+), 1 deletion(-)
diff --git a/drivers/gpu/drm/drm_panel.c b/drivers/gpu/drm/drm_panel.c
index c00529bfb706..7cee228f798b 100644
--- a/drivers/gpu/drm/drm_panel.c
+++ b/drivers/gpu/drm/drm_panel.c
@@ -9,10 +9,14 @@
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/export.h>
+#include <linux/media-bus-format.h>
#include <linux/module.h>
#include <linux/of.h>
+#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
+#include <drm/drm_atomic_state_readout.h>
+#include <drm/drm_atomic_state_readout_helper.h>
#include <drm/drm_bridge.h>
#include <drm/drm_connector.h>
#include <drm/drm_crtc.h>
@@ -216,6 +220,88 @@ static void panel_bridge_debugfs_init(struct drm_bridge *bridge,
panel->funcs->debugfs_init(panel, root);
}
+/*
+ * A panel has no state to read back: it's part of the pipeline if the CRTC
+ * feeding its encoder is active.
+ */
+static int panel_bridge_connector_readout(struct drm_bridge *bridge,
+ struct drm_atomic_sro_state *state,
+ struct drm_connector_state *conn_state)
+{
+ struct drm_connector *connector = conn_state->connector;
+ struct drm_encoder *encoder = bridge->encoder;
+ struct drm_crtc_state *crtc_state;
+ struct drm_crtc *crtc;
+
+ if (!encoder->funcs || !encoder->funcs->atomic_sro_get_current_crtc)
+ return -ENODEV;
+
+ crtc = encoder->funcs->atomic_sro_get_current_crtc(encoder);
+ if (!crtc)
+ return -ENODEV;
+
+ crtc_state = drm_atomic_sro_get_crtc_state(state, crtc);
+ if (!crtc_state)
+ return -ENODEV;
+
+ if (!crtc_state->active)
+ return 0;
+
+ crtc_state->encoder_mask |= drm_encoder_mask(encoder);
+ crtc_state->connector_mask |= drm_connector_mask(connector);
+
+ /* Released by __drm_atomic_helper_connector_destroy_state(). */
+ drm_connector_get(connector);
+ conn_state->crtc = crtc;
+ conn_state->best_encoder = encoder;
+
+ return 0;
+}
+
+/*
+ * Same result as the bus format negotiation of a commit, which doesn't run
+ * during readout: the panel asks for its first format and flags, and passes
+ * them on through drm_atomic_helper_bridge_propagate_bus_fmt().
+ */
+static int panel_bridge_readout_state(struct drm_bridge *bridge,
+ struct drm_atomic_sro_state *state,
+ struct drm_bridge_state *bridge_state,
+ struct drm_crtc_state *crtc_state,
+ struct drm_connector_state *conn_state)
+{
+ const struct drm_display_info *di = &conn_state->connector->display_info;
+ u32 format = di->num_bus_formats ? di->bus_formats[0] : MEDIA_BUS_FMT_FIXED;
+
+ bridge_state->input_bus_cfg.format = format;
+ bridge_state->input_bus_cfg.flags = di->bus_flags;
+ bridge_state->output_bus_cfg.format = format;
+ bridge_state->output_bus_cfg.flags = di->bus_flags;
+
+ return 0;
+}
+
+/*
+ * The firmware left the pipeline running, so the panel is taken as part of it.
+ * Without this it would stay off until the first modeset.
+ */
+static void panel_bridge_install_state(struct drm_bridge *bridge,
+ struct drm_bridge_state *state)
+{
+ struct drm_panel *panel = drm_bridge_to_panel(bridge);
+ struct drm_encoder *encoder = bridge->encoder;
+ struct drm_crtc *crtc;
+
+ if (!encoder->funcs || !encoder->funcs->atomic_sro_get_current_crtc)
+ return;
+
+ crtc = encoder->funcs->atomic_sro_get_current_crtc(encoder);
+ if (!crtc || !crtc->state->active)
+ return;
+
+ drm_panel_prepare(panel);
+ drm_panel_enable(panel);
+}
+
static const struct drm_bridge_funcs panel_bridge_bridge_funcs = {
.attach = panel_bridge_attach,
.detach = panel_bridge_detach,
@@ -228,6 +314,10 @@ static const struct drm_bridge_funcs panel_bridge_bridge_funcs = {
.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
.atomic_get_input_bus_fmts = drm_atomic_helper_bridge_propagate_bus_fmt,
+ .atomic_sro_readout_state = panel_bridge_readout_state,
+ .atomic_sro_compare_state = drm_atomic_helper_bridge_compare_state,
+ .atomic_sro_connector_readout = panel_bridge_connector_readout,
+ .atomic_sro_install_state = panel_bridge_install_state,
.debugfs_init = panel_bridge_debugfs_init,
};
@@ -600,7 +690,7 @@ void drm_panel_add(struct drm_panel *panel)
mutex_unlock(&panel_lock);
panel->bridge.of_node = panel->dev->of_node;
- panel->bridge.ops = DRM_BRIDGE_OP_MODES;
+ panel->bridge.ops = DRM_BRIDGE_OP_MODES | DRM_BRIDGE_OP_CONNECTOR_HW_READOUT;
panel->bridge.type = panel->connector_type;
panel->bridge.pre_enable_prev_first = panel->prepare_prev_first;
--
2.39.5
^ permalink raw reply [flat|nested] 5+ messages in thread
* [RFC PATCH 3/4] drm/tilcdc: Implement state readout support
2026-11-16 14:27 [RFC PATCH 0/4] drm/tilcdc: Implement state readout Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 1/4] drm/bridge: Add atomic_sro_install_state hook Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 2/4] drm/panel: Implement state readout in the panel bridge Màxim Pedraza Padilla
@ 2026-11-16 14:27 ` Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 4/4] drm/panel: simple: Keep the enable GPIO as left by the bootloader Màxim Pedraza Padilla
3 siblings, 0 replies; 5+ messages in thread
From: Màxim Pedraza Padilla @ 2026-11-16 14:27 UTC (permalink / raw)
To: Maxime Ripard
Cc: Neil Armstrong, Jessica Zhang, Jyri Sarha, Tomi Valkeinen,
Uwe Kleine-König, Andrzej Hajda, Robert Foss,
Laurent Pinchart, Jonas Karlman, Jernej Skrabec, Luca Ceresoli,
Maarten Lankhorst, Thomas Zimmermann, David Airlie,
Simona Vetter, dri-devel, linux-kernel
Reconstruct the display mode from the LCDC raster registers and read out
the primary plane, to build the initial KMS state from what the bootloader
left scanning out instead of resetting the controller. A splash drawn
before Linux takes over stays on screen, and the first commit replaces it,
with no modeset if it keeps the mode.
The registers don't record everything:
- The channel order isn't stored, so RGB is reported for the adopted
framebuffer. It doesn't change what's on screen.
- tilcdc_crtc_mode_fixup() is undone to get the requested mode, but a
positive sync can't be told from a mode that doesn't specify it. Such a
mode will be reported as different by the post-commit comparison.
If the raster isn't running there's nothing to adopt, and the CRTC and the
plane are read out as disabled.
Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Màxim Pedraza Padilla <maximpedraza@gmail.com>
---
drivers/gpu/drm/tilcdc/tilcdc_crtc.c | 173 ++++++++++++++++++++++++
drivers/gpu/drm/tilcdc/tilcdc_drv.c | 22 ++-
drivers/gpu/drm/tilcdc/tilcdc_encoder.c | 29 +++-
drivers/gpu/drm/tilcdc/tilcdc_plane.c | 106 +++++++++++++++
4 files changed, 325 insertions(+), 5 deletions(-)
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_crtc.c b/drivers/gpu/drm/tilcdc/tilcdc_crtc.c
index f619b7a6e70d..d5c34763bd96 100644
--- a/drivers/gpu/drm/tilcdc/tilcdc_crtc.c
+++ b/drivers/gpu/drm/tilcdc/tilcdc_crtc.c
@@ -4,6 +4,7 @@
* Author: Rob Clark <robdclark@gmail.com>
*/
+#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/of_graph.h>
@@ -11,6 +12,8 @@
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
+#include <drm/drm_atomic_state_readout_helper.h>
+#include <drm/drm_atomic_uapi.h>
#include <drm/drm_crtc.h>
#include <drm/drm_fb_dma_helper.h>
#include <drm/drm_fourcc.h>
@@ -711,10 +714,180 @@ static void tilcdc_crtc_hw_reset(struct drm_crtc *crtc)
pm_runtime_put_sync(dev->dev);
}
+/*
+ * Reconstruct the adjusted mode from the LCDC raster registers. This is the
+ * inverse of the register programming done in tilcdc_crtc_set_mode(): the
+ * horizontal front/back porch and sync width are stored as (value - 1), the
+ * pixels-per-line and lines-per-panel as (value - 1) as well, while the
+ * vertical front/back porch are stored verbatim. On the V2 controller a few
+ * high order bits live in RASTER_TIMING_2.
+ *
+ * tilcdc_crtc_mode_fixup() always sets a HSYNC polarity and the skew, so they
+ * can be told from the registers. A positive VSYNC can't be told from a mode
+ * that doesn't specify it: the latter is assumed.
+ */
+static int tilcdc_crtc_readout_mode(struct drm_crtc *crtc,
+ struct drm_display_mode *mode)
+{
+ struct drm_device *dev = crtc->dev;
+ struct tilcdc_drm_private *priv = ddev_to_tilcdc_priv(dev);
+ u32 t0, t1, t2, ctrl;
+ u32 ppl, hsw, hfp, hbp;
+ u32 lpp, vsw, vfp, vbp;
+ unsigned long clk_rate;
+ unsigned int clkdiv;
+
+ t0 = tilcdc_read(dev, LCDC_RASTER_TIMING_0_REG);
+ t1 = tilcdc_read(dev, LCDC_RASTER_TIMING_1_REG);
+ t2 = tilcdc_read(dev, LCDC_RASTER_TIMING_2_REG);
+ ctrl = tilcdc_read(dev, LCDC_CTRL_REG);
+
+ /* Horizontal fields, low bits in TIMING_0, V2 high bits in TIMING_2. */
+ ppl = (t0 >> 4) & 0x3f;
+ hsw = (t0 >> 10) & 0x3f;
+ hfp = (t0 >> 16) & 0xff;
+ hbp = (t0 >> 24) & 0xff;
+ if (priv->rev == 2) {
+ ppl |= ((t0 >> 3) & 0x1) << 6;
+ hsw |= ((t2 >> 27) & 0xf) << 6;
+ hfp |= (t2 & 0x3) << 8;
+ hbp |= ((t2 >> 4) & 0x3) << 8;
+ }
+ mode->hdisplay = (ppl + 1) << 4;
+ hsw += 1;
+ hfp += 1;
+ hbp += 1;
+
+ /* Vertical fields, LPP high bit in TIMING_2 on V2. */
+ lpp = t1 & 0x3ff;
+ if (priv->rev == 2 && (t2 & LCDC_LPP_B10))
+ lpp |= 0x400;
+ vsw = ((t1 >> 10) & 0x3f) + 1;
+ vfp = (t1 >> 16) & 0xff;
+ vbp = (t1 >> 24) & 0xff;
+ mode->vdisplay = lpp + 1;
+
+ mode->hsync_start = mode->hdisplay + hfp;
+ mode->hsync_end = mode->hsync_start + hsw;
+ mode->htotal = mode->hsync_end + hbp;
+
+ mode->vsync_start = mode->vdisplay + vfp;
+ mode->vsync_end = mode->vsync_start + vsw;
+ mode->vtotal = mode->vsync_end + vbp;
+
+ /* Pixel clock is the functional clock divided by the CTRL divisor. */
+ clkdiv = (ctrl & LCDC_CLK_DIVISOR_MASK) >> 8;
+ clk_rate = clk_get_rate(priv->clk);
+ if (!clkdiv || !clk_rate)
+ return -EINVAL;
+ mode->clock = (clk_rate / clkdiv) / 1000;
+
+ mode->flags |= t2 & LCDC_INVERT_HSYNC ? DRM_MODE_FLAG_NHSYNC :
+ DRM_MODE_FLAG_PHSYNC;
+ if (t2 & LCDC_INVERT_VSYNC)
+ mode->flags |= DRM_MODE_FLAG_NVSYNC;
+
+ mode->hskew = hsw;
+ mode->flags |= DRM_MODE_FLAG_HSKEW;
+
+ mode->type |= DRM_MODE_TYPE_DRIVER;
+ drm_mode_set_name(mode);
+ drm_mode_set_crtcinfo(mode, 0);
+
+ return 0;
+}
+
+static int tilcdc_crtc_readout_state(struct drm_crtc *crtc,
+ struct drm_atomic_sro_state *state,
+ struct drm_crtc_state *crtc_state)
+{
+ struct drm_device *dev = crtc->dev;
+ struct drm_display_mode adjusted = {}, mode;
+ int ret;
+
+ pm_runtime_get_sync(dev->dev);
+
+ /* Nothing to adopt unless the bootloader left the raster running. */
+ if (!(tilcdc_read(dev, LCDC_RASTER_CTRL_REG) & LCDC_RASTER_ENABLE))
+ goto out;
+
+ ret = tilcdc_crtc_readout_mode(crtc, &adjusted);
+ if (ret)
+ goto err;
+
+ /* Undo tilcdc_crtc_mode_fixup(). */
+ drm_mode_copy(&mode, &adjusted);
+ mode.hskew = 0;
+ mode.flags &= ~(DRM_MODE_FLAG_HSKEW | DRM_MODE_FLAG_NHSYNC |
+ DRM_MODE_FLAG_PHSYNC);
+ if (adjusted.flags & DRM_MODE_FLAG_PHSYNC)
+ mode.flags |= DRM_MODE_FLAG_NHSYNC;
+
+ ret = drm_atomic_set_mode_for_crtc(crtc_state, &mode);
+ if (WARN_ON(ret))
+ goto err;
+
+ drm_mode_copy(&crtc_state->adjusted_mode, &adjusted);
+
+ crtc_state->active = true;
+ crtc_state->enable = true;
+
+ /* The active plane is filled in by tilcdc_plane_readout_state(). */
+
+out:
+ pm_runtime_put_sync(dev->dev);
+ return 0;
+
+err:
+ pm_runtime_put_sync(dev->dev);
+ return ret;
+}
+
+static void tilcdc_crtc_install_state(struct drm_crtc *crtc,
+ struct drm_crtc_state *crtc_state)
+{
+ struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
+ struct drm_device *dev = crtc->dev;
+ struct tilcdc_drm_private *priv = ddev_to_tilcdc_priv(dev);
+
+ if (!crtc_state->active)
+ return;
+
+ /*
+ * The display is already scanning out the bootloader's image. Do what
+ * tilcdc_crtc_enable() and tilcdc_crtc_set_mode() would have done,
+ * without touching the raster: keep the controller powered, enable its
+ * interrupts and fill in the software state derived from the mode. A
+ * commit that doesn't change the mode relies on it, since no modeset
+ * will update it: set_scanout() uses crtc->mode for the DMA ceiling.
+ */
+ pm_runtime_get_sync(dev->dev);
+
+ mutex_lock(&tilcdc_crtc->enable_lock);
+
+ drm_mode_copy(&crtc->mode, &crtc_state->mode);
+ drm_mode_copy(&crtc->hwmode, &crtc_state->adjusted_mode);
+ crtc->enabled = true;
+ tilcdc_crtc->hvtotal_us = tilcdc_mode_hvtotal(&crtc->hwmode);
+ tilcdc_crtc->lcd_fck_rate = clk_get_rate(priv->clk);
+ tilcdc_crtc->last_vblank = ktime_get();
+
+ tilcdc_crtc_enable_irqs(dev);
+
+ drm_calc_timestamping_constants(crtc, &crtc->hwmode);
+ drm_crtc_vblank_on(crtc);
+
+ tilcdc_crtc->enabled = true;
+ mutex_unlock(&tilcdc_crtc->enable_lock);
+}
+
static const struct drm_crtc_funcs tilcdc_crtc_funcs = {
.set_config = drm_atomic_helper_set_config,
.page_flip = drm_atomic_helper_page_flip,
.atomic_create_state = drm_atomic_helper_crtc_create_state,
+ .atomic_sro_readout_state = tilcdc_crtc_readout_state,
+ .atomic_sro_install_state = tilcdc_crtc_install_state,
+ .atomic_sro_compare_state = drm_atomic_helper_crtc_compare_state,
.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
.enable_vblank = tilcdc_crtc_enable_vblank,
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_drv.c b/drivers/gpu/drm/tilcdc/tilcdc_drv.c
index 1d6c9a423a41..ab88632919fa 100644
--- a/drivers/gpu/drm/tilcdc/tilcdc_drv.c
+++ b/drivers/gpu/drm/tilcdc/tilcdc_drv.c
@@ -12,6 +12,8 @@
#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic_helper.h>
+#include <drm/drm_atomic_state_readout.h>
+#include <drm/drm_atomic_state_readout_helper.h>
#include <drm/drm_debugfs.h>
#include <drm/drm_drv.h>
#include <drm/drm_fbdev_dma.h>
@@ -75,6 +77,12 @@ static const struct drm_mode_config_funcs mode_config_funcs = {
.fb_create = drm_gem_fb_create,
.atomic_check = tilcdc_atomic_check,
.atomic_commit = drm_atomic_helper_commit,
+ .atomic_sro_readout_state = drm_atomic_helper_sro_readout_state,
+ .hw_reset = drm_mode_config_helper_hw_reset,
+};
+
+static const struct drm_mode_config_helper_funcs mode_config_helper_funcs = {
+ .atomic_sro_build_state = drm_atomic_helper_sro_build_state,
};
static void modeset_init(struct drm_device *dev)
@@ -86,6 +94,7 @@ static void modeset_init(struct drm_device *dev)
dev->mode_config.max_width = priv->max_width;
dev->mode_config.max_height = 2048;
dev->mode_config.funcs = &mode_config_funcs;
+ dev->mode_config.helper_private = &mode_config_helper_funcs;
}
#ifdef CONFIG_CPU_FREQ
@@ -422,10 +431,19 @@ static int tilcdc_pdev_probe(struct platform_device *pdev)
goto unregister_cpufreq_notif;
}
- drm_mode_config_reset(ddev);
-
drm_kms_helper_poll_init(ddev);
+ /*
+ * Build the initial state from whatever the bootloader left running,
+ * instead of resetting the controller, so a splash drawn before Linux
+ * takes over is adopted rather than blanked.
+ */
+ ret = drm_mode_config_create_initial_state(ddev);
+ if (ret) {
+ drm_err(ddev, "failed to create initial state: %d\n", ret);
+ goto stop_poll;
+ }
+
ret = drm_dev_register(ddev, 0);
if (ret)
goto stop_poll;
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_encoder.c b/drivers/gpu/drm/tilcdc/tilcdc_encoder.c
index ac4b5beb2dd5..b3fe18f69f17 100644
--- a/drivers/gpu/drm/tilcdc/tilcdc_encoder.c
+++ b/drivers/gpu/drm/tilcdc/tilcdc_encoder.c
@@ -9,12 +9,34 @@
#include <drm/drm_atomic_helper.h>
#include <drm/drm_bridge.h>
#include <drm/drm_bridge_connector.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_encoder.h>
#include <drm/drm_of.h>
-#include <drm/drm_simple_kms_helper.h>
#include "tilcdc_drv.h"
#include "tilcdc_encoder.h"
+/*
+ * State readout needs to know which CRTC drives this encoder so the connector
+ * can be tied back to it. tilcdc has a single CRTC, so return the one the
+ * encoder was made possible for.
+ */
+static struct drm_crtc *
+tilcdc_encoder_get_current_crtc(struct drm_encoder *encoder)
+{
+ struct drm_crtc *crtc;
+
+ drm_for_each_crtc(crtc, encoder->dev)
+ if (encoder->possible_crtcs == drm_crtc_mask(crtc))
+ return crtc;
+
+ return NULL;
+}
+
+static const struct drm_encoder_funcs tilcdc_encoder_funcs = {
+ .atomic_sro_get_current_crtc = tilcdc_encoder_get_current_crtc,
+};
+
static
int tilcdc_attach_bridge(struct drm_device *ddev, struct drm_bridge *bridge)
{
@@ -51,8 +73,9 @@ int tilcdc_encoder_create(struct drm_device *ddev)
else if (IS_ERR(bridge))
return PTR_ERR(bridge);
- encoder = drmm_simple_encoder_alloc(ddev, struct tilcdc_encoder,
- base, DRM_MODE_ENCODER_NONE);
+ encoder = drmm_encoder_alloc(ddev, struct tilcdc_encoder, base,
+ &tilcdc_encoder_funcs,
+ DRM_MODE_ENCODER_NONE, NULL);
if (IS_ERR(encoder)) {
drm_err(ddev, "drm_encoder_init() failed %pe\n", encoder);
return PTR_ERR(encoder);
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_plane.c b/drivers/gpu/drm/tilcdc/tilcdc_plane.c
index eb0a5562421f..63d936d8cfc6 100644
--- a/drivers/gpu/drm/tilcdc/tilcdc_plane.c
+++ b/drivers/gpu/drm/tilcdc/tilcdc_plane.c
@@ -4,17 +4,123 @@
* Author: Jyri Sarha <jsarha@ti.com>
*/
+#include <linux/pm_runtime.h>
+
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
+#include <drm/drm_atomic_state_readout.h>
+#include <drm/drm_atomic_state_readout_helper.h>
+#include <drm/drm_crtc.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_framebuffer.h>
+#include <drm/drm_gem_framebuffer_helper.h>
#include "tilcdc_drv.h"
+#include "tilcdc_regs.h"
+
+static const struct drm_framebuffer_funcs tilcdc_plane_readout_fb_funcs = {
+ .destroy = drm_gem_fb_destroy,
+};
+
+/*
+ * The RASTER_CTRL format bits only encode the pixel depth, not the channel
+ * order, so the RGB/BGR ambiguity is resolved in favour of the RGB variant.
+ * The panel wiring decides the actual order, so this only affects the format
+ * reported for the adopted framebuffer.
+ */
+static u32 tilcdc_plane_readout_format(struct drm_device *dev)
+{
+ u32 ctrl = tilcdc_read(dev, LCDC_RASTER_CTRL_REG);
+
+ if (!(ctrl & LCDC_V2_TFT_24BPP_MODE))
+ return DRM_FORMAT_RGB565;
+ if (ctrl & LCDC_V2_TFT_24BPP_UNPACK)
+ return DRM_FORMAT_XRGB8888;
+ return DRM_FORMAT_RGB888;
+}
+
+static int tilcdc_plane_atomic_readout_state(struct drm_plane *plane,
+ struct drm_atomic_sro_state *state,
+ struct drm_plane_state *plane_state)
+{
+ struct drm_device *dev = plane->dev;
+ const struct drm_format_info *info;
+ struct drm_crtc_state *crtc_state;
+ struct drm_framebuffer *fb;
+ struct drm_crtc *crtc;
+ unsigned int w, h;
+ int ret;
+
+ pm_runtime_get_sync(dev->dev);
+
+ if (!(tilcdc_read(dev, LCDC_RASTER_CTRL_REG) & LCDC_RASTER_ENABLE))
+ goto out;
+
+ if (dev->num_crtcs != 1) {
+ ret = -EINVAL;
+ goto err;
+ }
+ crtc = list_first_entry(&dev->mode_config.crtc_list, struct drm_crtc,
+ head);
+
+ crtc_state = drm_atomic_sro_get_crtc_state(state, crtc);
+ if (!crtc_state) {
+ ret = -ENODEV;
+ goto err;
+ }
+
+ /* The tilcdc primary plane always covers the whole active area. */
+ w = crtc_state->adjusted_mode.hdisplay;
+ h = crtc_state->adjusted_mode.vdisplay;
+
+ info = drm_format_info(tilcdc_plane_readout_format(dev));
+ if (!info) {
+ ret = -EINVAL;
+ goto err;
+ }
+
+ fb = kzalloc_obj(*fb);
+ if (!fb) {
+ ret = -ENOMEM;
+ goto err;
+ }
+ fb->dev = dev;
+ fb->format = info;
+ fb->width = w;
+ fb->height = h;
+ fb->pitches[0] = w * (drm_format_info_bpp(info, 0) / 8);
+ fb->offsets[0] = 0;
+
+ ret = drm_framebuffer_init(dev, fb, &tilcdc_plane_readout_fb_funcs);
+ if (ret) {
+ kfree(fb);
+ goto err;
+ }
+
+ plane_state->fb = fb;
+ plane_state->crtc = crtc;
+ plane_state->src_w = w << 16;
+ plane_state->src_h = h << 16;
+ plane_state->crtc_w = w;
+ plane_state->crtc_h = h;
+
+ crtc_state->plane_mask |= drm_plane_mask(plane);
+
+out:
+ pm_runtime_put_sync(dev->dev);
+ return 0;
+
+err:
+ pm_runtime_put_sync(dev->dev);
+ return ret;
+}
static const struct drm_plane_funcs tilcdc_plane_funcs = {
.update_plane = drm_atomic_helper_update_plane,
.disable_plane = drm_atomic_helper_disable_plane,
.atomic_create_state = drm_atomic_helper_plane_create_state,
+ .atomic_sro_readout_state = tilcdc_plane_atomic_readout_state,
+ .atomic_sro_compare_state = drm_atomic_helper_plane_compare_state,
.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
};
--
2.39.5
^ permalink raw reply [flat|nested] 5+ messages in thread
* [RFC PATCH 4/4] drm/panel: simple: Keep the enable GPIO as left by the bootloader
2026-11-16 14:27 [RFC PATCH 0/4] drm/tilcdc: Implement state readout Màxim Pedraza Padilla
` (2 preceding siblings ...)
2026-11-16 14:27 ` [RFC PATCH 3/4] drm/tilcdc: Implement state readout support Màxim Pedraza Padilla
@ 2026-11-16 14:27 ` Màxim Pedraza Padilla
3 siblings, 0 replies; 5+ messages in thread
From: Màxim Pedraza Padilla @ 2026-11-16 14:27 UTC (permalink / raw)
To: Maxime Ripard
Cc: Neil Armstrong, Jessica Zhang, Jyri Sarha, Tomi Valkeinen,
Uwe Kleine-König, Andrzej Hajda, Robert Foss,
Laurent Pinchart, Jonas Karlman, Jernej Skrabec, Luca Ceresoli,
Maarten Lankhorst, Thomas Zimmermann, David Airlie,
Simona Vetter, dri-devel, linux-kernel
The enable GPIO is requested as output low at probe, which turns the
panel off and blanks a splash screen the bootloader left on it, even
when the display state is read out and kept.
Request it with GPIOD_ASIS instead, and set it as output when the panel
is powered up, since it may still be an input if the bootloader didn't
touch it.
Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Màxim Pedraza Padilla <maximpedraza@gmail.com>
---
drivers/gpu/drm/panel/panel-simple.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c
index a944c34642dc..9d2aa4d16f97 100644
--- a/drivers/gpu/drm/panel/panel-simple.c
+++ b/drivers/gpu/drm/panel/panel-simple.c
@@ -341,7 +341,7 @@ static int panel_simple_resume(struct device *dev)
return err;
}
- gpiod_set_value_cansleep(p->enable_gpio, 1);
+ gpiod_direction_output(p->enable_gpio, 1);
if (p->desc->delay.prepare)
msleep(p->desc->delay.prepare);
@@ -688,7 +688,7 @@ static struct panel_simple *panel_simple_probe(struct device *dev)
return ERR_CAST(panel->supply);
panel->enable_gpio = devm_gpiod_get_optional(dev, "enable",
- GPIOD_OUT_LOW);
+ GPIOD_ASIS);
if (IS_ERR(panel->enable_gpio))
return dev_err_cast_probe(dev, panel->enable_gpio,
"failed to request GPIO\n");
--
2.39.5
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-16 13:27 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-16 14:27 [RFC PATCH 0/4] drm/tilcdc: Implement state readout Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 1/4] drm/bridge: Add atomic_sro_install_state hook Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 2/4] drm/panel: Implement state readout in the panel bridge Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 3/4] drm/tilcdc: Implement state readout support Màxim Pedraza Padilla
2026-11-16 14:27 ` [RFC PATCH 4/4] drm/panel: simple: Keep the enable GPIO as left by the bootloader Màxim Pedraza Padilla
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®