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 --]
next prev parent 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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.