drivers/gpu/drm/hisilicon/kirin/kirin_drm_ade.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Hisilicon Hi6220 SoC ADE(Advanced Display Engine)'s crtc&plane driver
   4  *
   5  * Copyright (c) 2016 Linaro Limited.
   6  * Copyright (c) 2014-2016 Hisilicon Limited.
   7  *
   8  * Author:
   9  *      Xinliang Liu <z.liuxinliang@hisilicon.com>
  10  *      Xinliang Liu <xinliang.liu@linaro.org>
  11  *      Xinwei Kong <kong.kongxinwei@hisilicon.com>
  12  */
  13
  14 #include <linux/bitops.h>
  15 #include <linux/clk.h>
  16 #include <linux/mfd/syscon.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/regmap.h>
  19 #include <linux/reset.h>
  20
  21 #include <video/display_timing.h>
  22
  23 #include <drm/drm_atomic.h>
  24 #include <drm/drm_atomic_helper.h>
  25 #include <drm/drm_crtc.h>
  26 #include <drm/drm_drv.h>
  27 #include <drm/drm_fb_cma_helper.h>
  28 #include <drm/drm_fourcc.h>
  29 #include <drm/drm_gem_cma_helper.h>
  30 #include <drm/drm_plane_helper.h>
  31 #include <drm/drm_probe_helper.h>
  32 #include <drm/drm_vblank.h>
  33 #include <drm/drm_gem_framebuffer_helper.h>
  34
  35 #include "kirin_drm_drv.h"
  36 #include "kirin_ade_reg.h"
  37
  38 #define OUT_OVLY        ADE_OVLY2 /* output overlay compositor */
  39 #define ADE_DEBUG       1
  40
  41
  42 struct ade_hw_ctx {
  43         void __iomem  *base;
  44         struct regmap *noc_regmap;
  45         struct clk *ade_core_clk;
  46         struct clk *media_noc_clk;
  47         struct clk *ade_pix_clk;
  48         struct reset_control *reset;
  49         struct work_struct display_reset_wq;
  50         bool power_on;
  51         int irq;
  52
  53         struct drm_crtc *crtc;
  54 };
  55
  56 struct ade_data {
  57         struct kirin_crtc crtc;
  58         struct kirin_plane planes[ADE_CH_NUM];
  59         struct ade_hw_ctx *hw_ctx;
  60 };
  61
  62 /* ade-format info: */
  63 static const struct kirin_format ade_formats[] = {
  64         /* 16bpp RGB: */
  65         { DRM_FORMAT_RGB565, ADE_RGB_565 },
  66         { DRM_FORMAT_BGR565, ADE_BGR_565 },
  67         /* 24bpp RGB: */
  68         { DRM_FORMAT_RGB888, ADE_RGB_888 },
  69         { DRM_FORMAT_BGR888, ADE_BGR_888 },
  70         /* 32bpp [A]RGB: */
  71         { DRM_FORMAT_XRGB8888, ADE_XRGB_8888 },
  72         { DRM_FORMAT_XBGR8888, ADE_XBGR_8888 },
  73         { DRM_FORMAT_RGBA8888, ADE_RGBA_8888 },
  74         { DRM_FORMAT_BGRA8888, ADE_BGRA_8888 },
  75         { DRM_FORMAT_ARGB8888, ADE_ARGB_8888 },
  76         { DRM_FORMAT_ABGR8888, ADE_ABGR_8888 },
  77 };
  78
  79 static const u32 channel_formats[] = {
  80         /* channel 1,2,3,4 */
  81         DRM_FORMAT_RGB565, DRM_FORMAT_BGR565, DRM_FORMAT_RGB888,
  82         DRM_FORMAT_BGR888, DRM_FORMAT_XRGB8888, DRM_FORMAT_XBGR8888,
  83         DRM_FORMAT_RGBA8888, DRM_FORMAT_BGRA8888, DRM_FORMAT_ARGB8888,
  84         DRM_FORMAT_ABGR8888
  85 };
  86
  87 /* convert from fourcc format to ade format */
  88 static u32 ade_get_format(u32 pixel_format)
  89 {
  90         int i;
  91
  92         for (i = 0; i < ARRAY_SIZE(ade_formats); i++)
  93                 if (ade_formats[i].pixel_format == pixel_format)
  94                         return ade_formats[i].hw_format;
  95
  96         /* not found */
  97         DRM_ERROR("Not found pixel format!!fourcc_format= %d\n",
  98                   pixel_format);
  99         return ADE_FORMAT_UNSUPPORT;
 100 }
 101
 102 static void ade_update_reload_bit(void __iomem *base, u32 bit_num, u32 val)
 103 {
 104         u32 bit_ofst, reg_num;
 105
 106         bit_ofst = bit_num % 32;
 107         reg_num = bit_num / 32;
 108
 109         ade_update_bits(base + ADE_RELOAD_DIS(reg_num), bit_ofst,
 110                         MASK(1), !!val);
 111 }
 112
 113 static u32 ade_read_reload_bit(void __iomem *base, u32 bit_num)
 114 {
 115         u32 tmp, bit_ofst, reg_num;
 116
 117         bit_ofst = bit_num % 32;
 118         reg_num = bit_num / 32;
 119
 120         tmp = readl(base + ADE_RELOAD_DIS(reg_num));
 121         return !!(BIT(bit_ofst) & tmp);
 122 }
 123
 124 static void ade_init(struct ade_hw_ctx *ctx)
 125 {
 126         void __iomem *base = ctx->base;
 127
 128         /* enable clk gate */
 129         ade_update_bits(base + ADE_CTRL1, AUTO_CLK_GATE_EN_OFST,
 130                         AUTO_CLK_GATE_EN, ADE_ENABLE);
 131         /* clear overlay */
 132         writel(0, base + ADE_OVLY1_TRANS_CFG);
 133         writel(0, base + ADE_OVLY_CTL);
 134         writel(0, base + ADE_OVLYX_CTL(OUT_OVLY));
 135         /* clear reset and reload regs */
 136         writel(MASK(32), base + ADE_SOFT_RST_SEL(0));
 137         writel(MASK(32), base + ADE_SOFT_RST_SEL(1));
 138         writel(MASK(32), base + ADE_RELOAD_DIS(0));
 139         writel(MASK(32), base + ADE_RELOAD_DIS(1));
 140         /*
 141          * for video mode, all the ade registers should
 142          * become effective at frame end.
 143          */
 144         ade_update_bits(base + ADE_CTRL, FRM_END_START_OFST,
 145                         FRM_END_START_MASK, REG_EFFECTIVE_IN_ADEEN_FRMEND);
 146         ade_update_bits(base + LDI_INT_EN, UNDERFLOW_INT_EN_OFST, MASK(1), 1);
 147 }
 148
 149 static bool ade_crtc_mode_fixup(struct drm_crtc *crtc,
 150                                 const struct drm_display_mode *mode,
 151                                 struct drm_display_mode *adjusted_mode)
 152 {
 153         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 154         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 155
 156         adjusted_mode->clock =
 157                 clk_round_rate(ctx->ade_pix_clk, mode->clock * 1000) / 1000;
 158         return true;
 159 }
 160
 161
 162 static void ade_set_pix_clk(struct ade_hw_ctx *ctx,
 163                             struct drm_display_mode *mode,
 164                             struct drm_display_mode *adj_mode)
 165 {
 166         u32 clk_Hz = mode->clock * 1000;
 167         int ret;
 168
 169         /*
 170          * Success should be guaranteed in mode_valid call back,
 171          * so failure shouldn't happen here
 172          */
 173         ret = clk_set_rate(ctx->ade_pix_clk, clk_Hz);
 174         if (ret)
 175                 DRM_ERROR("failed to set pixel clk %dHz (%d)\n", clk_Hz, ret);
 176         adj_mode->clock = clk_get_rate(ctx->ade_pix_clk) / 1000;
 177 }
 178
 179 static void ade_ldi_set_mode(struct ade_hw_ctx *ctx,
 180                              struct drm_display_mode *mode,
 181                              struct drm_display_mode *adj_mode)
 182 {
 183         void __iomem *base = ctx->base;
 184         u32 width = mode->hdisplay;
 185         u32 height = mode->vdisplay;
 186         u32 hfp, hbp, hsw, vfp, vbp, vsw;
 187         u32 plr_flags;
 188
 189         plr_flags = (mode->flags & DRM_MODE_FLAG_NVSYNC) ? FLAG_NVSYNC : 0;
 190         plr_flags |= (mode->flags & DRM_MODE_FLAG_NHSYNC) ? FLAG_NHSYNC : 0;
 191         hfp = mode->hsync_start - mode->hdisplay;
 192         hbp = mode->htotal - mode->hsync_end;
 193         hsw = mode->hsync_end - mode->hsync_start;
 194         vfp = mode->vsync_start - mode->vdisplay;
 195         vbp = mode->vtotal - mode->vsync_end;
 196         vsw = mode->vsync_end - mode->vsync_start;
 197         if (vsw > 15) {
 198                 DRM_DEBUG_DRIVER("vsw exceeded 15\n");
 199                 vsw = 15;
 200         }
 201
 202         writel((hbp << HBP_OFST) | hfp, base + LDI_HRZ_CTRL0);
 203          /* the configured value is actual value - 1 */
 204         writel(hsw - 1, base + LDI_HRZ_CTRL1);
 205         writel((vbp << VBP_OFST) | vfp, base + LDI_VRT_CTRL0);
 206          /* the configured value is actual value - 1 */
 207         writel(vsw - 1, base + LDI_VRT_CTRL1);
 208          /* the configured value is actual value - 1 */
 209         writel(((height - 1) << VSIZE_OFST) | (width - 1),
 210                base + LDI_DSP_SIZE);
 211         writel(plr_flags, base + LDI_PLR_CTRL);
 212
 213         /* set overlay compositor output size */
 214         writel(((width - 1) << OUTPUT_XSIZE_OFST) | (height - 1),
 215                base + ADE_OVLY_OUTPUT_SIZE(OUT_OVLY));
 216
 217         /* ctran6 setting */
 218         writel(CTRAN_BYPASS_ON, base + ADE_CTRAN_DIS(ADE_CTRAN6));
 219          /* the configured value is actual value - 1 */
 220         writel(width * height - 1, base + ADE_CTRAN_IMAGE_SIZE(ADE_CTRAN6));
 221         ade_update_reload_bit(base, CTRAN_OFST + ADE_CTRAN6, 0);
 222
 223         ade_set_pix_clk(ctx, mode, adj_mode);
 224
 225         DRM_DEBUG_DRIVER("set mode: %dx%d\n", width, height);
 226 }
 227
 228 static int ade_power_up(struct ade_hw_ctx *ctx)
 229 {
 230         int ret;
 231
 232         ret = clk_prepare_enable(ctx->media_noc_clk);
 233         if (ret) {
 234                 DRM_ERROR("failed to enable media_noc_clk (%d)\n", ret);
 235                 return ret;
 236         }
 237
 238         ret = reset_control_deassert(ctx->reset);
 239         if (ret) {
 240                 DRM_ERROR("failed to deassert reset\n");
 241                 return ret;
 242         }
 243
 244         ret = clk_prepare_enable(ctx->ade_core_clk);
 245         if (ret) {
 246                 DRM_ERROR("failed to enable ade_core_clk (%d)\n", ret);
 247                 return ret;
 248         }
 249
 250         ade_init(ctx);
 251         ctx->power_on = true;
 252         return 0;
 253 }
 254
 255 static void ade_power_down(struct ade_hw_ctx *ctx)
 256 {
 257         void __iomem *base = ctx->base;
 258
 259         writel(ADE_DISABLE, base + LDI_CTRL);
 260         /* dsi pixel off */
 261         writel(DSI_PCLK_OFF, base + LDI_HDMI_DSI_GT);
 262
 263         clk_disable_unprepare(ctx->ade_core_clk);
 264         reset_control_assert(ctx->reset);
 265         clk_disable_unprepare(ctx->media_noc_clk);
 266         ctx->power_on = false;
 267 }
 268
 269 static void ade_set_medianoc_qos(struct ade_hw_ctx *ctx)
 270 {
 271         struct regmap *map = ctx->noc_regmap;
 272
 273         regmap_update_bits(map, ADE0_QOSGENERATOR_MODE,
 274                            QOSGENERATOR_MODE_MASK, BYPASS_MODE);
 275         regmap_update_bits(map, ADE0_QOSGENERATOR_EXTCONTROL,
 276                            SOCKET_QOS_EN, SOCKET_QOS_EN);
 277
 278         regmap_update_bits(map, ADE1_QOSGENERATOR_MODE,
 279                            QOSGENERATOR_MODE_MASK, BYPASS_MODE);
 280         regmap_update_bits(map, ADE1_QOSGENERATOR_EXTCONTROL,
 281                            SOCKET_QOS_EN, SOCKET_QOS_EN);
 282 }
 283
 284 static int ade_crtc_enable_vblank(struct drm_crtc *crtc)
 285 {
 286         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 287         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 288         void __iomem *base = ctx->base;
 289
 290         if (!ctx->power_on)
 291                 (void)ade_power_up(ctx);
 292
 293         ade_update_bits(base + LDI_INT_EN, FRAME_END_INT_EN_OFST,
 294                         MASK(1), 1);
 295
 296         return 0;
 297 }
 298
 299 static void ade_crtc_disable_vblank(struct drm_crtc *crtc)
 300 {
 301         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 302         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 303         void __iomem *base = ctx->base;
 304
 305         if (!ctx->power_on) {
 306                 DRM_ERROR("power is down! vblank disable fail\n");
 307                 return;
 308         }
 309
 310         ade_update_bits(base + LDI_INT_EN, FRAME_END_INT_EN_OFST,
 311                         MASK(1), 0);
 312 }
 313
 314 static void drm_underflow_wq(struct work_struct *work)
 315 {
 316         struct ade_hw_ctx *ctx = container_of(work, struct ade_hw_ctx,
 317                                               display_reset_wq);
 318         struct drm_device *drm_dev = ctx->crtc->dev;
 319         struct drm_atomic_state *state;
 320
 321         state = drm_atomic_helper_suspend(drm_dev);
 322         drm_atomic_helper_resume(drm_dev, state);
 323 }
 324
 325 static irqreturn_t ade_irq_handler(int irq, void *data)
 326 {
 327         struct ade_hw_ctx *ctx = data;
 328         struct drm_crtc *crtc = ctx->crtc;
 329         void __iomem *base = ctx->base;
 330         u32 status;
 331
 332         status = readl(base + LDI_MSK_INT);
 333         DRM_DEBUG_VBL("LDI IRQ: status=0x%X\n", status);
 334
 335         /* vblank irq */
 336         if (status & BIT(FRAME_END_INT_EN_OFST)) {
 337                 ade_update_bits(base + LDI_INT_CLR, FRAME_END_INT_EN_OFST,
 338                                 MASK(1), 1);
 339                 drm_crtc_handle_vblank(crtc);
 340         }
 341         if (status & BIT(UNDERFLOW_INT_EN_OFST)) {
 342                 ade_update_bits(base + LDI_INT_CLR, UNDERFLOW_INT_EN_OFST,
 343                                 MASK(1), 1);
 344                 DRM_ERROR("LDI underflow!");
 345                 schedule_work(&ctx->display_reset_wq);
 346         }
 347
 348         return IRQ_HANDLED;
 349 }
 350
 351 static void ade_display_enable(struct ade_hw_ctx *ctx)
 352 {
 353         void __iomem *base = ctx->base;
 354         u32 out_fmt = LDI_OUT_RGB_888;
 355
 356         /* enable output overlay compositor */
 357         writel(ADE_ENABLE, base + ADE_OVLYX_CTL(OUT_OVLY));
 358         ade_update_reload_bit(base, OVLY_OFST + OUT_OVLY, 0);
 359
 360         /* display source setting */
 361         writel(DISP_SRC_OVLY2, base + ADE_DISP_SRC_CFG);
 362
 363         /* enable ade */
 364         writel(ADE_ENABLE, base + ADE_EN);
 365         /* enable ldi */
 366         writel(NORMAL_MODE, base + LDI_WORK_MODE);
 367         writel((out_fmt << BPP_OFST) | DATA_GATE_EN | LDI_EN,
 368                base + LDI_CTRL);
 369         /* dsi pixel on */
 370         writel(DSI_PCLK_ON, base + LDI_HDMI_DSI_GT);
 371 }
 372
 373 #if ADE_DEBUG
 374 static void ade_rdma_dump_regs(void __iomem *base, u32 ch)
 375 {
 376         u32 reg_ctrl, reg_addr, reg_size, reg_stride, reg_space, reg_en;
 377         u32 val;
 378
 379         reg_ctrl = RD_CH_CTRL(ch);
 380         reg_addr = RD_CH_ADDR(ch);
 381         reg_size = RD_CH_SIZE(ch);
 382         reg_stride = RD_CH_STRIDE(ch);
 383         reg_space = RD_CH_SPACE(ch);
 384         reg_en = RD_CH_EN(ch);
 385
 386         val = ade_read_reload_bit(base, RDMA_OFST + ch);
 387         DRM_DEBUG_DRIVER("[rdma%d]: reload(%d)\n", ch + 1, val);
 388         val = readl(base + reg_ctrl);
 389         DRM_DEBUG_DRIVER("[rdma%d]: reg_ctrl(0x%08x)\n", ch + 1, val);
 390         val = readl(base + reg_addr);
 391         DRM_DEBUG_DRIVER("[rdma%d]: reg_addr(0x%08x)\n", ch + 1, val);
 392         val = readl(base + reg_size);
 393         DRM_DEBUG_DRIVER("[rdma%d]: reg_size(0x%08x)\n", ch + 1, val);
 394         val = readl(base + reg_stride);
 395         DRM_DEBUG_DRIVER("[rdma%d]: reg_stride(0x%08x)\n", ch + 1, val);
 396         val = readl(base + reg_space);
 397         DRM_DEBUG_DRIVER("[rdma%d]: reg_space(0x%08x)\n", ch + 1, val);
 398         val = readl(base + reg_en);
 399         DRM_DEBUG_DRIVER("[rdma%d]: reg_en(0x%08x)\n", ch + 1, val);
 400 }
 401
 402 static void ade_clip_dump_regs(void __iomem *base, u32 ch)
 403 {
 404         u32 val;
 405
 406         val = ade_read_reload_bit(base, CLIP_OFST + ch);
 407         DRM_DEBUG_DRIVER("[clip%d]: reload(%d)\n", ch + 1, val);
 408         val = readl(base + ADE_CLIP_DISABLE(ch));
 409         DRM_DEBUG_DRIVER("[clip%d]: reg_clip_disable(0x%08x)\n", ch + 1, val);
 410         val = readl(base + ADE_CLIP_SIZE0(ch));
 411         DRM_DEBUG_DRIVER("[clip%d]: reg_clip_size0(0x%08x)\n", ch + 1, val);
 412         val = readl(base + ADE_CLIP_SIZE1(ch));
 413         DRM_DEBUG_DRIVER("[clip%d]: reg_clip_size1(0x%08x)\n", ch + 1, val);
 414 }
 415
 416 static void ade_compositor_routing_dump_regs(void __iomem *base, u32 ch)
 417 {
 418         u8 ovly_ch = 0; /* TODO: Only primary plane now */
 419         u32 val;
 420
 421         val = readl(base + ADE_OVLY_CH_XY0(ovly_ch));
 422         DRM_DEBUG_DRIVER("[overlay ch%d]: reg_ch_xy0(0x%08x)\n", ovly_ch, val);
 423         val = readl(base + ADE_OVLY_CH_XY1(ovly_ch));
 424         DRM_DEBUG_DRIVER("[overlay ch%d]: reg_ch_xy1(0x%08x)\n", ovly_ch, val);
 425         val = readl(base + ADE_OVLY_CH_CTL(ovly_ch));
 426         DRM_DEBUG_DRIVER("[overlay ch%d]: reg_ch_ctl(0x%08x)\n", ovly_ch, val);
 427 }
 428
 429 static void ade_dump_overlay_compositor_regs(void __iomem *base, u32 comp)
 430 {
 431         u32 val;
 432
 433         val = ade_read_reload_bit(base, OVLY_OFST + comp);
 434         DRM_DEBUG_DRIVER("[overlay%d]: reload(%d)\n", comp + 1, val);
 435         writel(ADE_ENABLE, base + ADE_OVLYX_CTL(comp));
 436         DRM_DEBUG_DRIVER("[overlay%d]: reg_ctl(0x%08x)\n", comp + 1, val);
 437         val = readl(base + ADE_OVLY_CTL);
 438         DRM_DEBUG_DRIVER("ovly_ctl(0x%08x)\n", val);
 439 }
 440
 441 static void ade_dump_regs(void __iomem *base)
 442 {
 443         u32 i;
 444
 445         /* dump channel regs */
 446         for (i = 0; i < ADE_CH_NUM; i++) {
 447                 /* dump rdma regs */
 448                 ade_rdma_dump_regs(base, i);
 449
 450                 /* dump clip regs */
 451                 ade_clip_dump_regs(base, i);
 452
 453                 /* dump compositor routing regs */
 454                 ade_compositor_routing_dump_regs(base, i);
 455         }
 456
 457         /* dump overlay compositor regs */
 458         ade_dump_overlay_compositor_regs(base, OUT_OVLY);
 459 }
 460 #else
 461 static void ade_dump_regs(void __iomem *base) { }
 462 #endif
 463
 464 static void ade_crtc_atomic_enable(struct drm_crtc *crtc,
 465                                    struct drm_crtc_state *old_state)
 466 {
 467         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 468         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 469         int ret;
 470
 471         if (kcrtc->enable)
 472                 return;
 473
 474         if (!ctx->power_on) {
 475                 ret = ade_power_up(ctx);
 476                 if (ret)
 477                         return;
 478         }
 479
 480         ade_set_medianoc_qos(ctx);
 481         ade_display_enable(ctx);
 482         ade_dump_regs(ctx->base);
 483         drm_crtc_vblank_on(crtc);
 484         kcrtc->enable = true;
 485 }
 486
 487 static void ade_crtc_atomic_disable(struct drm_crtc *crtc,
 488                                     struct drm_crtc_state *old_state)
 489 {
 490         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 491         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 492
 493         if (!kcrtc->enable)
 494                 return;
 495
 496         drm_crtc_vblank_off(crtc);
 497         ade_power_down(ctx);
 498         kcrtc->enable = false;
 499 }
 500
 501 static void ade_crtc_mode_set_nofb(struct drm_crtc *crtc)
 502 {
 503         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 504         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 505         struct drm_display_mode *mode = &crtc->state->mode;
 506         struct drm_display_mode *adj_mode = &crtc->state->adjusted_mode;
 507
 508         if (!ctx->power_on)
 509                 (void)ade_power_up(ctx);
 510         ade_ldi_set_mode(ctx, mode, adj_mode);
 511 }
 512
 513 static void ade_crtc_atomic_begin(struct drm_crtc *crtc,
 514                                   struct drm_crtc_state *old_state)
 515 {
 516         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 517         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 518         struct drm_display_mode *mode = &crtc->state->mode;
 519         struct drm_display_mode *adj_mode = &crtc->state->adjusted_mode;
 520
 521         if (!ctx->power_on)
 522                 (void)ade_power_up(ctx);
 523         ade_ldi_set_mode(ctx, mode, adj_mode);
 524 }
 525
 526 static void ade_crtc_atomic_flush(struct drm_crtc *crtc,
 527                                   struct drm_crtc_state *old_state)
 528
 529 {
 530         struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
 531         struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
 532         struct drm_pending_vblank_event *event = crtc->state->event;
 533         void __iomem *base = ctx->base;
 534
 535         /* only crtc is enabled regs take effect */
 536         if (kcrtc->enable) {
 537                 ade_dump_regs(base);
 538                 /* flush ade registers */
 539                 writel(ADE_ENABLE, base + ADE_EN);
 540         }
 541
 542         if (event) {
 543                 crtc->state->event = NULL;
 544
 545                 spin_lock_irq(&crtc->dev->event_lock);
 546                 if (drm_crtc_vblank_get(crtc) == 0)
 547                         drm_crtc_arm_vblank_event(crtc, event);
 548                 else
 549                         drm_crtc_send_vblank_event(crtc, event);
 550                 spin_unlock_irq(&crtc->dev->event_lock);
 551         }
 552 }
 553
 554 static const struct drm_crtc_helper_funcs ade_crtc_helper_funcs = {
 555         .mode_fixup     = ade_crtc_mode_fixup,
 556         .mode_set_nofb  = ade_crtc_mode_set_nofb,
 557         .atomic_begin   = ade_crtc_atomic_begin,
 558         .atomic_flush   = ade_crtc_atomic_flush,
 559         .atomic_enable  = ade_crtc_atomic_enable,
 560         .atomic_disable = ade_crtc_atomic_disable,
 561 };
 562
 563 static const struct drm_crtc_funcs ade_crtc_funcs = {
 564         .destroy        = drm_crtc_cleanup,
 565         .set_config     = drm_atomic_helper_set_config,
 566         .page_flip      = drm_atomic_helper_page_flip,
 567         .reset          = drm_atomic_helper_crtc_reset,
 568         .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
 569         .atomic_destroy_state   = drm_atomic_helper_crtc_destroy_state,
 570         .enable_vblank  = ade_crtc_enable_vblank,
 571         .disable_vblank = ade_crtc_disable_vblank,
 572 };
 573
 574 static int kirin_drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
 575                                struct drm_plane *plane)
 576 {
 577         struct device_node *port;
 578         int ret;
 579
 580         /* set crtc port so that
 581          * drm_of_find_possible_crtcs call works
 582          */
 583         port = of_get_child_by_name(dev->dev->of_node, "port");
 584         if (!port) {
 585                 DRM_ERROR("no port node found in %pOF\n", dev->dev->of_node);
 586                 return -EINVAL;
 587         }
 588         of_node_put(port);
 589         crtc->port = port;
 590
 591         ret = drm_crtc_init_with_planes(dev, crtc, plane, NULL,
 592                                         ade_driver_data.crtc_funcs, NULL);
 593         if (ret) {
 594                 DRM_ERROR("failed to init crtc.\n");
 595                 return ret;
 596         }
 597
 598         drm_crtc_helper_add(crtc, ade_driver_data.crtc_helper_funcs);
 599
 600         return 0;
 601 }
 602
 603 static void ade_rdma_set(void __iomem *base, struct drm_framebuffer *fb,
 604                          u32 ch, u32 y, u32 in_h, u32 fmt)
 605 {
 606         struct drm_gem_cma_object *obj = drm_fb_cma_get_gem_obj(fb, 0);
 607         struct drm_format_name_buf format_name;
 608         u32 reg_ctrl, reg_addr, reg_size, reg_stride, reg_space, reg_en;
 609         u32 stride = fb->pitches[0];
 610         u32 addr = (u32)obj->paddr + y * stride;
 611
 612         DRM_DEBUG_DRIVER("rdma%d: (y=%d, height=%d), stride=%d, paddr=0x%x\n",
 613                          ch + 1, y, in_h, stride, (u32)obj->paddr);
 614         DRM_DEBUG_DRIVER("addr=0x%x, fb:%dx%d, pixel_format=%d(%s)\n",
 615                          addr, fb->width, fb->height, fmt,
 616                          drm_get_format_name(fb->format->format, &format_name));
 617
 618         /* get reg offset */
 619         reg_ctrl = RD_CH_CTRL(ch);
 620         reg_addr = RD_CH_ADDR(ch);
 621         reg_size = RD_CH_SIZE(ch);
 622         reg_stride = RD_CH_STRIDE(ch);
 623         reg_space = RD_CH_SPACE(ch);
 624         reg_en = RD_CH_EN(ch);
 625
 626         /*
 627          * TODO: set rotation
 628          */
 629         writel((fmt << 16) & 0x1f0000, base + reg_ctrl);
 630         writel(addr, base + reg_addr);
 631         writel((in_h << 16) | stride, base + reg_size);
 632         writel(stride, base + reg_stride);
 633         writel(in_h * stride, base + reg_space);
 634         writel(ADE_ENABLE, base + reg_en);
 635         ade_update_reload_bit(base, RDMA_OFST + ch, 0);
 636 }
 637
 638 static void ade_rdma_disable(void __iomem *base, u32 ch)
 639 {
 640         u32 reg_en;
 641
 642         /* get reg offset */
 643         reg_en = RD_CH_EN(ch);
 644         writel(0, base + reg_en);
 645         ade_update_reload_bit(base, RDMA_OFST + ch, 1);
 646 }
 647
 648 static void ade_clip_set(void __iomem *base, u32 ch, u32 fb_w, u32 x,
 649                          u32 in_w, u32 in_h)
 650 {
 651         u32 disable_val;
 652         u32 clip_left;
 653         u32 clip_right;
 654
 655         /*
 656          * clip width, no need to clip height
 657          */
 658         if (fb_w == in_w) { /* bypass */
 659                 disable_val = 1;
 660                 clip_left = 0;
 661                 clip_right = 0;
 662         } else {
 663                 disable_val = 0;
 664                 clip_left = x;
 665                 clip_right = fb_w - (x + in_w) - 1;
 666         }
 667
 668         DRM_DEBUG_DRIVER("clip%d: clip_left=%d, clip_right=%d\n",
 669                          ch + 1, clip_left, clip_right);
 670
 671         writel(disable_val, base + ADE_CLIP_DISABLE(ch));
 672         writel((fb_w - 1) << 16 | (in_h - 1), base + ADE_CLIP_SIZE0(ch));
 673         writel(clip_left << 16 | clip_right, base + ADE_CLIP_SIZE1(ch));
 674         ade_update_reload_bit(base, CLIP_OFST + ch, 0);
 675 }
 676
 677 static void ade_clip_disable(void __iomem *base, u32 ch)
 678 {
 679         writel(1, base + ADE_CLIP_DISABLE(ch));
 680         ade_update_reload_bit(base, CLIP_OFST + ch, 1);
 681 }
 682
 683 static bool has_Alpha_channel(int format)
 684 {
 685         switch (format) {
 686         case ADE_ARGB_8888:
 687         case ADE_ABGR_8888:
 688         case ADE_RGBA_8888:
 689         case ADE_BGRA_8888:
 690                 return true;
 691         default:
 692                 return false;
 693         }
 694 }
 695
 696 static void ade_get_blending_params(u32 fmt, u8 glb_alpha, u8 *alp_mode,
 697                                     u8 *alp_sel, u8 *under_alp_sel)
 698 {
 699         bool has_alpha = has_Alpha_channel(fmt);
 700
 701         /*
 702          * get alp_mode
 703          */
 704         if (has_alpha && glb_alpha < 255)
 705                 *alp_mode = ADE_ALP_PIXEL_AND_GLB;
 706         else if (has_alpha)
 707                 *alp_mode = ADE_ALP_PIXEL;
 708         else
 709                 *alp_mode = ADE_ALP_GLOBAL;
 710
 711         /*
 712          * get alp sel
 713          */
 714         *alp_sel = ADE_ALP_MUL_COEFF_3; /* 1 */
 715         *under_alp_sel = ADE_ALP_MUL_COEFF_2; /* 0 */
 716 }
 717
 718 static void ade_compositor_routing_set(void __iomem *base, u8 ch,
 719                                        u32 x0, u32 y0,
 720                                        u32 in_w, u32 in_h, u32 fmt)
 721 {
 722         u8 ovly_ch = 0; /* TODO: This is the zpos, only one plane now */
 723         u8 glb_alpha = 255;
 724         u32 x1 = x0 + in_w - 1;
 725         u32 y1 = y0 + in_h - 1;
 726         u32 val;
 727         u8 alp_sel;
 728         u8 under_alp_sel;
 729         u8 alp_mode;
 730
 731         ade_get_blending_params(fmt, glb_alpha, &alp_mode, &alp_sel,
 732                                 &under_alp_sel);
 733
 734         /* overlay routing setting
 735          */
 736         writel(x0 << 16 | y0, base + ADE_OVLY_CH_XY0(ovly_ch));
 737         writel(x1 << 16 | y1, base + ADE_OVLY_CH_XY1(ovly_ch));
 738         val = (ch + 1) << CH_SEL_OFST | BIT(CH_EN_OFST) |
 739                 alp_sel << CH_ALP_SEL_OFST |
 740                 under_alp_sel << CH_UNDER_ALP_SEL_OFST |
 741                 glb_alpha << CH_ALP_GBL_OFST |
 742                 alp_mode << CH_ALP_MODE_OFST;
 743         writel(val, base + ADE_OVLY_CH_CTL(ovly_ch));
 744         /* connect this plane/channel to overlay2 compositor */
 745         ade_update_bits(base + ADE_OVLY_CTL, CH_OVLY_SEL_OFST(ovly_ch),
 746                         CH_OVLY_SEL_MASK, CH_OVLY_SEL_VAL(OUT_OVLY));
 747 }
 748
 749 static void ade_compositor_routing_disable(void __iomem *base, u32 ch)
 750 {
 751         u8 ovly_ch = 0; /* TODO: Only primary plane now */
 752
 753         /* disable this plane/channel */
 754         ade_update_bits(base + ADE_OVLY_CH_CTL(ovly_ch), CH_EN_OFST,
 755                         MASK(1), 0);
 756         /* dis-connect this plane/channel of overlay2 compositor */
 757         ade_update_bits(base + ADE_OVLY_CTL, CH_OVLY_SEL_OFST(ovly_ch),
 758                         CH_OVLY_SEL_MASK, 0);
 759 }
 760
 761 /*
 762  * Typicaly, a channel looks like: DMA-->clip-->scale-->ctrans-->compositor
 763  */
 764 static void ade_update_channel(struct kirin_plane *kplane,
 765                                struct drm_framebuffer *fb, int crtc_x,
 766                                int crtc_y, unsigned int crtc_w,
 767                                unsigned int crtc_h, u32 src_x,
 768                                u32 src_y, u32 src_w, u32 src_h)
 769 {
 770         struct ade_hw_ctx *ctx = kplane->hw_ctx;
 771         void __iomem *base = ctx->base;
 772         u32 fmt = ade_get_format(fb->format->format);
 773         u32 ch = kplane->ch;
 774         u32 in_w;
 775         u32 in_h;
 776
 777         DRM_DEBUG_DRIVER("channel%d: src:(%d, %d)-%dx%d, crtc:(%d, %d)-%dx%d",
 778                          ch + 1, src_x, src_y, src_w, src_h,
 779                          crtc_x, crtc_y, crtc_w, crtc_h);
 780
 781         /* 1) DMA setting */
 782         in_w = src_w;
 783         in_h = src_h;
 784         ade_rdma_set(base, fb, ch, src_y, in_h, fmt);
 785
 786         /* 2) clip setting */
 787         ade_clip_set(base, ch, fb->width, src_x, in_w, in_h);
 788
 789         /* 3) TODO: scale setting for overlay planes */
 790
 791         /* 4) TODO: ctran/csc setting for overlay planes */
 792
 793         /* 5) compositor routing setting */
 794         ade_compositor_routing_set(base, ch, crtc_x, crtc_y, in_w, in_h, fmt);
 795 }
 796
 797 static void ade_disable_channel(struct kirin_plane *kplane)
 798 {
 799         struct ade_hw_ctx *ctx = kplane->hw_ctx;
 800         void __iomem *base = ctx->base;
 801         u32 ch = kplane->ch;
 802
 803         DRM_DEBUG_DRIVER("disable channel%d\n", ch + 1);
 804
 805         /* disable read DMA */
 806         ade_rdma_disable(base, ch);
 807
 808         /* disable clip */
 809         ade_clip_disable(base, ch);
 810
 811         /* disable compositor routing */
 812         ade_compositor_routing_disable(base, ch);
 813 }
 814
 815 static int ade_plane_atomic_check(struct drm_plane *plane,
 816                                   struct drm_plane_state *state)
 817 {
 818         struct drm_framebuffer *fb = state->fb;
 819         struct drm_crtc *crtc = state->crtc;
 820         struct drm_crtc_state *crtc_state;
 821         u32 src_x = state->src_x >> 16;
 822         u32 src_y = state->src_y >> 16;
 823         u32 src_w = state->src_w >> 16;
 824         u32 src_h = state->src_h >> 16;
 825         int crtc_x = state->crtc_x;
 826         int crtc_y = state->crtc_y;
 827         u32 crtc_w = state->crtc_w;
 828         u32 crtc_h = state->crtc_h;
 829         u32 fmt;
 830
 831         if (!crtc || !fb)
 832                 return 0;
 833
 834         fmt = ade_get_format(fb->format->format);
 835         if (fmt == ADE_FORMAT_UNSUPPORT)
 836                 return -EINVAL;
 837
 838         crtc_state = drm_atomic_get_crtc_state(state->state, crtc);
 839         if (IS_ERR(crtc_state))
 840                 return PTR_ERR(crtc_state);
 841
 842         if (src_w != crtc_w || src_h != crtc_h) {
 843                 return -EINVAL;
 844         }
 845
 846         if (src_x + src_w > fb->width ||
 847             src_y + src_h > fb->height)
 848                 return -EINVAL;
 849
 850         if (crtc_x < 0 || crtc_y < 0)
 851                 return -EINVAL;
 852
 853         if (crtc_x + crtc_w > crtc_state->adjusted_mode.hdisplay ||
 854             crtc_y + crtc_h > crtc_state->adjusted_mode.vdisplay)
 855                 return -EINVAL;
 856
 857         return 0;
 858 }
 859
 860 static void ade_plane_atomic_update(struct drm_plane *plane,
 861                                     struct drm_plane_state *old_state)
 862 {
 863         struct drm_plane_state *state = plane->state;
 864         struct kirin_plane *kplane = to_kirin_plane(plane);
 865
 866         ade_update_channel(kplane, state->fb, state->crtc_x, state->crtc_y,
 867                            state->crtc_w, state->crtc_h,
 868                            state->src_x >> 16, state->src_y >> 16,
 869                            state->src_w >> 16, state->src_h >> 16);
 870 }
 871
 872 static void ade_plane_atomic_disable(struct drm_plane *plane,
 873                                      struct drm_plane_state *old_state)
 874 {
 875         struct kirin_plane *kplane = to_kirin_plane(plane);
 876
 877         ade_disable_channel(kplane);
 878 }
 879
 880 static const struct drm_plane_helper_funcs ade_plane_helper_funcs = {
 881         .atomic_check = ade_plane_atomic_check,
 882         .atomic_update = ade_plane_atomic_update,
 883         .atomic_disable = ade_plane_atomic_disable,
 884 };
 885
 886 static struct drm_plane_funcs ade_plane_funcs = {
 887         .update_plane   = drm_atomic_helper_update_plane,
 888         .disable_plane  = drm_atomic_helper_disable_plane,
 889         .destroy = drm_plane_cleanup,
 890         .reset = drm_atomic_helper_plane_reset,
 891         .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
 892         .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
 893 };
 894
 895 static int kirin_drm_plane_init(struct drm_device *dev,
 896                                 struct kirin_plane *kplane,
 897                                 enum drm_plane_type type)
 898 {
 899         int ret = 0;
 900
 901         ret = drm_universal_plane_init(dev, &kplane->base, 1,
 902                                        ade_driver_data.plane_funcs,
 903                                        ade_driver_data.channel_formats,
 904                                        ade_driver_data.channel_formats_cnt,
 905                                        NULL, type, NULL);
 906         if (ret) {
 907                 DRM_ERROR("fail to init plane, ch=%d\n", kplane->ch);
 908                 return ret;
 909         }
 910
 911         drm_plane_helper_add(&kplane->base, ade_driver_data.plane_helper_funcs);
 912
 913         return 0;
 914 }
 915
 916 static void *ade_hw_ctx_alloc(struct platform_device *pdev,
 917                               struct drm_crtc *crtc)
 918 {
 919         struct resource *res;
 920         struct device *dev = &pdev->dev;
 921         struct device_node *np = pdev->dev.of_node;
 922         struct ade_hw_ctx *ctx = NULL;
 923         int ret;
 924
 925         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
 926         if (!ctx) {
 927                 DRM_ERROR("failed to alloc ade_hw_ctx\n");
 928                 return ERR_PTR(-ENOMEM);
 929         }
 930
 931         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 932         ctx->base = devm_ioremap_resource(dev, res);
 933         if (IS_ERR(ctx->base)) {
 934                 DRM_ERROR("failed to remap ade io base\n");
 935                 return ERR_PTR(-EIO);
 936         }
 937
 938         ctx->reset = devm_reset_control_get(dev, NULL);
 939         if (IS_ERR(ctx->reset))
 940                 return ERR_PTR(-ENODEV);
 941
 942         ctx->noc_regmap =
 943                 syscon_regmap_lookup_by_phandle(np, "hisilicon,noc-syscon");
 944         if (IS_ERR(ctx->noc_regmap)) {
 945                 DRM_ERROR("failed to get noc regmap\n");
 946                 return ERR_PTR(-ENODEV);
 947         }
 948
 949         ctx->irq = platform_get_irq(pdev, 0);
 950         if (ctx->irq < 0) {
 951                 DRM_ERROR("failed to get irq\n");
 952                 return ERR_PTR(-ENODEV);
 953         }
 954
 955         ctx->ade_core_clk = devm_clk_get(dev, "clk_ade_core");
 956         if (IS_ERR(ctx->ade_core_clk)) {
 957                 DRM_ERROR("failed to parse clk ADE_CORE\n");
 958                 return ERR_PTR(-ENODEV);
 959         }
 960
 961         ctx->media_noc_clk = devm_clk_get(dev, "clk_codec_jpeg");
 962         if (IS_ERR(ctx->media_noc_clk)) {
 963                 DRM_ERROR("failed to parse clk CODEC_JPEG\n");
 964                 return ERR_PTR(-ENODEV);
 965         }
 966
 967         ctx->ade_pix_clk = devm_clk_get(dev, "clk_ade_pix");
 968         if (IS_ERR(ctx->ade_pix_clk)) {
 969                 DRM_ERROR("failed to parse clk ADE_PIX\n");
 970                 return ERR_PTR(-ENODEV);
 971         }
 972
 973         /* vblank irq init */
 974         ret = devm_request_irq(dev, ctx->irq, ade_irq_handler,
 975                                IRQF_SHARED, dev->driver->name, ctx);
 976         if (ret)
 977                 return ERR_PTR(-EIO);
 978
 979         INIT_WORK(&ctx->display_reset_wq, drm_underflow_wq);
 980         ctx->crtc = crtc;
 981
 982         return ctx;
 983 }
 984
 985 static int ade_drm_init(struct platform_device *pdev)
 986 {
 987         struct drm_device *dev = platform_get_drvdata(pdev);
 988         struct ade_data *ade;
 989         struct ade_hw_ctx *ctx;
 990         struct kirin_crtc *kcrtc;
 991         struct kirin_plane *kplane;
 992         enum drm_plane_type type;
 993         int prim_plane;
 994         int ret;
 995         u32 ch;
 996
 997         ade = devm_kzalloc(dev->dev, sizeof(*ade), GFP_KERNEL);
 998         if (!ade) {
 999                 DRM_ERROR("failed to alloc ade_data\n");
1000                 return -ENOMEM;
1001         }
1002
1003         ctx = ade_hw_ctx_alloc(pdev, &ade->crtc.base);
1004         if (IS_ERR(ctx)) {
1005                 DRM_ERROR("failed to initialize kirin_priv hw ctx\n");
1006                 return -EINVAL;
1007         }
1008         ade->hw_ctx = ctx;
1009
1010         kcrtc = &ade->crtc;
1011         kcrtc->hw_ctx = ctx;
1012
1013         /*
1014          * plane init
1015          * TODO: Now only support primary plane, overlay planes
1016          * need to do.
1017          */
1018         for (ch = 0; ch < ade_driver_data.num_planes; ch++) {
1019                 kplane = &ade->planes[ch];
1020                 kplane->ch = ch;
1021                 kplane->hw_ctx = ctx;
1022
1023                 if (ch == ade_driver_data.prim_plane)
1024                         type = DRM_PLANE_TYPE_PRIMARY;
1025                 else
1026                         type = DRM_PLANE_TYPE_OVERLAY;
1027
1028                 ret = kirin_drm_plane_init(dev, kplane, type);
1029                 if (ret)
1030                         return ret;
1031         }
1032
1033         /* crtc init */
1034         prim_plane = ade_driver_data.prim_plane;
1035         ret = kirin_drm_crtc_init(dev, &kcrtc->base,
1036                                   &ade->planes[prim_plane].base);
1037         if (ret)
1038                 return ret;
1039
1040         return 0;
1041 }
1042
1043 static void ade_drm_cleanup(struct platform_device *pdev)
1044 {
1045 }
1046
1047 static const struct drm_mode_config_funcs ade_mode_config_funcs = {
1048         .fb_create = drm_gem_fb_create,
1049         .atomic_check = drm_atomic_helper_check,
1050         .atomic_commit = drm_atomic_helper_commit,
1051
1052 };
1053
1054 DEFINE_DRM_GEM_CMA_FOPS(ade_fops);
1055
1056 static struct drm_driver ade_driver = {
1057         .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
1058         .fops = &ade_fops,
1059         .gem_free_object_unlocked = drm_gem_cma_free_object,
1060         .gem_vm_ops = &drm_gem_cma_vm_ops,
1061         .dumb_create = drm_gem_cma_dumb_create_internal,
1062         .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
1063         .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
1064         .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
1065         .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
1066         .gem_prime_vmap = drm_gem_cma_prime_vmap,
1067         .gem_prime_vunmap = drm_gem_cma_prime_vunmap,
1068         .gem_prime_mmap = drm_gem_cma_prime_mmap,
1069
1070         .name = "kirin",
1071         .desc = "Hisilicon Kirin620 SoC DRM Driver",
1072         .date = "20150718",
1073         .major = 1,
1074         .minor = 0,
1075 };
1076
1077 struct kirin_drm_data ade_driver_data = {
1078         .register_connects = false,
1079         .num_planes = ADE_CH_NUM,
1080         .prim_plane = ADE_CH1,
1081         .channel_formats = channel_formats,
1082         .channel_formats_cnt = ARRAY_SIZE(channel_formats),
1083         .config_max_width = 2048,
1084         .config_max_height = 2048,
1085         .driver = &ade_driver,
1086         .crtc_helper_funcs = &ade_crtc_helper_funcs,
1087         .crtc_funcs = &ade_crtc_funcs,
1088         .plane_helper_funcs = &ade_plane_helper_funcs,
1089         .plane_funcs = &ade_plane_funcs,
1090         .mode_config_funcs = &ade_mode_config_funcs,
1091
1092         .init = ade_drm_init,
1093         .cleanup = ade_drm_cleanup
1094 };