On Fri, Aug 15, 2025 at 12:40:43AM +0800, Icenowy Zheng wrote:
> This is a from-scratch driver targeting Verisilicon DC-series display
> controllers, which feature self-identification functionality like their
> GC-series GPUs.
> 
> Only DC8200 is being supported now, and only the main framebuffer is set
> up (as the DRM primary plane). Support for more DC models and more
> features is my further targets.
> 
> As the display controller is delivered to SoC vendors as a whole part,
> this driver does not use component framework and extra bridges inside a
> SoC is expected to be implemented as dedicated bridges (this driver
> properly supports bridge chaining).
> 
> Signed-off-by: Icenowy Zheng <u...@icenowy.me>
> ---
>  drivers/gpu/drm/Kconfig                       |   2 +
>  drivers/gpu/drm/Makefile                      |   1 +
>  drivers/gpu/drm/verisilicon/Kconfig           |  15 +
>  drivers/gpu/drm/verisilicon/Makefile          |   5 +
>  drivers/gpu/drm/verisilicon/vs_bridge.c       | 330 ++++++++++++++++++
>  drivers/gpu/drm/verisilicon/vs_bridge.h       |  40 +++
>  drivers/gpu/drm/verisilicon/vs_bridge_regs.h  |  47 +++
>  drivers/gpu/drm/verisilicon/vs_crtc.c         | 217 ++++++++++++
>  drivers/gpu/drm/verisilicon/vs_crtc.h         |  29 ++
>  drivers/gpu/drm/verisilicon/vs_crtc_regs.h    |  60 ++++
>  drivers/gpu/drm/verisilicon/vs_dc.c           | 233 +++++++++++++
>  drivers/gpu/drm/verisilicon/vs_dc.h           |  39 +++
>  drivers/gpu/drm/verisilicon/vs_dc_top_regs.h  |  27 ++
>  drivers/gpu/drm/verisilicon/vs_drm.c          | 177 ++++++++++
>  drivers/gpu/drm/verisilicon/vs_drm.h          |  29 ++
>  drivers/gpu/drm/verisilicon/vs_hwdb.c         | 150 ++++++++
>  drivers/gpu/drm/verisilicon/vs_hwdb.h         |  29 ++
>  drivers/gpu/drm/verisilicon/vs_plane.c        | 102 ++++++
>  drivers/gpu/drm/verisilicon/vs_plane.h        |  68 ++++
>  .../gpu/drm/verisilicon/vs_primary_plane.c    | 166 +++++++++
>  .../drm/verisilicon/vs_primary_plane_regs.h   |  53 +++
>  21 files changed, 1819 insertions(+)
>  create mode 100644 drivers/gpu/drm/verisilicon/Kconfig
>  create mode 100644 drivers/gpu/drm/verisilicon/Makefile
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_bridge.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_bridge.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_bridge_regs.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_crtc.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_crtc.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_crtc_regs.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_dc.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_dc.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_dc_top_regs.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_drm.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_drm.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_hwdb.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_hwdb.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_plane.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_plane.h
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_primary_plane.c
>  create mode 100644 drivers/gpu/drm/verisilicon/vs_primary_plane_regs.h
> 
> diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
> index f7ea8e895c0c0..33601485ecdba 100644
> --- a/drivers/gpu/drm/Kconfig
> +++ b/drivers/gpu/drm/Kconfig
> @@ -396,6 +396,8 @@ source "drivers/gpu/drm/sprd/Kconfig"
>  
>  source "drivers/gpu/drm/imagination/Kconfig"
>  
> +source "drivers/gpu/drm/verisilicon/Kconfig"
> +
>  config DRM_HYPERV
>       tristate "DRM Support for Hyper-V synthetic video device"
>       depends on DRM && PCI && HYPERV
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 4dafbdc8f86ac..32ed4cf9df1bd 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -231,6 +231,7 @@ obj-y                     += solomon/
>  obj-$(CONFIG_DRM_SPRD) += sprd/
>  obj-$(CONFIG_DRM_LOONGSON) += loongson/
>  obj-$(CONFIG_DRM_POWERVR) += imagination/
> +obj-$(CONFIG_DRM_VERISILICON_DC) += verisilicon/
>  
>  # Ensure drm headers are self-contained and pass kernel-doc
>  hdrtest-files := \
> diff --git a/drivers/gpu/drm/verisilicon/Kconfig 
> b/drivers/gpu/drm/verisilicon/Kconfig
> new file mode 100644
> index 0000000000000..0235577c72824
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/Kconfig
> @@ -0,0 +1,15 @@
> +# SPDX-License-Identifier: GPL-2.0-only
> +config DRM_VERISILICON_DC
> +     tristate "DRM Support for Verisilicon DC-series display controllers"
> +     depends on DRM && COMMON_CLK
> +     depends on RISCV || COMPILER_TEST
> +     select DRM_CLIENT_SELECTION
> +     select DRM_GEM_DMA_HELPER
> +     select DRM_KMS_HELPER
> +     select DRM_BRIDGE_CONNECTOR
> +     select REGMAP_MMIO
> +     select VIDEOMODE_HELPERS
> +     help
> +       Choose this option if you have a SoC with Verisilicon DC-series
> +       display controllers. If M is selected, the module will be called
> +       verisilicon-dc.
> diff --git a/drivers/gpu/drm/verisilicon/Makefile 
> b/drivers/gpu/drm/verisilicon/Makefile
> new file mode 100644
> index 0000000000000..fd8d805fbcde1
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/Makefile
> @@ -0,0 +1,5 @@
> +# SPDX-License-Identifier: GPL-2.0-only
> +
> +verisilicon-dc-objs := vs_bridge.o vs_crtc.o vs_dc.o vs_drm.o vs_hwdb.o 
> vs_plane.o vs_primary_plane.o
> +
> +obj-$(CONFIG_DRM_VERISILICON_DC) += verisilicon-dc.o
> diff --git a/drivers/gpu/drm/verisilicon/vs_bridge.c 
> b/drivers/gpu/drm/verisilicon/vs_bridge.c
> new file mode 100644
> index 0000000000000..c8caf31fac7d6
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_bridge.c
> @@ -0,0 +1,330 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/of.h>
> +#include <linux/regmap.h>
> +
> +#include <uapi/linux/media-bus-format.h>
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_bridge.h>
> +#include <drm/drm_bridge_connector.h>
> +#include <drm/drm_connector.h>
> +#include <drm/drm_encoder.h>
> +#include <drm/drm_of.h>
> +#include <drm/drm_print.h>
> +#include <drm/drm_simple_kms_helper.h>
> +
> +#include "vs_bridge.h"
> +#include "vs_bridge_regs.h"
> +#include "vs_crtc.h"
> +#include "vs_dc.h"
> +
> +static int vs_bridge_attach(struct drm_bridge *bridge,
> +                         struct drm_encoder *encoder,
> +                         enum drm_bridge_attach_flags flags)
> +{
> +     struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
> +
> +     return drm_bridge_attach(encoder, vbridge->next,
> +                              bridge, flags);
> +}
> +
> +struct vsdc_dp_format {
> +     u32 linux_fmt;
> +     bool is_yuv;
> +     u32 vsdc_fmt;
> +};
> +
> +static struct vsdc_dp_format vsdc_dp_supported_fmts[] = {
> +     /* default to RGB888 */
> +     { MEDIA_BUS_FMT_FIXED, false, VSDC_DISP_DP_CONFIG_FMT_RGB888 },
> +     { MEDIA_BUS_FMT_RGB888_1X24, false, VSDC_DISP_DP_CONFIG_FMT_RGB888 },
> +     { MEDIA_BUS_FMT_RGB565_1X16, false, VSDC_DISP_DP_CONFIG_FMT_RGB565 },
> +     { MEDIA_BUS_FMT_RGB666_1X18, false, VSDC_DISP_DP_CONFIG_FMT_RGB666 },
> +     { MEDIA_BUS_FMT_RGB888_1X24, false, VSDC_DISP_DP_CONFIG_FMT_RGB888 },
> +     { MEDIA_BUS_FMT_RGB101010_1X30,
> +       false, VSDC_DISP_DP_CONFIG_FMT_RGB101010 },
> +     { MEDIA_BUS_FMT_UYVY8_1X16, true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYVY8 },
> +     { MEDIA_BUS_FMT_UYVY10_1X20, true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYVY10 },
> +     { MEDIA_BUS_FMT_YUV8_1X24, true, VSDC_DISP_DP_CONFIG_YUV_FMT_YUV8 },
> +     { MEDIA_BUS_FMT_YUV10_1X30, true, VSDC_DISP_DP_CONFIG_YUV_FMT_YUV10 },
> +     { MEDIA_BUS_FMT_UYYVYY8_0_5X24,
> +       true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYYVYY8 },
> +     { MEDIA_BUS_FMT_UYYVYY10_0_5X30,
> +       true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYYVYY10 },
> +};
> +
> +static u32 *vs_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge,
> +                                     struct drm_bridge_state *bridge_state,
> +                                     struct drm_crtc_state *crtc_state,
> +                                     struct drm_connector_state *conn_state,
> +                                     unsigned int *num_output_fmts)
> +{
> +     struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
> +     struct drm_connector *conn = conn_state->connector;
> +     u32 *output_fmts;
> +     unsigned int i;
> +
> +     if (vbridge->intf == VSDC_OUTPUT_INTERFACE_DPI)

This kind of checks looks like there should be a drm_encoder handled by
the same driver. Or maybe it's better to have two sets of funcs
structures, one for the DPI, one for DP.

> +             *num_output_fmts = 1;
> +     else
> +             *num_output_fmts = ARRAY_SIZE(vsdc_dp_supported_fmts);
> +
> +     output_fmts = kcalloc(*num_output_fmts, sizeof(*output_fmts),
> +                           GFP_KERNEL);
> +     if (!output_fmts)
> +             return NULL;
> +
> +     if (vbridge->intf == VSDC_OUTPUT_INTERFACE_DPI) {
> +             if (conn->display_info.num_bus_formats &&
> +                 conn->display_info.bus_formats)
> +                     output_fmts[0] = conn->display_info.bus_formats[0];
> +             else
> +                     output_fmts[0] = MEDIA_BUS_FMT_FIXED;
> +     } else {
> +             for (i = 0; i < *num_output_fmts; i++)
> +                     output_fmts[i] = vsdc_dp_supported_fmts[i].linux_fmt;

memcpy(a, b, min(ARRAY_SIZE(), num_output_fmts)) ?

> +     }
> +
> +     return output_fmts;
> +}
> +
> +static bool vs_bridge_out_dp_fmt_supported(u32 out_fmt)
> +{
> +     unsigned int i;
> +
> +     for (i = 0; i < ARRAY_SIZE(vsdc_dp_supported_fmts); i++)
> +             if (vsdc_dp_supported_fmts[i].linux_fmt == out_fmt)

return true;

> +                     break;
> +
> +     return !(i == ARRAY_SIZE(vsdc_dp_supported_fmts));

return false;

> +}
> +
> +static u32 *vs_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge,
> +                                     struct drm_bridge_state *bridge_state,
> +                                     struct drm_crtc_state *crtc_state,
> +                                     struct drm_connector_state *conn_state,
> +                                     u32 output_fmt,
> +                                     unsigned int *num_input_fmts)
> +{
> +     struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
> +
> +     if (vbridge->intf == VSDC_OUTPUT_INTERFACE_DP &&
> +         !vs_bridge_out_dp_fmt_supported(output_fmt)) {
> +             *num_input_fmts = 0;
> +             return NULL;
> +     }
> +
> +     return drm_atomic_helper_bridge_propagate_bus_fmt(bridge, bridge_state,
> +                                                       crtc_state,
> +                                                       conn_state,
> +                                                       output_fmt,
> +                                                       num_input_fmts);
> +}
> +
> +static int vs_bridge_atomic_check(struct drm_bridge *bridge,
> +                               struct drm_bridge_state *bridge_state,
> +                               struct drm_crtc_state *crtc_state,
> +                               struct drm_connector_state *conn_state)
> +{
> +     struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
> +
> +     if (vbridge->intf == VSDC_OUTPUT_INTERFACE_DP &&
> +         
> !vs_bridge_out_dp_fmt_supported(bridge_state->output_bus_cfg.format))
> +             return -EINVAL;
> +
> +     vbridge->output_bus_fmt = bridge_state->output_bus_cfg.format;

You are saving a state value into a non-state variable. There is no
guarantee that this atomic_check() will be followed by the actual
commit. So, either you have to use a struct that extends
drm_bridge_state here or store the output_bus_fmt during
atomic_enable().

> +
> +     return 0;
> +}
> +
> +static void vs_bridge_atomic_enable(struct drm_bridge *bridge,
> +                                 struct drm_atomic_state *state)
> +{
> +     struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
> +     struct drm_bridge_state *br_state = drm_atomic_get_bridge_state(state,
> +                                                                     bridge);
> +     struct vs_crtc *crtc = vbridge->crtc;
> +     struct vs_dc *dc = crtc->dc;
> +     unsigned int output = crtc->id;
> +     u32 dp_fmt;
> +     unsigned int i;
> +
> +     DRM_DEBUG_DRIVER("Enabling output %u\n", output);
> +
> +     switch (vbridge->intf) {
> +     case VSDC_OUTPUT_INTERFACE_DPI:
> +             regmap_clear_bits(dc->regs, VSDC_DISP_DP_CONFIG(output),
> +                               VSDC_DISP_DP_CONFIG_DP_EN);
> +             break;
> +     case VSDC_OUTPUT_INTERFACE_DP:
> +             for (i = 0; i < ARRAY_SIZE(vsdc_dp_supported_fmts); i++) {
> +                     if (vsdc_dp_supported_fmts[i].linux_fmt ==
> +                         vbridge->output_bus_fmt)
> +                             break;
> +             }
> +             WARN_ON_ONCE(i == ARRAY_SIZE(vsdc_dp_supported_fmts));
> +             dp_fmt = vsdc_dp_supported_fmts[i].vsdc_fmt;

This might trigger all static checkers in the universe. It's not really
possible, since you've checked it in the atomic_check(), but...

> +             dp_fmt |= VSDC_DISP_DP_CONFIG_DP_EN;
> +             regmap_write(dc->regs, VSDC_DISP_DP_CONFIG(output), dp_fmt);
> +             regmap_assign_bits(dc->regs,
> +                                VSDC_DISP_PANEL_CONFIG(output),
> +                                VSDC_DISP_PANEL_CONFIG_YUV,
> +                                vsdc_dp_supported_fmts[i].is_yuv);
> +             break;
> +     }
> +
> +     regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output),
> +                       VSDC_DISP_PANEL_CONFIG_DAT_POL);
> +     regmap_assign_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output),
> +                        VSDC_DISP_PANEL_CONFIG_DE_POL,
> +                        br_state->output_bus_cfg.flags &
> +                        DRM_BUS_FLAG_DE_LOW);
> +     regmap_assign_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output),
> +                        VSDC_DISP_PANEL_CONFIG_CLK_POL,
> +                        br_state->output_bus_cfg.flags &
> +                        DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE);
> +     regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output),
> +                     VSDC_DISP_PANEL_CONFIG_DE_EN |
> +                     VSDC_DISP_PANEL_CONFIG_DAT_EN |
> +                     VSDC_DISP_PANEL_CONFIG_CLK_EN);
> +     regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output),
> +                     VSDC_DISP_PANEL_CONFIG_RUNNING);
> +     regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_START,
> +                       VSDC_DISP_PANEL_START_MULTI_DISP_SYNC);
> +     regmap_set_bits(dc->regs, VSDC_DISP_PANEL_START,
> +                     VSDC_DISP_PANEL_START_RUNNING(output));
> +
> +     regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG_EX(crtc->id),
> +                     VSDC_DISP_PANEL_CONFIG_EX_COMMIT);
> +}
> +
> +static void vs_bridge_atomic_disable(struct drm_bridge *bridge,
> +                                  struct drm_atomic_state *state)
> +{
> +     struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
> +     struct vs_crtc *crtc = vbridge->crtc;
> +     struct vs_dc *dc = crtc->dc;
> +     unsigned int output = crtc->id;
> +
> +     DRM_DEBUG_DRIVER("Disabling output %u\n", output);
> +
> +     regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_START,
> +                       VSDC_DISP_PANEL_START_MULTI_DISP_SYNC |
> +                       VSDC_DISP_PANEL_START_RUNNING(output));
> +     regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output),
> +                       VSDC_DISP_PANEL_CONFIG_RUNNING);
> +
> +     regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG_EX(crtc->id),
> +                     VSDC_DISP_PANEL_CONFIG_EX_COMMIT);
> +}
> +
> +static const struct drm_bridge_funcs vs_bridge_funcs = {
> +     .attach = vs_bridge_attach,
> +     .atomic_enable = vs_bridge_atomic_enable,
> +     .atomic_disable = vs_bridge_atomic_disable,
> +     .atomic_check = vs_bridge_atomic_check,
> +     .atomic_get_input_bus_fmts = vs_bridge_atomic_get_input_bus_fmts,
> +     .atomic_get_output_bus_fmts = vs_bridge_atomic_get_output_bus_fmts,
> +     .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
> +     .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
> +     .atomic_reset = drm_atomic_helper_bridge_reset,
> +};
> +
> +static int vs_bridge_detect_output_interface(struct device_node *of_node,
> +                                          unsigned int output)
> +{
> +     int ret;
> +     struct device_node *remote;
> +
> +     remote = of_graph_get_remote_node(of_node, output,
> +                                       VSDC_OUTPUT_INTERFACE_DPI);

This deserves a comment in the source file.

> +     if (remote) {
> +             ret = VSDC_OUTPUT_INTERFACE_DPI;

return here, drop else{}

> +     } else {
> +             remote = of_graph_get_remote_node(of_node, output,
> +                                               VSDC_OUTPUT_INTERFACE_DP);
> +             if (remote)
> +                     ret = VSDC_OUTPUT_INTERFACE_DP;

return

> +             else
> +                     ret = -ENODEV;
> +     }
> +
> +     return ret;
> +}
> +
> +struct vs_bridge *vs_bridge_init(struct drm_device *drm_dev,
> +                              struct vs_crtc *crtc)
> +{
> +     unsigned int output = crtc->id;
> +     struct vs_bridge *bridge;
> +     struct drm_bridge *next;
> +     enum vs_bridge_output_interface intf;
> +     int ret;
> +
> +     intf = vs_bridge_detect_output_interface(drm_dev->dev->of_node,
> +                                              output);
> +     if (intf == -ENODEV) {
> +             dev_info(drm_dev->dev, "Skipping output %u\n", output);
> +             return NULL;
> +     }
> +
> +     bridge = devm_kzalloc(drm_dev->dev, sizeof(*bridge), GFP_KERNEL);

devm_drm_bridge_alloc()

> +     if (!bridge)
> +             return ERR_PTR(-ENOMEM);
> +
> +     bridge->crtc = crtc;
> +     bridge->intf = intf;
> +     bridge->base.funcs = &vs_bridge_funcs;
> +
> +     next = devm_drm_of_get_bridge(drm_dev->dev, drm_dev->dev->of_node,
> +                                   output, intf);
> +     if (IS_ERR(next)) {
> +             ret = PTR_ERR(next);
> +             goto err_free_bridge;
> +     }
> +
> +     bridge->next = next;
> +
> +     ret = drm_simple_encoder_init(drm_dev, &bridge->enc,

Oh, so there is an encoder... Please drop drm_simple_encoder, it's
deprecated, and try moving all the ifs to the encoder funcs.

> +                                   (intf == VSDC_OUTPUT_INTERFACE_DPI) ?
> +                                   DRM_MODE_ENCODER_DPI :
> +                                   DRM_MODE_ENCODER_NONE);
> +     if (ret) {
> +             dev_err(drm_dev->dev,
> +                     "Cannot initialize encoder for output %u\n", output);
> +             goto err_free_bridge;
> +     }
> +
> +     bridge->enc.possible_crtcs = drm_crtc_mask(&crtc->base);
> +
> +     ret = drm_bridge_attach(&bridge->enc, &bridge->base, NULL,
> +                             DRM_BRIDGE_ATTACH_NO_CONNECTOR);
> +     if (ret) {
> +             dev_err(drm_dev->dev,
> +                     "Cannot attach bridge for output %u\n", output);
> +             goto err_cleanup_encoder;
> +     }
> +
> +     bridge->conn = drm_bridge_connector_init(drm_dev, &bridge->enc);
> +     if (IS_ERR(bridge->conn)) {
> +             dev_err(drm_dev->dev,
> +                     "Cannot create connector for output %u\n", output);
> +             ret = PTR_ERR(bridge->conn);
> +             goto err_cleanup_encoder;
> +     }
> +     drm_connector_attach_encoder(bridge->conn, &bridge->enc);
> +
> +     return bridge;
> +
> +err_cleanup_encoder:
> +     drm_encoder_cleanup(&bridge->enc);
> +err_free_bridge:
> +     devm_kfree(drm_dev->dev, bridge);
> +
> +     return ERR_PTR(ret);
> +}
> diff --git a/drivers/gpu/drm/verisilicon/vs_bridge.h 
> b/drivers/gpu/drm/verisilicon/vs_bridge.h
> new file mode 100644
> index 0000000000000..4a8a9eeb739f2
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_bridge.h
> @@ -0,0 +1,40 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#ifndef _VS_BRIDGE_H_
> +#define _VS_BRIDGE_H_
> +
> +#include <linux/types.h>
> +
> +#include <drm/drm_bridge.h>
> +#include <drm/drm_connector.h>
> +#include <drm/drm_encoder.h>
> +
> +struct vs_crtc;
> +
> +enum vs_bridge_output_interface {
> +     VSDC_OUTPUT_INTERFACE_DPI = 0,
> +     VSDC_OUTPUT_INTERFACE_DP = 1
> +};
> +
> +struct vs_bridge {
> +     struct drm_bridge base;
> +     struct drm_encoder enc;
> +     struct drm_connector *conn;
> +
> +     struct vs_crtc *crtc;
> +     struct drm_bridge *next;
> +     enum vs_bridge_output_interface intf;
> +     u32 output_bus_fmt;
> +};
> +
> +static inline struct vs_bridge *drm_bridge_to_vs_bridge(struct drm_bridge 
> *bridge)
> +{
> +     return container_of(bridge, struct vs_bridge, base);
> +}
> +
> +struct vs_bridge *vs_bridge_init(struct drm_device *drm_dev,
> +                              struct vs_crtc *crtc);
> +#endif /* _VS_BRIDGE_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_bridge_regs.h 
> b/drivers/gpu/drm/verisilicon/vs_bridge_regs.h
> new file mode 100644
> index 0000000000000..d1c91dd1354b4
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_bridge_regs.h
> @@ -0,0 +1,47 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + *
> + * Based on vs_dc_hw.h, which is:
> + *   Copyright (C) 2023 VeriSilicon Holdings Co., Ltd.
> + */
> +
> +#ifndef _VS_BRIDGE_REGS_H_
> +#define _VS_BRIDGE_REGS_H_
> +
> +#include <linux/bits.h>
> +
> +#define VSDC_DISP_PANEL_CONFIG(n)            (0x1418 + 0x4 * (n))
> +#define VSDC_DISP_PANEL_CONFIG_DE_EN         BIT(0)
> +#define VSDC_DISP_PANEL_CONFIG_DE_POL                BIT(1)
> +#define VSDC_DISP_PANEL_CONFIG_DAT_EN                BIT(4)
> +#define VSDC_DISP_PANEL_CONFIG_DAT_POL               BIT(5)
> +#define VSDC_DISP_PANEL_CONFIG_CLK_EN                BIT(8)
> +#define VSDC_DISP_PANEL_CONFIG_CLK_POL               BIT(9)
> +#define VSDC_DISP_PANEL_CONFIG_RUNNING               BIT(12)
> +#define VSDC_DISP_PANEL_CONFIG_GAMMA         BIT(13)
> +#define VSDC_DISP_PANEL_CONFIG_YUV           BIT(16)
> +
> +#define VSDC_DISP_PANEL_START                        0x1CCC
> +#define VSDC_DISP_PANEL_START_RUNNING(n)     BIT(n)
> +#define VSDC_DISP_PANEL_START_MULTI_DISP_SYNC        BIT(3)
> +
> +#define VSDC_DISP_DP_CONFIG(n)                       (0x1CD0 + 0x4 * (n))
> +#define VSDC_DISP_DP_CONFIG_DP_EN            BIT(3)
> +#define VSDC_DISP_DP_CONFIG_FMT_MASK         GENMASK(2, 0)
> +#define VSDC_DISP_DP_CONFIG_FMT_RGB565               (0)
> +#define VSDC_DISP_DP_CONFIG_FMT_RGB666               (1)
> +#define VSDC_DISP_DP_CONFIG_FMT_RGB888               (2)
> +#define VSDC_DISP_DP_CONFIG_FMT_RGB101010    (3)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_MASK     GENMASK(7, 4)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_UYVY8    (2 << 4)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_YUV8     (4 << 4)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_UYVY10   (8 << 4)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_YUV10    (10 << 4)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_UYYVYY8  (12 << 4)
> +#define VSDC_DISP_DP_CONFIG_YUV_FMT_UYYVYY10 (13 << 4)
> +
> +#define VSDC_DISP_PANEL_CONFIG_EX(n)         (0x2518 + 0x4 * (n))
> +#define VSDC_DISP_PANEL_CONFIG_EX_COMMIT     BIT(0)
> +
> +#endif /* _VS_BRIDGE_REGS_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_crtc.c 
> b/drivers/gpu/drm/verisilicon/vs_crtc.c
> new file mode 100644
> index 0000000000000..46c4191b82f49
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_crtc.c
> @@ -0,0 +1,217 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/regmap.h>
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_print.h>
> +
> +#include "vs_crtc_regs.h"
> +#include "vs_crtc.h"
> +#include "vs_dc.h"
> +#include "vs_dc_top_regs.h"
> +#include "vs_plane.h"
> +
> +static void vs_crtc_atomic_flush(struct drm_crtc *crtc,
> +                              struct drm_atomic_state *state)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
> +                                                                       crtc);
> +     struct drm_pending_vblank_event *event = crtc_state->event;
> +
> +     DRM_DEBUG_DRIVER("Flushing CRTC %u vblank events\n", vcrtc->id);
> +
> +     if (event) {
> +             crtc_state->event = NULL;
> +
> +             spin_lock_irq(&crtc->dev->event_lock);
> +             if (drm_crtc_vblank_get(crtc) == 0)
> +                     drm_crtc_arm_vblank_event(crtc, event);
> +             else
> +                     drm_crtc_send_vblank_event(crtc, event);
> +             spin_unlock_irq(&crtc->dev->event_lock);
> +     }
> +}
> +
> +static void vs_crtc_atomic_disable(struct drm_crtc *crtc,
> +                                struct drm_atomic_state *state)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +     unsigned int output = vcrtc->id;
> +
> +     DRM_DEBUG_DRIVER("Disabling CRTC %u\n", output);
> +
> +     drm_crtc_vblank_off(crtc);
> +
> +     clk_disable_unprepare(dc->pix_clk[output]);
> +}
> +
> +static void vs_crtc_atomic_enable(struct drm_crtc *crtc,
> +                                  struct drm_atomic_state *state)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +     unsigned int output = vcrtc->id;
> +
> +     DRM_DEBUG_DRIVER("Enabling CRTC %u\n", output);
> +
> +     WARN_ON(clk_prepare_enable(dc->pix_clk[output]));
> +
> +     drm_crtc_vblank_on(crtc);
> +}
> +
> +static void vs_crtc_mode_set_nofb(struct drm_crtc *crtc)
> +{
> +     struct drm_display_mode *mode = &crtc->state->adjusted_mode;
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +     unsigned int output = vcrtc->id;
> +
> +     DRM_DEBUG_DRIVER("Setting mode on CRTC %u\n", output);
> +
> +     regmap_write(dc->regs, VSDC_DISP_HSIZE(output),
> +                  VSDC_DISP_HSIZE_DISP(mode->hdisplay) |
> +                  VSDC_DISP_HSIZE_TOTAL(mode->htotal));
> +     regmap_write(dc->regs, VSDC_DISP_VSIZE(output),
> +                  VSDC_DISP_VSIZE_DISP(mode->vdisplay) |
> +                  VSDC_DISP_VSIZE_TOTAL(mode->vtotal));
> +     regmap_write(dc->regs, VSDC_DISP_HSYNC(output),
> +                  VSDC_DISP_HSYNC_START(mode->hsync_start) |
> +                  VSDC_DISP_HSYNC_END(mode->hsync_end) |
> +                  VSDC_DISP_HSYNC_EN);
> +     if (!(mode->flags & DRM_MODE_FLAG_PHSYNC))
> +             regmap_set_bits(dc->regs, VSDC_DISP_HSYNC(output),
> +                             VSDC_DISP_HSYNC_POL);
> +     regmap_write(dc->regs, VSDC_DISP_VSYNC(output),
> +                  VSDC_DISP_VSYNC_START(mode->vsync_start) |
> +                  VSDC_DISP_VSYNC_END(mode->vsync_end) |
> +                  VSDC_DISP_VSYNC_EN);
> +     if (!(mode->flags & DRM_MODE_FLAG_PVSYNC))
> +             regmap_set_bits(dc->regs, VSDC_DISP_VSYNC(output),
> +                             VSDC_DISP_VSYNC_POL);
> +
> +     WARN_ON(clk_set_rate(dc->pix_clk[output], mode->crtc_clock * 1000));
> +}
> +
> +static enum drm_mode_status
> +vs_crtc_mode_valid(struct drm_crtc *crtc, const struct drm_display_mode 
> *mode)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +     unsigned int output = vcrtc->id;
> +     long rate;
> +
> +     if (mode->htotal > 0x7FFF)

lowercase hex, please.

> +             return MODE_BAD_HVALUE;
> +     if (mode->vtotal > 0x7FFF)
> +             return MODE_BAD_VVALUE;
> +
> +     rate = clk_round_rate(dc->pix_clk[output], mode->clock * 1000);
> +     if (rate <= 0)
> +             return MODE_CLOCK_RANGE;
> +
> +     return MODE_OK;
> +}
> +
> +static bool vs_crtc_mode_fixup(struct drm_crtc *crtc,
> +                            const struct drm_display_mode *m,
> +                            struct drm_display_mode *adjusted_mode)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +     unsigned int output = vcrtc->id;
> +     long clk_rate;
> +
> +     drm_mode_set_crtcinfo(adjusted_mode, 0);
> +
> +     /* Feedback the pixel clock to crtc_clock */
> +     clk_rate = adjusted_mode->crtc_clock * 1000;
> +     clk_rate = clk_round_rate(dc->pix_clk[output], clk_rate);
> +     if (clk_rate <= 0)
> +             return false;
> +
> +     adjusted_mode->crtc_clock = clk_rate / 1000;
> +
> +     return true;
> +}
> +
> +static const struct drm_crtc_helper_funcs vs_crtc_helper_funcs = {
> +     .atomic_flush   = vs_crtc_atomic_flush,
> +     .atomic_enable  = vs_crtc_atomic_enable,
> +     .atomic_disable = vs_crtc_atomic_disable,
> +     .mode_set_nofb  = vs_crtc_mode_set_nofb,
> +     .mode_valid     = vs_crtc_mode_valid,
> +     .mode_fixup     = vs_crtc_mode_fixup,
> +};
> +
> +static int vs_crtc_enable_vblank(struct drm_crtc *crtc)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +
> +     DRM_DEBUG_DRIVER("Enabling VBLANK on CRTC %u\n", vcrtc->id);
> +     regmap_set_bits(dc->regs, VSDC_TOP_IRQ_EN, 
> VSDC_TOP_IRQ_VSYNC(vcrtc->id));
> +
> +     return 0;
> +}
> +
> +static void vs_crtc_disable_vblank(struct drm_crtc *crtc)
> +{
> +     struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     struct vs_dc *dc = vcrtc->dc;
> +
> +     DRM_DEBUG_DRIVER("Disabling VBLANK on CRTC %u\n", vcrtc->id);
> +     regmap_clear_bits(dc->regs, VSDC_TOP_IRQ_EN, 
> VSDC_TOP_IRQ_VSYNC(vcrtc->id));
> +}
> +
> +static const struct drm_crtc_funcs vs_crtc_funcs = {
> +     .atomic_destroy_state   = drm_atomic_helper_crtc_destroy_state,
> +     .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
> +     .destroy                = drm_crtc_cleanup,
> +     .page_flip              = drm_atomic_helper_page_flip,
> +     .reset                  = drm_atomic_helper_crtc_reset,
> +     .set_config             = drm_atomic_helper_set_config,
> +     .enable_vblank          = vs_crtc_enable_vblank,
> +     .disable_vblank         = vs_crtc_disable_vblank,
> +};
> +
> +struct vs_crtc *vs_crtc_init(struct drm_device *drm_dev, struct vs_dc *dc,
> +                          unsigned int output)
> +{
> +     struct vs_crtc *vcrtc;
> +     struct drm_plane *primary;
> +     int ret;
> +
> +     vcrtc = devm_kzalloc(drm_dev->dev, sizeof(*vcrtc), GFP_KERNEL);
> +     if (!vcrtc)
> +             return ERR_PTR(-ENOMEM);
> +     vcrtc->dc = dc;
> +     vcrtc->id = output;
> +
> +     /* Create our primary plane */
> +     primary = vs_primary_plane_init(drm_dev, dc);
> +     if (IS_ERR(primary)) {
> +             dev_err(drm_dev->dev, "Couldn't create the primary plane\n");
> +             return ERR_PTR(PTR_ERR(primary));
> +     }
> +
> +     ret = drm_crtc_init_with_planes(drm_dev, &vcrtc->base,
> +                                     primary,
> +                                     NULL,
> +                                     &vs_crtc_funcs,
> +                                     NULL);
> +     if (ret) {
> +             dev_err(drm_dev->dev, "Couldn't initialize CRTC\n");
> +             return ERR_PTR(ret);
> +     }
> +
> +     drm_crtc_helper_add(&vcrtc->base, &vs_crtc_helper_funcs);
> +
> +     return vcrtc;
> +}
> diff --git a/drivers/gpu/drm/verisilicon/vs_crtc.h 
> b/drivers/gpu/drm/verisilicon/vs_crtc.h
> new file mode 100644
> index 0000000000000..6f862d609b984
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_crtc.h
> @@ -0,0 +1,29 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#ifndef _VS_CRTC_H_
> +#define _VS_CRTC_H_
> +
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_vblank.h>
> +
> +struct vs_dc;
> +
> +struct vs_crtc {
> +     struct drm_crtc base;
> +
> +     struct vs_dc *dc;
> +     unsigned int id;
> +};
> +
> +static inline struct vs_crtc *drm_crtc_to_vs_crtc(struct drm_crtc *crtc)
> +{
> +     return container_of(crtc, struct vs_crtc, base);
> +}
> +
> +struct vs_crtc *vs_crtc_init(struct drm_device *drm_dev, struct vs_dc *dc,
> +                          unsigned int output);
> +
> +#endif /* _VS_CRTC_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_crtc_regs.h 
> b/drivers/gpu/drm/verisilicon/vs_crtc_regs.h
> new file mode 100644
> index 0000000000000..c7930e817635c
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_crtc_regs.h
> @@ -0,0 +1,60 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + *
> + * Based on vs_dc_hw.h, which is:
> + *   Copyright (C) 2023 VeriSilicon Holdings Co., Ltd.
> + */
> +
> +#ifndef _VS_CRTC_REGS_H_
> +#define _VS_CRTC_REGS_H_
> +
> +#include <linux/bits.h>
> +
> +#define VSDC_DISP_DITHER_CONFIG(n)           (0x1410 + 0x4 * (n))
> +
> +#define VSDC_DISP_DITHER_TABLE_LOW(n)                (0x1420 + 0x4 * (n))
> +#define VSDC_DISP_DITHER_TABLE_LOW_DEFAULT   0x7B48F3C0
> +
> +#define VSDC_DISP_DITHER_TABLE_HIGH(n)               (0x1428 + 0x4 * (n))
> +#define VSDC_DISP_DITHER_TABLE_HIGH_DEFAULT  0x596AD1E2
> +
> +#define VSDC_DISP_HSIZE(n)                   (0x1430 + 0x4 * (n))
> +#define VSDC_DISP_HSIZE_DISP_MASK            GENMASK(14, 0)
> +#define VSDC_DISP_HSIZE_DISP(v)                      ((v) << 0)
> +#define VSDC_DISP_HSIZE_TOTAL_MASK           GENMASK(30, 16)
> +#define VSDC_DISP_HSIZE_TOTAL(v)             ((v) << 16)
> +
> +#define VSDC_DISP_HSYNC(n)                   (0x1438 + 0x4 * (n))
> +#define VSDC_DISP_HSYNC_START_MASK           GENMASK(14, 0)
> +#define VSDC_DISP_HSYNC_START(v)             ((v) << 0)
> +#define VSDC_DISP_HSYNC_END_MASK             GENMASK(29, 15)
> +#define VSDC_DISP_HSYNC_END(v)                       ((v) << 15)
> +#define VSDC_DISP_HSYNC_EN                   BIT(30)
> +#define VSDC_DISP_HSYNC_POL                  BIT(31)
> +
> +#define VSDC_DISP_VSIZE(n)                   (0x1440 + 0x4 * (n))
> +#define VSDC_DISP_VSIZE_DISP_MASK            GENMASK(14, 0)
> +#define VSDC_DISP_VSIZE_DISP(v)                      ((v) << 0)
> +#define VSDC_DISP_VSIZE_TOTAL_MASK           GENMASK(30, 16)
> +#define VSDC_DISP_VSIZE_TOTAL(v)             ((v) << 16)
> +
> +#define VSDC_DISP_VSYNC(n)                   (0x1448 + 0x4 * (n))
> +#define VSDC_DISP_VSYNC_START_MASK           GENMASK(14, 0)
> +#define VSDC_DISP_VSYNC_START(v)             ((v) << 0)
> +#define VSDC_DISP_VSYNC_END_MASK             GENMASK(29, 15)
> +#define VSDC_DISP_VSYNC_END(v)                       ((v) << 15)
> +#define VSDC_DISP_VSYNC_EN                   BIT(30)
> +#define VSDC_DISP_VSYNC_POL                  BIT(31)
> +
> +#define VSDC_DISP_CURRENT_LOCATION(n)                (0x1450 + 0x4 * (n))
> +
> +#define VSDC_DISP_GAMMA_INDEX(n)             (0x1458 + 0x4 * (n))
> +
> +#define VSDC_DISP_GAMMA_DATA(n)                      (0x1460 + 0x4 * (n))
> +
> +#define VSDC_DISP_IRQ_STA                    0x147C
> +
> +#define VSDC_DISP_IRQ_EN                     0x1480
> +
> +#endif /* _VS_CRTC_REGS_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_dc.c 
> b/drivers/gpu/drm/verisilicon/vs_dc.c
> new file mode 100644
> index 0000000000000..98384559568c4
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_dc.c
> @@ -0,0 +1,233 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/dma-mapping.h>
> +#include <linux/of.h>
> +#include <linux/of_graph.h>
> +
> +#include "vs_crtc.h"
> +#include "vs_dc.h"
> +#include "vs_dc_top_regs.h"
> +#include "vs_drm.h"
> +#include "vs_hwdb.h"
> +
> +static const struct regmap_config vs_dc_regmap_cfg = {
> +     .reg_bits = 32,
> +     .val_bits = 32,
> +     .reg_stride = sizeof(u32),
> +     /* VSDC_OVL_CONFIG_EX(1) */
> +     .max_register = 0x2544,
> +     .cache_type = REGCACHE_NONE,
> +};
> +
> +static const struct of_device_id vs_dc_driver_dt_match[] = {
> +     { .compatible = "verisilicon,dc" },
> +     {},
> +};
> +MODULE_DEVICE_TABLE(of, vs_dc_driver_dt_match);
> +
> +static irqreturn_t vs_dc_irq_handler(int irq, void *private)
> +{
> +     struct vs_dc *dc = private;
> +     u32 irqs;
> +
> +     regmap_read(dc->regs, VSDC_TOP_IRQ_ACK, &irqs);
> +
> +     return vs_drm_handle_irq(dc, irqs);
> +}
> +
> +static int vs_dc_probe(struct platform_device *pdev)
> +{
> +     struct device *dev = &pdev->dev;
> +     struct vs_dc *dc;
> +     void __iomem *regs;
> +     unsigned int outputs, i;
> +     /* pix0/pix1 */
> +     char pixclk_name[5];
> +     int irq, ret;
> +
> +     if (!dev->of_node) {
> +             dev_err(dev, "can't find DC devices\n");
> +             return -ENODEV;
> +     }
> +
> +     outputs = of_graph_get_port_count(dev->of_node);
> +     if (!outputs) {
> +             dev_err(dev, "can't find DC downstream ports\n");
> +             return -ENODEV;
> +     }
> +     if (outputs > VSDC_MAX_OUTPUTS) {
> +             dev_err(dev, "too many DC downstream ports than possible\n");
> +             return -EINVAL;
> +     }
> +
> +     ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
> +     if (ret) {
> +             dev_err(dev, "No suitable DMA available\n");
> +             return ret;
> +     }
> +
> +     dc = devm_kzalloc(dev, sizeof(*dc), GFP_KERNEL);
> +     if (!dc)
> +             return -ENOMEM;
> +
> +     dc->outputs = outputs;
> +
> +     dc->rsts[0].id = "core";
> +     dc->rsts[1].id = "axi";
> +     dc->rsts[0].id = "ahb";
> +
> +     ret = devm_reset_control_bulk_get_optional_shared(dev, VSDC_RESET_COUNT,
> +                                                       dc->rsts);
> +     if (ret) {
> +             dev_err(dev, "can't get reset lines\n");
> +             return ret;
> +     }
> +
> +     dc->core_clk = devm_clk_get(dev, "core");
> +     if (IS_ERR(dc->core_clk)) {
> +             dev_err(dev, "can't get core clock\n");
> +             return PTR_ERR(dc->core_clk);
> +     }
> +
> +     dc->axi_clk = devm_clk_get(dev, "axi");
> +     if (IS_ERR(dc->axi_clk)) {
> +             dev_err(dev, "can't get axi clock\n");
> +             return PTR_ERR(dc->axi_clk);
> +     }
> +
> +     dc->ahb_clk = devm_clk_get(dev, "ahb");

devm_clk_get_enabled() ?

> +     if (IS_ERR(dc->ahb_clk)) {
> +             dev_err(dev, "can't get ahb clock\n");
> +             return PTR_ERR(dc->ahb_clk);
> +     }
> +
> +     for (i = 0; i < outputs; i++) {
> +             snprintf(pixclk_name, sizeof(pixclk_name), "pix%u", i);
> +             dc->pix_clk[i] = devm_clk_get(dev, pixclk_name);
> +             if (IS_ERR(dc->pix_clk[i])) {
> +                     dev_err(dev, "can't get pixel clk %u\n", i);
> +                     return PTR_ERR(dc->pix_clk[i]);
> +             }
> +     }
> +
> +     irq = platform_get_irq(pdev, 0);
> +     if (irq < 0) {
> +             dev_err(dev, "can't get irq\n");
> +             return irq;
> +     }
> +
> +     ret = reset_control_bulk_deassert(VSDC_RESET_COUNT, dc->rsts);
> +     if (ret) {
> +             dev_err(dev, "can't deassert reset lines\n");
> +             return ret;
> +     }
> +
> +     ret = clk_prepare_enable(dc->core_clk);
> +     if (ret) {
> +             dev_err(dev, "can't enable core clock\n");
> +             goto err_rst_assert;
> +     }
> +
> +     ret = clk_prepare_enable(dc->axi_clk);
> +     if (ret) {
> +             dev_err(dev, "can't enable axi clock\n");
> +             goto err_core_clk_disable;
> +     }
> +
> +     ret = clk_prepare_enable(dc->ahb_clk);
> +     if (ret) {
> +             dev_err(dev, "can't enable ahb clock\n");
> +             goto err_axi_clk_disable;
> +     }
> +
> +     regs = devm_platform_ioremap_resource(pdev, 0);
> +     if (IS_ERR(regs)) {
> +             dev_err(dev, "can't map registers");
> +             ret = PTR_ERR(regs);
> +             goto err_ahb_clk_disable;
> +     }
> +
> +     dc->regs = devm_regmap_init_mmio(dev, regs, &vs_dc_regmap_cfg);
> +     if (IS_ERR(dc->regs)) {
> +             ret = PTR_ERR(dc->regs);
> +             goto err_ahb_clk_disable;
> +     }
> +
> +     ret = vs_fill_chip_identity(dc->regs, &dc->identity);

I'd say, this should be a part of the DT bindings.

> +     if (ret)
> +             goto err_ahb_clk_disable;
> +
> +     dev_info(dev, "DC%x rev %x customer %x\n", dc->identity.model,
> +              dc->identity.revision, dc->identity.customer_id);
> +
> +     if (outputs > dc->identity.display_count) {
> +             dev_err(dev, "too many downstream ports than HW capability\n");
> +             ret = -EINVAL;
> +             goto err_ahb_clk_disable;
> +     }
> +
> +     ret = devm_request_irq(dev, irq, vs_dc_irq_handler, 0,
> +                            dev_name(dev), dc);

Are we ready to handle the IRQ here?

> +     if (ret) {
> +             dev_err(dev, "can't request irq\n");
> +             goto err_ahb_clk_disable;
> +     }
> +
> +     dev_set_drvdata(dev, dc);
> +
> +     ret = vs_drm_initialize(dc, pdev);
> +     if (ret)
> +             goto err_ahb_clk_disable;
> +
> +     return 0;
> +
> +err_ahb_clk_disable:
> +     clk_disable_unprepare(dc->ahb_clk);
> +err_axi_clk_disable:
> +     clk_disable_unprepare(dc->axi_clk);
> +err_core_clk_disable:
> +     clk_disable_unprepare(dc->core_clk);
> +err_rst_assert:
> +     reset_control_bulk_assert(VSDC_RESET_COUNT, dc->rsts);
> +     return ret;
> +}
> +
> +static void vs_dc_remove(struct platform_device *pdev)
> +{
> +     struct vs_dc *dc = dev_get_drvdata(&pdev->dev);
> +
> +     vs_drm_finalize(dc);
> +
> +     dev_set_drvdata(&pdev->dev, NULL);
> +
> +     clk_disable_unprepare(dc->ahb_clk);
> +     clk_disable_unprepare(dc->axi_clk);
> +     clk_disable_unprepare(dc->core_clk);
> +     reset_control_bulk_assert(VSDC_RESET_COUNT, dc->rsts);
> +}
> +
> +static void vs_dc_shutdown(struct platform_device *pdev)
> +{
> +     struct vs_dc *dc = dev_get_drvdata(&pdev->dev);
> +
> +     vs_drm_shutdown_handler(dc);

I'd suggest inlining simple wrappers.

> +}
> +
> +struct platform_driver vs_dc_platform_driver = {
> +     .probe = vs_dc_probe,
> +     .remove = vs_dc_remove,
> +     .shutdown = vs_dc_shutdown,
> +     .driver = {
> +             .name = "verisilicon-dc",
> +             .of_match_table = vs_dc_driver_dt_match,
> +     },
> +};
> +
> +module_platform_driver(vs_dc_platform_driver);
> +
> +MODULE_AUTHOR("Icenowy Zheng <u...@icenowy.me>");
> +MODULE_DESCRIPTION("Verisilicon display controller driver");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/gpu/drm/verisilicon/vs_dc.h 
> b/drivers/gpu/drm/verisilicon/vs_dc.h
> new file mode 100644
> index 0000000000000..5e071501b1c38
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_dc.h
> @@ -0,0 +1,39 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + *
> + * Based on vs_dc_hw.h, which is:
> + *   Copyright (C) 2023 VeriSilicon Holdings Co., Ltd.
> + */
> +
> +#ifndef _VS_DC_H_
> +#define _VS_DC_H_
> +
> +#include <linux/clk.h>
> +#include <linux/regmap.h>
> +#include <linux/reset.h>
> +
> +#include <drm/drm_device.h>
> +
> +#include "vs_hwdb.h"
> +
> +#define VSDC_MAX_OUTPUTS 2
> +#define VSDC_RESET_COUNT 3
> +
> +struct vs_drm_dev;
> +struct vs_crtc;
> +
> +struct vs_dc {
> +     struct regmap *regs;
> +     struct clk *core_clk;
> +     struct clk *axi_clk;
> +     struct clk *ahb_clk;
> +     struct clk *pix_clk[VSDC_MAX_OUTPUTS];
> +     struct reset_control_bulk_data rsts[VSDC_RESET_COUNT];
> +
> +     struct vs_drm_dev *drm_dev;
> +     struct vs_chip_identity identity;
> +     unsigned int outputs;
> +};
> +
> +#endif /* _VS_DC_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_dc_top_regs.h 
> b/drivers/gpu/drm/verisilicon/vs_dc_top_regs.h
> new file mode 100644
> index 0000000000000..50509bbbff08f
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_dc_top_regs.h
> @@ -0,0 +1,27 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + *
> + * Based on vs_dc_hw.h, which is:
> + *   Copyright (C) 2023 VeriSilicon Holdings Co., Ltd.
> + */
> +
> +#ifndef _VS_DC_TOP_H_
> +#define _VS_DC_TOP_H_
> +
> +#include <linux/bits.h>
> +
> +#define VSDC_TOP_RST                         0x0000
> +
> +#define VSDC_TOP_IRQ_ACK                     0x0010
> +#define VSDC_TOP_IRQ_VSYNC(n)                        BIT(n)
> +
> +#define VSDC_TOP_IRQ_EN                              0x0014
> +
> +#define VSDC_TOP_CHIP_MODEL                  0x0020
> +
> +#define VSDC_TOP_CHIP_REV                    0x0024
> +
> +#define VSDC_TOP_CHIP_CUSTOMER_ID            0x0030
> +
> +#endif /* _VS_DC_TOP_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_drm.c 
> b/drivers/gpu/drm/verisilicon/vs_drm.c
> new file mode 100644
> index 0000000000000..f356d7832c449
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_drm.c
> @@ -0,0 +1,177 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/aperture.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/platform_device.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/module.h>
> +#include <linux/regmap.h>
> +#include <linux/console.h>
> +
> +#include <drm/clients/drm_client_setup.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_drv.h>
> +#include <drm/drm_fbdev_dma.h>
> +#include <drm/drm_gem_dma_helper.h>
> +#include <drm/drm_gem_framebuffer_helper.h>
> +#include <drm/drm_of.h>
> +#include <drm/drm_probe_helper.h>
> +#include <drm/drm_vblank.h>
> +
> +#include "vs_bridge.h"
> +#include "vs_crtc.h"
> +#include "vs_dc.h"
> +#include "vs_dc_top_regs.h"
> +#include "vs_drm.h"
> +
> +#define DRIVER_NAME  "verisilicon"
> +#define DRIVER_DESC  "Verisilicon DC-series display controller driver"
> +#define DRIVER_MAJOR 1
> +#define DRIVER_MINOR 0
> +
> +static int vs_gem_dumb_create(struct drm_file *file_priv,
> +                           struct drm_device *drm,
> +                           struct drm_mode_create_dumb *args)
> +{
> +     /* The hardware wants 128B-aligned pitches for linear buffers. */
> +     args->pitch = ALIGN(DIV_ROUND_UP(args->width * args->bpp, 8), 128);
> +
> +     return drm_gem_dma_dumb_create_internal(file_priv, drm, args);
> +}
> +
> +DEFINE_DRM_GEM_FOPS(vs_drm_driver_fops);
> +
> +static const struct drm_driver vs_drm_driver = {
> +     .driver_features        = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
> +     .fops                   = &vs_drm_driver_fops,
> +     .name   = DRIVER_NAME,
> +     .desc   = DRIVER_DESC,
> +     .major  = DRIVER_MAJOR,
> +     .minor  = DRIVER_MINOR,
> +
> +     /* GEM Operations */
> +     DRM_GEM_DMA_DRIVER_OPS_WITH_DUMB_CREATE(vs_gem_dumb_create),
> +     DRM_FBDEV_DMA_DRIVER_OPS,
> +};
> +
> +static const struct drm_mode_config_funcs vs_mode_config_funcs = {
> +     .fb_create              = drm_gem_fb_create,
> +     .atomic_check           = drm_atomic_helper_check,
> +     .atomic_commit          = drm_atomic_helper_commit,
> +};
> +
> +static struct drm_mode_config_helper_funcs vs_mode_config_helper_funcs = {
> +     .atomic_commit_tail = drm_atomic_helper_commit_tail,
> +};
> +
> +static void vs_mode_config_init(struct drm_device *drm)
> +{
> +     drm_mode_config_reset(drm);
> +
> +     drm->mode_config.min_width = 0;
> +     drm->mode_config.min_height = 0;
> +     drm->mode_config.max_width = 8192;
> +     drm->mode_config.max_height = 8192;
> +     drm->mode_config.funcs = &vs_mode_config_funcs;
> +     drm->mode_config.helper_private = &vs_mode_config_helper_funcs;
> +}
> +
> +int vs_drm_initialize(struct vs_dc *dc, struct platform_device *pdev)
> +{
> +     struct device *dev = &pdev->dev;
> +     struct vs_drm_dev *vdrm;
> +     struct drm_device *drm;
> +     struct vs_crtc *crtc;
> +     struct vs_bridge *bridge;
> +     unsigned int i;
> +     int ret;
> +
> +     vdrm = devm_drm_dev_alloc(dev, &vs_drm_driver, struct vs_drm_dev, base);
> +     if (IS_ERR(vdrm))
> +             return PTR_ERR(vdrm);
> +
> +     drm = &vdrm->base;
> +     vdrm->dc = dc;
> +     dc->drm_dev = vdrm;
> +
> +     ret = drmm_mode_config_init(drm);
> +     if (ret)
> +             return ret;
> +
> +     for (i = 0; i < dc->outputs; i++) {
> +             crtc = vs_crtc_init(drm, dc, i);
> +             if (IS_ERR(crtc))
> +                     return PTR_ERR(crtc);
> +
> +             bridge = vs_bridge_init(drm, crtc);
> +             if (IS_ERR(bridge))
> +                     return PTR_ERR(bridge);
> +
> +             vdrm->crtcs[i] = crtc;
> +     }
> +
> +     ret = drm_vblank_init(drm, dc->outputs);
> +     if (ret)
> +             return ret;
> +
> +     /* Remove early framebuffers (ie. simplefb) */
> +     ret = aperture_remove_all_conflicting_devices(DRIVER_NAME);
> +     if (ret)
> +             return ret;
> +
> +     vs_mode_config_init(drm);
> +
> +     /* Enable connectors polling */
> +     drm_kms_helper_poll_init(drm);
> +
> +     ret = drm_dev_register(drm, 0);
> +     if (ret)
> +             goto err_fini_poll;
> +
> +     drm_client_setup(drm, NULL);
> +
> +     return 0;
> +
> +err_fini_poll:
> +     drm_kms_helper_poll_fini(drm);
> +     return ret;
> +}
> +
> +void vs_drm_finalize(struct vs_dc *dc)
> +{
> +     struct vs_drm_dev *vdrm = dc->drm_dev;
> +     struct drm_device *drm = &vdrm->base;
> +
> +     drm_dev_unregister(drm);
> +     drm_kms_helper_poll_fini(drm);
> +     drm_atomic_helper_shutdown(drm);
> +     dc->drm_dev = NULL;
> +}
> +
> +void vs_drm_shutdown_handler(struct vs_dc *dc)
> +{
> +     struct vs_drm_dev *vdrm = dc->drm_dev;
> +
> +     drm_atomic_helper_shutdown(&vdrm->base);
> +}
> +
> +irqreturn_t vs_drm_handle_irq(struct vs_dc *dc, u32 irqs)
> +{
> +     unsigned int i;
> +
> +     for (i = 0; i < dc->outputs; i++) {
> +             if (irqs & VSDC_TOP_IRQ_VSYNC(i)) {
> +                     irqs &= ~VSDC_TOP_IRQ_VSYNC(i);
> +                     if (dc->drm_dev->crtcs[i])
> +                             
> drm_crtc_handle_vblank(&dc->drm_dev->crtcs[i]->base);
> +             }
> +     }
> +
> +     if (irqs)
> +             pr_warn("Unknown Verisilicon DC interrupt 0x%x fired!\n", irqs);
> +
> +     return IRQ_HANDLED;
> +}
> diff --git a/drivers/gpu/drm/verisilicon/vs_drm.h 
> b/drivers/gpu/drm/verisilicon/vs_drm.h
> new file mode 100644
> index 0000000000000..bbcd2e527deb6
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_drm.h
> @@ -0,0 +1,29 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#ifndef _VS_DRM_H_
> +#define _VS_DRM_H_
> +
> +#include <linux/irqreturn.h>
> +#include <linux/platform_device.h>
> +#include <linux/types.h>
> +
> +#include <drm/drm_device.h>
> +
> +struct vs_dc;
> +
> +struct vs_drm_dev {
> +     struct drm_device base;
> +
> +     struct vs_dc *dc;
> +     struct vs_crtc *crtcs[VSDC_MAX_OUTPUTS];
> +};
> +
> +int vs_drm_initialize(struct vs_dc *dc, struct platform_device *pdev);
> +void vs_drm_finalize(struct vs_dc *dc);
> +void vs_drm_shutdown_handler(struct vs_dc *dc);
> +irqreturn_t vs_drm_handle_irq(struct vs_dc *dc, u32 irqs);
> +
> +#endif /* _VS_DRM_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_hwdb.c 
> b/drivers/gpu/drm/verisilicon/vs_hwdb.c
> new file mode 100644
> index 0000000000000..4a87e5d4701f3
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_hwdb.c
> @@ -0,0 +1,150 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/errno.h>
> +
> +#include <drm/drm_fourcc.h>
> +
> +#include "vs_dc_top_regs.h"
> +#include "vs_hwdb.h"
> +
> +static const u32 vs_formats_array_no_yuv444[] = {
> +     DRM_FORMAT_XRGB4444,
> +     DRM_FORMAT_XBGR4444,
> +     DRM_FORMAT_RGBX4444,
> +     DRM_FORMAT_BGRX4444,
> +     DRM_FORMAT_ARGB4444,
> +     DRM_FORMAT_ABGR4444,
> +     DRM_FORMAT_RGBA4444,
> +     DRM_FORMAT_BGRA4444,
> +     DRM_FORMAT_XRGB1555,
> +     DRM_FORMAT_XBGR1555,
> +     DRM_FORMAT_RGBX5551,
> +     DRM_FORMAT_BGRX5551,
> +     DRM_FORMAT_ARGB1555,
> +     DRM_FORMAT_ABGR1555,
> +     DRM_FORMAT_RGBA5551,
> +     DRM_FORMAT_BGRA5551,
> +     DRM_FORMAT_RGB565,
> +     DRM_FORMAT_BGR565,
> +     DRM_FORMAT_XRGB8888,
> +     DRM_FORMAT_XBGR8888,
> +     DRM_FORMAT_RGBX8888,
> +     DRM_FORMAT_BGRX8888,
> +     DRM_FORMAT_ARGB8888,
> +     DRM_FORMAT_ABGR8888,
> +     DRM_FORMAT_RGBA8888,
> +     DRM_FORMAT_BGRA8888,
> +     DRM_FORMAT_ARGB2101010,
> +     DRM_FORMAT_ABGR2101010,
> +     DRM_FORMAT_RGBA1010102,
> +     DRM_FORMAT_BGRA1010102,
> +     /* TODO: non-RGB formats */
> +};
> +
> +static const u32 vs_formats_array_with_yuv444[] = {
> +     DRM_FORMAT_XRGB4444,
> +     DRM_FORMAT_XBGR4444,
> +     DRM_FORMAT_RGBX4444,
> +     DRM_FORMAT_BGRX4444,
> +     DRM_FORMAT_ARGB4444,
> +     DRM_FORMAT_ABGR4444,
> +     DRM_FORMAT_RGBA4444,
> +     DRM_FORMAT_BGRA4444,
> +     DRM_FORMAT_XRGB1555,
> +     DRM_FORMAT_XBGR1555,
> +     DRM_FORMAT_RGBX5551,
> +     DRM_FORMAT_BGRX5551,
> +     DRM_FORMAT_ARGB1555,
> +     DRM_FORMAT_ABGR1555,
> +     DRM_FORMAT_RGBA5551,
> +     DRM_FORMAT_BGRA5551,
> +     DRM_FORMAT_RGB565,
> +     DRM_FORMAT_BGR565,
> +     DRM_FORMAT_XRGB8888,
> +     DRM_FORMAT_XBGR8888,
> +     DRM_FORMAT_RGBX8888,
> +     DRM_FORMAT_BGRX8888,
> +     DRM_FORMAT_ARGB8888,
> +     DRM_FORMAT_ABGR8888,
> +     DRM_FORMAT_RGBA8888,
> +     DRM_FORMAT_BGRA8888,
> +     DRM_FORMAT_ARGB2101010,
> +     DRM_FORMAT_ABGR2101010,
> +     DRM_FORMAT_RGBA1010102,
> +     DRM_FORMAT_BGRA1010102,
> +     /* TODO: non-RGB formats */
> +};
> +
> +static const struct vs_formats vs_formats_no_yuv444 = {
> +     .array = vs_formats_array_no_yuv444,
> +     .num = ARRAY_SIZE(vs_formats_array_no_yuv444)
> +};
> +
> +static const struct vs_formats vs_formats_with_yuv444 = {
> +     .array = vs_formats_array_with_yuv444,
> +     .num = ARRAY_SIZE(vs_formats_array_with_yuv444)
> +};
> +
> +static struct vs_chip_identity vs_chip_identities[] = {
> +     {
> +             .model = 0x8200,
> +             .revision = 0x5720,
> +             .customer_id = ~0U,
> +
> +             .display_count = 2,
> +             .formats = &vs_formats_no_yuv444,
> +     },
> +     {
> +             .model = 0x8200,
> +             .revision = 0x5721,
> +             .customer_id = 0x30B,
> +
> +             .display_count = 2,
> +             .formats = &vs_formats_no_yuv444,
> +     },
> +     {
> +             .model = 0x8200,
> +             .revision = 0x5720,
> +             .customer_id = 0x310,
> +
> +             .display_count = 2,
> +             .formats = &vs_formats_with_yuv444,
> +     },
> +     {
> +             .model = 0x8200,
> +             .revision = 0x5720,
> +             .customer_id = 0x311,
> +
> +             .display_count = 2,
> +             .formats = &vs_formats_no_yuv444,
> +     },
> +};
> +
> +int vs_fill_chip_identity(struct regmap *regs,
> +                       struct vs_chip_identity *ident)
> +{
> +     u32 model;
> +     u32 revision;
> +     u32 customer_id;
> +     int i;
> +
> +     regmap_read(regs, VSDC_TOP_CHIP_MODEL, &model);
> +     regmap_read(regs, VSDC_TOP_CHIP_REV, &revision);
> +     regmap_read(regs, VSDC_TOP_CHIP_CUSTOMER_ID, &customer_id);
> +
> +     for (i = 0; i < ARRAY_SIZE(vs_chip_identities); i++) {
> +             if (vs_chip_identities[i].model == model &&
> +                 vs_chip_identities[i].revision == revision &&
> +                 (vs_chip_identities[i].customer_id == customer_id ||
> +                      vs_chip_identities[i].customer_id == ~0U)) {
> +                     memcpy(ident, &vs_chip_identities[i], sizeof(*ident));
> +                     ident->customer_id = customer_id;
> +                     return 0;
> +             }
> +     }
> +
> +     return -EINVAL;
> +}
> diff --git a/drivers/gpu/drm/verisilicon/vs_hwdb.h 
> b/drivers/gpu/drm/verisilicon/vs_hwdb.h
> new file mode 100644
> index 0000000000000..92192e4fa0862
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_hwdb.h
> @@ -0,0 +1,29 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#ifndef _VS_HWDB_H_
> +#define _VS_HWDB_H_
> +
> +#include <linux/regmap.h>
> +#include <linux/types.h>
> +
> +struct vs_formats {
> +     const u32 *array;
> +     unsigned int num;
> +};
> +
> +struct vs_chip_identity {
> +     u32 model;
> +     u32 revision;
> +     u32 customer_id;
> +
> +     u32 display_count;
> +     const struct vs_formats *formats;
> +};
> +
> +int vs_fill_chip_identity(struct regmap *regs,
> +                       struct vs_chip_identity *ident);
> +
> +#endif /* _VS_HWDB_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_plane.c 
> b/drivers/gpu/drm/verisilicon/vs_plane.c
> new file mode 100644
> index 0000000000000..f3c9963b6a4ea
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_plane.c
> @@ -0,0 +1,102 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/errno.h>
> +
> +#include <drm/drm_fourcc.h>
> +#include <drm/drm_print.h>
> +
> +#include "vs_plane.h"
> +
> +void drm_format_to_vs_format(u32 drm_format, struct vs_format *vs_format)
> +{
> +     switch (drm_format) {
> +     case DRM_FORMAT_XRGB4444:
> +     case DRM_FORMAT_RGBX4444:
> +     case DRM_FORMAT_XBGR4444:
> +     case DRM_FORMAT_BGRX4444:
> +             vs_format->color = VSDC_COLOR_FORMAT_X4R4G4B4;
> +             break;
> +     case DRM_FORMAT_ARGB4444:
> +     case DRM_FORMAT_RGBA4444:
> +     case DRM_FORMAT_ABGR4444:
> +     case DRM_FORMAT_BGRA4444:
> +             vs_format->color = VSDC_COLOR_FORMAT_A4R4G4B4;
> +             break;
> +     case DRM_FORMAT_XRGB1555:
> +     case DRM_FORMAT_RGBX5551:
> +     case DRM_FORMAT_XBGR1555:
> +     case DRM_FORMAT_BGRX5551:
> +             vs_format->color = VSDC_COLOR_FORMAT_X1R5G5B5;
> +             break;
> +     case DRM_FORMAT_ARGB1555:
> +     case DRM_FORMAT_RGBA5551:
> +     case DRM_FORMAT_ABGR1555:
> +     case DRM_FORMAT_BGRA5551:
> +             vs_format->color = VSDC_COLOR_FORMAT_A1R5G5B5;
> +             break;
> +     case DRM_FORMAT_RGB565:
> +     case DRM_FORMAT_BGR565:
> +             vs_format->color = VSDC_COLOR_FORMAT_R5G6B5;
> +             break;
> +     case DRM_FORMAT_XRGB8888:
> +     case DRM_FORMAT_RGBX8888:
> +     case DRM_FORMAT_XBGR8888:
> +     case DRM_FORMAT_BGRX8888:
> +             vs_format->color = VSDC_COLOR_FORMAT_X8R8G8B8;
> +             break;
> +     case DRM_FORMAT_ARGB8888:
> +     case DRM_FORMAT_RGBA8888:
> +     case DRM_FORMAT_ABGR8888:
> +     case DRM_FORMAT_BGRA8888:
> +             vs_format->color = VSDC_COLOR_FORMAT_A8R8G8B8;
> +             break;
> +     case DRM_FORMAT_ARGB2101010:
> +     case DRM_FORMAT_RGBA1010102:
> +     case DRM_FORMAT_ABGR2101010:
> +     case DRM_FORMAT_BGRA1010102:
> +             vs_format->color = VSDC_COLOR_FORMAT_A2R10G10B10;
> +             break;
> +     default:
> +             DRM_WARN("Unexpected drm format!\n");
> +     }
> +
> +     switch (drm_format) {
> +     case DRM_FORMAT_RGBX4444:
> +     case DRM_FORMAT_RGBA4444:
> +     case DRM_FORMAT_RGBX5551:
> +     case DRM_FORMAT_RGBA5551:
> +     case DRM_FORMAT_RGBX8888:
> +     case DRM_FORMAT_RGBA8888:
> +     case DRM_FORMAT_RGBA1010102:
> +             vs_format->swizzle = VSDC_SWIZZLE_RGBA;
> +             break;
> +     case DRM_FORMAT_XBGR4444:
> +     case DRM_FORMAT_ABGR4444:
> +     case DRM_FORMAT_XBGR1555:
> +     case DRM_FORMAT_ABGR1555:
> +     case DRM_FORMAT_BGR565:
> +     case DRM_FORMAT_XBGR8888:
> +     case DRM_FORMAT_ABGR8888:
> +     case DRM_FORMAT_ABGR2101010:
> +             vs_format->swizzle = VSDC_SWIZZLE_ABGR;
> +             break;
> +     case DRM_FORMAT_BGRX4444:
> +     case DRM_FORMAT_BGRA4444:
> +     case DRM_FORMAT_BGRX5551:
> +     case DRM_FORMAT_BGRA5551:
> +     case DRM_FORMAT_BGRX8888:
> +     case DRM_FORMAT_BGRA8888:
> +     case DRM_FORMAT_BGRA1010102:
> +             vs_format->swizzle = VSDC_SWIZZLE_BGRA;
> +             break;
> +     default:
> +             /* N/A for YUV formats */
> +             vs_format->swizzle = VSDC_SWIZZLE_ARGB;
> +     }
> +
> +     /* N/A for non-YUV formats */
> +     vs_format->uv_swizzle = false;
> +}
> diff --git a/drivers/gpu/drm/verisilicon/vs_plane.h 
> b/drivers/gpu/drm/verisilicon/vs_plane.h
> new file mode 100644
> index 0000000000000..3595267c89b53
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_plane.h
> @@ -0,0 +1,68 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + *
> + * Based on vs_dc_hw.h, which is:
> + *   Copyright (C) 2023 VeriSilicon Holdings Co., Ltd.
> + */
> +
> +#ifndef _VS_PLANE_H_
> +#define _VS_PLANE_H_
> +
> +#include <linux/types.h>
> +
> +#include <drm/drm_device.h>
> +#include <drm/drm_plane.h>
> +
> +#define VSDC_MAKE_PLANE_SIZE(w, h) (((w) & 0x7fff) | (((h) & 0x7fff) << 15))
> +#define VSDC_MAKE_PLANE_POS(x, y) (((x) & 0x7fff) | (((y) & 0x7fff) << 15))
> +
> +struct vs_dc;
> +
> +enum vs_color_format {
> +     VSDC_COLOR_FORMAT_X4R4G4B4,
> +     VSDC_COLOR_FORMAT_A4R4G4B4,
> +     VSDC_COLOR_FORMAT_X1R5G5B5,
> +     VSDC_COLOR_FORMAT_A1R5G5B5,
> +     VSDC_COLOR_FORMAT_R5G6B5,
> +     VSDC_COLOR_FORMAT_X8R8G8B8,
> +     VSDC_COLOR_FORMAT_A8R8G8B8,
> +     VSDC_COLOR_FORMAT_YUY2,
> +     VSDC_COLOR_FORMAT_UYVY,
> +     VSDC_COLOR_FORMAT_INDEX8,
> +     VSDC_COLOR_FORMAT_MONOCHROME,
> +     VSDC_COLOR_FORMAT_YV12 = 0xf,
> +     VSDC_COLOR_FORMAT_A8,
> +     VSDC_COLOR_FORMAT_NV12,
> +     VSDC_COLOR_FORMAT_NV16,
> +     VSDC_COLOR_FORMAT_RG16,
> +     VSDC_COLOR_FORMAT_R8,
> +     VSDC_COLOR_FORMAT_NV12_10BIT,
> +     VSDC_COLOR_FORMAT_A2R10G10B10,
> +     VSDC_COLOR_FORMAT_NV16_10BIT,
> +     VSDC_COLOR_FORMAT_INDEX1,
> +     VSDC_COLOR_FORMAT_INDEX2,
> +     VSDC_COLOR_FORMAT_INDEX4,
> +     VSDC_COLOR_FORMAT_P010,
> +     VSDC_COLOR_FORMAT_YUV444,
> +     VSDC_COLOR_FORMAT_YUV444_10BIT
> +};
> +
> +enum vs_swizzle {
> +     VSDC_SWIZZLE_ARGB,
> +     VSDC_SWIZZLE_RGBA,
> +     VSDC_SWIZZLE_ABGR,
> +     VSDC_SWIZZLE_BGRA,
> +};
> +
> +struct vs_format {
> +     enum vs_color_format color;
> +     enum vs_swizzle swizzle;
> +     bool uv_swizzle;
> +};
> +
> +void drm_format_to_vs_format(u32 drm_format, struct vs_format *vs_format);
> +
> +struct drm_plane *vs_primary_plane_init(struct drm_device *dev, struct vs_dc 
> *dc);
> +
> +#endif /* _VS_PLANE_H_ */
> diff --git a/drivers/gpu/drm/verisilicon/vs_primary_plane.c 
> b/drivers/gpu/drm/verisilicon/vs_primary_plane.c
> new file mode 100644
> index 0000000000000..25d6e01cc8b71
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_primary_plane.c
> @@ -0,0 +1,166 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + */
> +
> +#include <linux/regmap.h>
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_fb_dma_helper.h>
> +#include <drm/drm_fourcc.h>
> +#include <drm/drm_framebuffer.h>
> +#include <drm/drm_gem_atomic_helper.h>
> +#include <drm/drm_gem_dma_helper.h>
> +#include <drm/drm_modeset_helper_vtables.h>
> +#include <drm/drm_plane.h>
> +#include <drm/drm_print.h>
> +
> +#include "vs_crtc.h"
> +#include "vs_plane.h"
> +#include "vs_dc.h"
> +#include "vs_primary_plane_regs.h"
> +
> +static int vs_primary_plane_atomic_check(struct drm_plane *plane,
> +                                      struct drm_atomic_state *state)
> +{
> +     struct drm_plane_state *new_plane_state = 
> drm_atomic_get_new_plane_state(state,
> +                                                                             
>  plane);
> +     struct drm_crtc *crtc = new_plane_state->crtc;
> +     struct drm_crtc_state *crtc_state;
> +
> +     if (!crtc)
> +             return 0;
> +
> +     crtc_state = drm_atomic_get_existing_crtc_state(state,
> +                                                     crtc);
> +     if (WARN_ON(!crtc_state))
> +             return -EINVAL;
> +
> +     return drm_atomic_helper_check_plane_state(new_plane_state,
> +                                                crtc_state,
> +                                                DRM_PLANE_NO_SCALING,
> +                                                DRM_PLANE_NO_SCALING,
> +                                                false, true);
> +}
> +
> +
> +static void vs_primary_plane_atomic_update(struct drm_plane *plane,
> +                                        struct drm_atomic_state 
> *atomic_state)
> +{
> +     struct drm_plane_state *state = 
> drm_atomic_get_new_plane_state(atomic_state,
> +                                                                    plane);
> +     struct drm_framebuffer *fb = state->fb;
> +     struct drm_crtc *crtc = state->crtc;
> +     struct drm_gem_dma_object *gem;
> +     struct vs_dc *dc;
> +     struct vs_crtc *vcrtc;
> +     struct vs_format fmt;
> +     unsigned int output, bpp;
> +     dma_addr_t dma_addr;
> +
> +     if (!crtc)
> +             return;
> +
> +     DRM_DEBUG_DRIVER("Updating output %d primary plane\n", output);
> +
> +     vcrtc = drm_crtc_to_vs_crtc(crtc);
> +     output = vcrtc->id;
> +     dc = vcrtc->dc;
> +
> +     regmap_update_bits(dc->regs, VSDC_FB_CONFIG_EX(output),
> +                        VSDC_FB_CONFIG_EX_DISPLAY_ID_MASK,
> +                        VSDC_FB_CONFIG_EX_DISPLAY_ID(output));
> +
> +     if (!state->visible || !fb) {
> +             regmap_write(dc->regs, VSDC_FB_CONFIG(output), 0);
> +             regmap_write(dc->regs, VSDC_FB_CONFIG_EX(output), 0);
> +             goto commit;
> +     } else {
> +             regmap_set_bits(dc->regs, VSDC_FB_CONFIG_EX(output),
> +                             VSDC_FB_CONFIG_EX_FB_EN);
> +     }
> +
> +     drm_format_to_vs_format(state->fb->format->format, &fmt);
> +
> +     regmap_update_bits(dc->regs, VSDC_FB_CONFIG(output),
> +                        VSDC_FB_CONFIG_FMT_MASK,
> +                        VSDC_FB_CONFIG_FMT(fmt.color));
> +     regmap_update_bits(dc->regs, VSDC_FB_CONFIG(output),
> +                        VSDC_FB_CONFIG_SWIZZLE_MASK,
> +                        VSDC_FB_CONFIG_SWIZZLE(fmt.swizzle));
> +     regmap_assign_bits(dc->regs, VSDC_FB_CONFIG(output),
> +                        VSDC_FB_CONFIG_UV_SWIZZLE_EN, fmt.uv_swizzle);
> +
> +     /* Get the physical address of the buffer in memory */
> +     gem = drm_fb_dma_get_gem_obj(fb, 0);
> +
> +     /* Compute the start of the displayed memory */
> +     bpp = fb->format->cpp[0];
> +     dma_addr = gem->dma_addr + fb->offsets[0];
> +
> +     /* Fixup framebuffer address for src coordinates */
> +     dma_addr += (state->src.x1 >> 16) * bpp;
> +     dma_addr += (state->src.y1 >> 16) * fb->pitches[0];
> +
> +     regmap_write(dc->regs, VSDC_FB_ADDRESS(output),
> +                  lower_32_bits(dma_addr));
> +     regmap_write(dc->regs, VSDC_FB_STRIDE(output),
> +                  fb->pitches[0]);
> +
> +     regmap_write(dc->regs, VSDC_FB_TOP_LEFT(output),
> +                  VSDC_MAKE_PLANE_POS(state->crtc_x, state->crtc_y));
> +     regmap_write(dc->regs, VSDC_FB_BOTTOM_RIGHT(output),
> +                  VSDC_MAKE_PLANE_POS(state->crtc_x + state->crtc_w,
> +                                      state->crtc_y + state->crtc_h));
> +     regmap_write(dc->regs, VSDC_FB_SIZE(output),
> +                  VSDC_MAKE_PLANE_SIZE(state->crtc_w, state->crtc_h));
> +
> +     regmap_write(dc->regs, VSDC_FB_BLEND_CONFIG(output),
> +                  VSDC_FB_BLEND_CONFIG_BLEND_DISABLE);
> +commit:
> +     regmap_set_bits(dc->regs, VSDC_FB_CONFIG_EX(output),
> +                     VSDC_FB_CONFIG_EX_COMMIT);
> +}
> +
> +static const struct drm_plane_helper_funcs vs_primary_plane_helper_funcs = {
> +     .atomic_check   = vs_primary_plane_atomic_check,
> +     .atomic_update  = vs_primary_plane_atomic_update,
> +};
> +
> +static const struct drm_plane_funcs vs_primary_plane_funcs = {
> +     .atomic_destroy_state   = drm_atomic_helper_plane_destroy_state,
> +     .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
> +     .destroy                = drm_plane_cleanup,
> +     .disable_plane          = drm_atomic_helper_disable_plane,
> +     .reset                  = drm_atomic_helper_plane_reset,
> +     .update_plane           = drm_atomic_helper_update_plane,
> +};
> +
> +struct drm_plane *vs_primary_plane_init(struct drm_device *drm_dev, struct 
> vs_dc *dc)
> +{
> +     struct drm_plane *plane;
> +     int ret;
> +
> +     plane = devm_kzalloc(drm_dev->dev, sizeof(*plane), GFP_KERNEL);
> +     if (!plane)
> +             return ERR_PTR(-ENOMEM);
> +
> +     ret = drm_universal_plane_init(drm_dev, plane, 0,
> +                                    &vs_primary_plane_funcs,
> +                                    dc->identity.formats->array,
> +                                    dc->identity.formats->num,
> +                                    NULL,
> +                                    DRM_PLANE_TYPE_PRIMARY,
> +                                    NULL);
> +
> +     if (ret) {
> +             devm_kfree(drm_dev->dev, plane);
> +             return ERR_PTR(ret);
> +     }
> +
> +     drm_plane_helper_add(plane, &vs_primary_plane_helper_funcs);
> +
> +     return plane;
> +}
> diff --git a/drivers/gpu/drm/verisilicon/vs_primary_plane_regs.h 
> b/drivers/gpu/drm/verisilicon/vs_primary_plane_regs.h
> new file mode 100644
> index 0000000000000..cbb125c46b390
> --- /dev/null
> +++ b/drivers/gpu/drm/verisilicon/vs_primary_plane_regs.h
> @@ -0,0 +1,53 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2025 Icenowy Zheng <u...@icenowy.me>
> + *
> + * Based on vs_dc_hw.h, which is:
> + *   Copyright (C) 2023 VeriSilicon Holdings Co., Ltd.
> + */
> +
> +#ifndef _VS_PRIMARY_PLANE_REGS_H_
> +#define _VS_PRIMARY_PLANE_REGS_H_
> +
> +#include <linux/bits.h>
> +
> +#define VSDC_FB_ADDRESS(n)                   (0x1400 + 0x4 * (n))
> +
> +#define VSDC_FB_STRIDE(n)                    (0x1408 + 0x4 * (n))
> +
> +#define VSDC_FB_CONFIG(n)                    (0x1518 + 0x4 * (n))
> +#define VSDC_FB_CONFIG_CLEAR_EN                      BIT(8)
> +#define VSDC_FB_CONFIG_ROT_MASK                      GENMASK(13, 11)
> +#define VSDC_FB_CONFIG_ROT(v)                        ((v) << 11)
> +#define VSDC_FB_CONFIG_YUV_SPACE_MASK                GENMASK(16, 14)
> +#define VSDC_FB_CONFIG_YUV_SPACE(v)          ((v) << 14)
> +#define VSDC_FB_CONFIG_TILE_MODE_MASK                GENMASK(21, 17)
> +#define VSDC_FB_CONFIG_TILE_MODE(v)          ((v) << 14)
> +#define VSDC_FB_CONFIG_SCALE_EN                      BIT(22)
> +#define VSDC_FB_CONFIG_SWIZZLE_MASK          GENMASK(24, 23)
> +#define VSDC_FB_CONFIG_SWIZZLE(v)            ((v) << 23)
> +#define VSDC_FB_CONFIG_UV_SWIZZLE_EN         BIT(25)
> +#define VSDC_FB_CONFIG_FMT_MASK                      GENMASK(31, 26)
> +#define VSDC_FB_CONFIG_FMT(v)                        ((v) << 26)
> +
> +#define VSDC_FB_SIZE(n)                              (0x1810 + 0x4 * (n))
> +/* Fill with value generated with VSDC_MAKE_PLANE_SIZE(w, h) */
> +
> +#define VSDC_FB_CONFIG_EX(n)                 (0x1CC0 + 0x4 * (n))
> +#define VSDC_FB_CONFIG_EX_COMMIT             BIT(12)
> +#define VSDC_FB_CONFIG_EX_FB_EN                      BIT(13)
> +#define VSDC_FB_CONFIG_EX_ZPOS_MASK          GENMASK(18, 16)
> +#define VSDC_FB_CONFIG_EX_ZPOS(v)            ((v) << 16)
> +#define VSDC_FB_CONFIG_EX_DISPLAY_ID_MASK    GENMASK(19, 19)
> +#define VSDC_FB_CONFIG_EX_DISPLAY_ID(v)              ((v) << 19)
> +
> +#define VSDC_FB_TOP_LEFT(n)                  (0x24D8 + 0x4 * (n))
> +/* Fill with value generated with VSDC_MAKE_PLANE_POS(x, y) */
> +
> +#define VSDC_FB_BOTTOM_RIGHT(n)                      (0x24E0 + 0x4 * (n))
> +/* Fill with value generated with VSDC_MAKE_PLANE_POS(x, y) */
> +
> +#define VSDC_FB_BLEND_CONFIG(n)                      (0x2510 + 0x4 * (n))
> +#define VSDC_FB_BLEND_CONFIG_BLEND_DISABLE   BIT(1)
> +
> +#endif /* _VS_PRIMARY_PLANE_REGS_H_ */
> -- 
> 2.50.1
> 

-- 
With best wishes
Dmitry

Reply via email to