#define OUT_OVLY       ADE_OVLY2 /* output overlay compositor */
 #define ADE_DEBUG      1
 
-#define to_ade_crtc(crtc) \
-       container_of(crtc, struct ade_crtc, base)
+#define to_kirin_crtc(crtc) \
+       container_of(crtc, struct kirin_crtc, base)
 
 #define to_kirin_plane(plane) \
        container_of(plane, struct kirin_plane, base)
        int irq;
 };
 
-struct ade_crtc {
+struct kirin_crtc {
        struct drm_crtc base;
-       struct ade_hw_ctx *ctx;
+       void *hw_ctx;
        struct work_struct display_reset_wq;
        bool enable;
 };
 };
 
 struct ade_data {
-       struct ade_crtc acrtc;
+       struct kirin_crtc crtc;
        struct kirin_plane planes[ADE_CH_NUM];
        struct ade_hw_ctx ctx;
 };
                                const struct drm_display_mode *mode,
                                struct drm_display_mode *adjusted_mode)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 
        adjusted_mode->clock =
                clk_round_rate(ctx->ade_pix_clk, mode->clock * 1000) / 1000;
 
 static int ade_crtc_enable_vblank(struct drm_crtc *crtc)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
        void __iomem *base = ctx->base;
 
        if (!ctx->power_on)
 
 static void ade_crtc_disable_vblank(struct drm_crtc *crtc)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
        void __iomem *base = ctx->base;
 
        if (!ctx->power_on) {
 
 static void drm_underflow_wq(struct work_struct *work)
 {
-       struct ade_crtc *acrtc = container_of(work, struct ade_crtc,
+       struct kirin_crtc *acrtc = container_of(work, struct kirin_crtc,
                                              display_reset_wq);
        struct drm_device *drm_dev = (&acrtc->base)->dev;
        struct drm_atomic_state *state;
 
 static irqreturn_t ade_irq_handler(int irq, void *data)
 {
-       struct ade_crtc *acrtc = data;
-       struct ade_hw_ctx *ctx = acrtc->ctx;
-       struct drm_crtc *crtc = &acrtc->base;
+       struct kirin_crtc *kcrtc = data;
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
+       struct drm_crtc *crtc = &kcrtc->base;
        void __iomem *base = ctx->base;
        u32 status;
 
                ade_update_bits(base + LDI_INT_CLR, UNDERFLOW_INT_EN_OFST,
                                MASK(1), 1);
                DRM_ERROR("LDI underflow!");
-               schedule_work(&acrtc->display_reset_wq);
+               schedule_work(&kcrtc->display_reset_wq);
        }
 
        return IRQ_HANDLED;
 static void ade_crtc_atomic_enable(struct drm_crtc *crtc,
                                   struct drm_crtc_state *old_state)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
        int ret;
 
-       if (acrtc->enable)
+       if (kcrtc->enable)
                return;
 
        if (!ctx->power_on) {
        ade_display_enable(ctx);
        ade_dump_regs(ctx->base);
        drm_crtc_vblank_on(crtc);
-       acrtc->enable = true;
+       kcrtc->enable = true;
 }
 
 static void ade_crtc_atomic_disable(struct drm_crtc *crtc,
                                    struct drm_crtc_state *old_state)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 
-       if (!acrtc->enable)
+       if (!kcrtc->enable)
                return;
 
        drm_crtc_vblank_off(crtc);
        ade_power_down(ctx);
-       acrtc->enable = false;
+       kcrtc->enable = false;
 }
 
 static void ade_crtc_mode_set_nofb(struct drm_crtc *crtc)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
        struct drm_display_mode *mode = &crtc->state->mode;
        struct drm_display_mode *adj_mode = &crtc->state->adjusted_mode;
 
 static void ade_crtc_atomic_begin(struct drm_crtc *crtc,
                                  struct drm_crtc_state *old_state)
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
        struct drm_display_mode *mode = &crtc->state->mode;
        struct drm_display_mode *adj_mode = &crtc->state->adjusted_mode;
 
                                  struct drm_crtc_state *old_state)
 
 {
-       struct ade_crtc *acrtc = to_ade_crtc(crtc);
-       struct ade_hw_ctx *ctx = acrtc->ctx;
+       struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
+       struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
        struct drm_pending_vblank_event *event = crtc->state->event;
        void __iomem *base = ctx->base;
 
        /* only crtc is enabled regs take effect */
-       if (acrtc->enable) {
+       if (kcrtc->enable) {
                ade_dump_regs(base);
                /* flush ade registers */
                writel(ADE_ENABLE, base + ADE_EN);
        struct drm_device *dev = platform_get_drvdata(pdev);
        struct ade_data *ade;
        struct ade_hw_ctx *ctx;
-       struct ade_crtc *acrtc;
+       struct kirin_crtc *kcrtc;
        struct kirin_plane *kplane;
        enum drm_plane_type type;
        int ret;
        platform_set_drvdata(pdev, ade);
 
        ctx = &ade->ctx;
-       acrtc = &ade->acrtc;
-       acrtc->ctx = ctx;
+       kcrtc = &ade->crtc;
+       kcrtc->hw_ctx = ctx;
 
        ret = ade_dts_parse(pdev, ctx);
        if (ret)
        }
 
        /* crtc init */
-       ret = ade_crtc_init(dev, &acrtc->base, &ade->planes[PRIMARY_CH].base);
+       ret = ade_crtc_init(dev, &kcrtc->base, &ade->planes[PRIMARY_CH].base);
        if (ret)
                return ret;
 
        /* vblank irq init */
        ret = devm_request_irq(dev->dev, ctx->irq, ade_irq_handler,
-                              IRQF_SHARED, dev->driver->name, acrtc);
+                              IRQF_SHARED, dev->driver->name, kcrtc);
 
-       INIT_WORK(&acrtc->display_reset_wq, drm_underflow_wq);
+       INIT_WORK(&kcrtc->display_reset_wq, drm_underflow_wq);
 
        if (ret)
                return ret;