The Linux Kernel Mailing List
 help / color / mirror / Atom feed
From: Maxime Ripard <mripard@kernel.org>
To: "Màxim Pedraza Padilla" <maximpedraza@gmail.com>
Cc: "Neil Armstrong" <neil.armstrong@linaro.org>,
	"Jessica Zhang" <jesszhan0024@gmail.com>,
	"Jyri Sarha" <jyri.sarha@iki.fi>,
	"Tomi Valkeinen" <tomi.valkeinen@ideasonboard.com>,
	"Uwe Kleine-König" <ukleinek@kernel.org>,
	"Andrzej Hajda" <andrzej.hajda@intel.com>,
	"Robert Foss" <rfoss@kernel.org>,
	"Laurent Pinchart" <Laurent.pinchart@ideasonboard.com>,
	"Jonas Karlman" <jonas@kwiboo.se>,
	"Jernej Skrabec" <jernej.skrabec@gmail.com>,
	"Luca Ceresoli" <luca.ceresoli@bootlin.com>,
	"Maarten Lankhorst" <maarten.lankhorst@linux.intel.com>,
	"Thomas Zimmermann" <tzimmermann@suse.de>,
	"David Airlie" <airlied@gmail.com>,
	"Simona Vetter" <simona@ffwll.ch>,
	dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org
Subject: Re: [RFC PATCH 3/4] drm/tilcdc: Implement state readout support
Date: Mon, 16 Nov 2026 18:12:50 +0100	[thread overview]
Message-ID: <avs2dagfmQkv00H0@houat> (raw)
In-Reply-To: <20261116142707.1299360-4-maximpedraza@gmail.com>

[-- Attachment #1: Type: text/plain, Size: 17575 bytes --]

On Mon, Nov 16, 2026 at 03:27:06PM +0100, Màxim Pedraza Padilla wrote:
> 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.

You mean RGB vs BGR? It's not available anywhere in a register?

> - 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.

That's suprising as well, the polairity of signals is typically stored
somewhere in a register.

> 
> 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;

You need to give some leeway there. It's unlikely you'll ever going to
be an exact match for the mode being used due to clock rounding.

tilcdc_crtc_set_clk allows for a 5% (I think?) difference for example.

We handle that in tidss by looking for the closest rate match and see if
it falls into the specified tolerance
(dispc_find_closest_refresh_rate_from_clk). I always thought of it as
something that could be turned into a helper, and it's what you should
be using here.

> +	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);

The adjusted_mode handling should be fixed with v8 as well.

> +	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;
> +	}
> +

That part is
https://lore.kernel.org/all/20261116-drm-no-more-config-reset-v2-43-0bb471f4d1e0@kernel.org/
with hw_reset that sashiko pointed out

It should really be there, but there's a circular dependency at the
moment between these two series that I'm not quite sure how to solve.

Hopefully, we will be able to merge the tidss create_initial_state
conversion and break that circular dependency.

Maxime

>  	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
> 

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 269 bytes --]

  reply	other threads:[~2026-11-16 17:12 UTC|newest]

Thread overview: 9+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
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 16:58   ` Maxime Ripard
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 16:59   ` Maxime Ripard
2026-11-16 14:27 ` [RFC PATCH 3/4] drm/tilcdc: Implement state readout support Màxim Pedraza Padilla
2026-11-16 17:12   ` Maxime Ripard [this message]
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
2026-11-16 16:50 ` [RFC PATCH 0/4] drm/tilcdc: Implement state readout Maxime Ripard

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=avs2dagfmQkv00H0@houat \
    --to=mripard@kernel.org \
    --cc=Laurent.pinchart@ideasonboard.com \
    --cc=airlied@gmail.com \
    --cc=andrzej.hajda@intel.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=jernej.skrabec@gmail.com \
    --cc=jesszhan0024@gmail.com \
    --cc=jonas@kwiboo.se \
    --cc=jyri.sarha@iki.fi \
    --cc=linux-kernel@vger.kernel.org \
    --cc=luca.ceresoli@bootlin.com \
    --cc=maarten.lankhorst@linux.intel.com \
    --cc=maximpedraza@gmail.com \
    --cc=neil.armstrong@linaro.org \
    --cc=rfoss@kernel.org \
    --cc=simona@ffwll.ch \
    --cc=tomi.valkeinen@ideasonboard.com \
    --cc=tzimmermann@suse.de \
    --cc=ukleinek@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox