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