From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 22B20C83016 for ; Mon, 30 Nov 2020 14:29:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C196B206B6 for ; Mon, 30 Nov 2020 14:29:19 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="cGez0gcr" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727584AbgK3O3Q (ORCPT ); Mon, 30 Nov 2020 09:29:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47282 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727359AbgK3O3P (ORCPT ); Mon, 30 Nov 2020 09:29:15 -0500 Received: from mail-pj1-x1042.google.com (mail-pj1-x1042.google.com [IPv6:2607:f8b0:4864:20::1042]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 67FBAC0613D4 for ; Mon, 30 Nov 2020 06:28:55 -0800 (PST) Received: by mail-pj1-x1042.google.com with SMTP id v1so1437312pjr.2 for ; Mon, 30 Nov 2020 06:28:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=XxoJ/fBCpTNXMczMA7eAAjHKOEOEU3vuTs7aWQh2Gss=; b=cGez0gcr5TvXg7wt6Xz3BUTOzIkO7I1a9fRYYZri0s3oMYUnRNhjvHJ1tEkImq8duI sO6Iqj6BXnindcZJKO3kA+zJ0NYkm6HORiEPQQfMF1AJGKFA8Srlpv4lAnL081cRINOk vworUVnlMWabOu/3R7he28TOibLg1u4DPopJSRV0IoDsyJOM1jNkhlB3pg+1Tu6q8lSf DIgAqjox99j+aorRFXJRomkcrhRX2c19f4u68Y4HZFURYkRRK5rm6rkNx9Ywv/Q8xnXu 3GZFAWHa5x/gVmoTlnB31QTURUhWTAT13BOxILqMwe8UWPvX6KuOro8bNGcecFeNcMkE SBPw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=XxoJ/fBCpTNXMczMA7eAAjHKOEOEU3vuTs7aWQh2Gss=; b=LfKknb6zWphEbED+cUSP7hqpI5m8MrJUw+bAIyX0xQQlOFinXzWaLUIak1tn7wvGrc KFfzoJyC7J0RzvDZvCJsxlyN1LTbGiFQSzMPrs2cpqSU5Li9tlR+LcWAyDjWYeHf8g0p Mz16Df2ibAbFgOOqky3bfUi50cmO3eF2j9holqueyBKlsJpjlzUHlu05UeAqslmIo76L 0OfRBMjT6FoAEP8wTb2jGWt6C6VkkGt2/pU4K792RE1Fe4rAnvxLwPlmrEdGerhimBhB Crb+qBDnXNmO5310ctTrIXNzISdYl/jjALaiQ/RC4AnuIwHpFmW2rMA0L8xGNgTAX5/6 58AQ== X-Gm-Message-State: AOAM531/N7xcSlmkm6ZjCDWv6ORtCceSBUKATrdccjkGf9vhcN/Cz299 Y/+xt2wKELMkOfMat9pebU7P2NLZzcg= X-Google-Smtp-Source: ABdhPJy2MfX/8/BQrVzeiEhjhTyMypN4L/YiOx4QjAd2UPOTQdaekF7HDZQIdCf/Q7BoIDmr1JZ1tA== X-Received: by 2002:a17:90a:ec0e:: with SMTP id l14mr26862428pjy.123.1606746534793; Mon, 30 Nov 2020 06:28:54 -0800 (PST) Received: from nj08008nbu.spreadtrum.com ([117.18.48.82]) by smtp.gmail.com with ESMTPSA id 17sm15580479pfh.173.2020.11.30.06.28.51 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 30 Nov 2020 06:28:54 -0800 (PST) From: Kevin Tang To: maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, airlied@linux.ie, daniel@ffwll.ch, robh+dt@kernel.org, mark.rutland@arm.com, kevin3.tang@gmail.com Cc: orsonzhai@gmail.com, zhang.lyra@gmail.com, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [PATCH 4/6] drm/sprd: add Unisoc's drm display controller driver Date: Mon, 30 Nov 2020 22:28:31 +0800 Message-Id: <1606746513-30909-5-git-send-email-kevin3.tang@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1606746513-30909-1-git-send-email-kevin3.tang@gmail.com> References: <1606746513-30909-1-git-send-email-kevin3.tang@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Adds DPU(Display Processor Unit) support for the Unisoc's display subsystem. It's support multi planes, scaler, rotation, PQ(Picture Quality) and more. Cc: Orson Zhai Cc: Chunyan Zhang Signed-off-by: Kevin Tang --- drivers/gpu/drm/sprd/Kconfig | 1 + drivers/gpu/drm/sprd/Makefile | 6 +- drivers/gpu/drm/sprd/dpu_r2p0.c | 598 ++++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/sprd/sprd_dpu.c | 457 ++++++++++++++++++++++++++++++ drivers/gpu/drm/sprd/sprd_dpu.h | 175 ++++++++++++ drivers/gpu/drm/sprd/sprd_drm.c | 1 + drivers/gpu/drm/sprd/sprd_drm.h | 2 + 7 files changed, 1238 insertions(+), 2 deletions(-) create mode 100644 drivers/gpu/drm/sprd/dpu_r2p0.c create mode 100644 drivers/gpu/drm/sprd/sprd_dpu.c create mode 100644 drivers/gpu/drm/sprd/sprd_dpu.h diff --git a/drivers/gpu/drm/sprd/Kconfig b/drivers/gpu/drm/sprd/Kconfig index 6e80cc9..9b4ef9a 100644 --- a/drivers/gpu/drm/sprd/Kconfig +++ b/drivers/gpu/drm/sprd/Kconfig @@ -3,6 +3,7 @@ config DRM_SPRD depends on ARCH_SPRD || COMPILE_TEST depends on DRM && OF select DRM_KMS_HELPER + select VIDEOMODE_HELPERS select DRM_GEM_CMA_HELPER select DRM_KMS_CMA_HELPER select DRM_MIPI_DSI diff --git a/drivers/gpu/drm/sprd/Makefile b/drivers/gpu/drm/sprd/Makefile index 86d95d9..0ba48f2 100644 --- a/drivers/gpu/drm/sprd/Makefile +++ b/drivers/gpu/drm/sprd/Makefile @@ -1,5 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 -subdir-ccflags-y += -I$(srctree)/$(src) +obj-y := sprd_drm.o \ + sprd_dpu.o + +obj-y += dpu_r2p0.o -obj-y := sprd_drm.o diff --git a/drivers/gpu/drm/sprd/dpu_r2p0.c b/drivers/gpu/drm/sprd/dpu_r2p0.c new file mode 100644 index 0000000..46ab8b3 --- /dev/null +++ b/drivers/gpu/drm/sprd/dpu_r2p0.c @@ -0,0 +1,598 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2020 Unisoc Inc. + */ + +#include +#include +#include +#include + +#include "sprd_dpu.h" + +/* Global control registers */ +#define REG_DPU_CTRL 0x04 +#define REG_DPU_CFG0 0x08 +#define REG_DPU_CFG1 0x0C +#define REG_DPU_CFG2 0x10 +#define REG_PANEL_SIZE 0x20 +#define REG_BLEND_SIZE 0x24 +#define REG_BG_COLOR 0x2C + +/* Layer0 control registers */ +#define REG_LAY_BASE_ADDR0 0x30 +#define REG_LAY_BASE_ADDR1 0x34 +#define REG_LAY_BASE_ADDR2 0x38 +#define REG_LAY_CTRL 0x40 +#define REG_LAY_SIZE 0x44 +#define REG_LAY_PITCH 0x48 +#define REG_LAY_POS 0x4C +#define REG_LAY_ALPHA 0x50 +#define REG_LAY_PALLETE 0x58 +#define REG_LAY_CROP_START 0x5C + +/* Interrupt control registers */ +#define REG_DPU_INT_EN 0x1E0 +#define REG_DPU_INT_CLR 0x1E4 +#define REG_DPU_INT_STS 0x1E8 + +/* DPI control registers */ +#define REG_DPI_CTRL 0x1F0 +#define REG_DPI_H_TIMING 0x1F4 +#define REG_DPI_V_TIMING 0x1F8 + +/* MMU control registers */ +#define REG_MMU_EN 0x800 +#define REG_MMU_VPN_RANGE 0x80C +#define REG_MMU_VAOR_ADDR_RD 0x818 +#define REG_MMU_VAOR_ADDR_WR 0x81C +#define REG_MMU_INV_ADDR_RD 0x820 +#define REG_MMU_INV_ADDR_WR 0x824 +#define REG_MMU_PPN1 0x83C +#define REG_MMU_RANGE1 0x840 +#define REG_MMU_PPN2 0x844 +#define REG_MMU_RANGE2 0x848 + +/* Global control bits */ +#define BIT_DPU_RUN BIT(0) +#define BIT_DPU_STOP BIT(1) +#define BIT_DPU_REG_UPDATE BIT(2) +#define BIT_DPU_IF_EDPI BIT(0) +#define BIT_DPU_COEF_NARROW_RANGE BIT(4) +#define BIT_DPU_Y2R_COEF_ITU709_STANDARD BIT(5) + +/* Layer control bits */ +#define BIT_DPU_LAY_EN BIT(0) +#define BIT_DPU_LAY_LAYER_ALPHA (0x01 << 2) +#define BIT_DPU_LAY_COMBO_ALPHA (0x02 << 2) +#define BIT_DPU_LAY_FORMAT_YUV422_2PLANE (0x00 << 4) +#define BIT_DPU_LAY_FORMAT_YUV420_2PLANE (0x01 << 4) +#define BIT_DPU_LAY_FORMAT_YUV420_3PLANE (0x02 << 4) +#define BIT_DPU_LAY_FORMAT_ARGB8888 (0x03 << 4) +#define BIT_DPU_LAY_FORMAT_RGB565 (0x04 << 4) +#define BIT_DPU_LAY_DATA_ENDIAN_B0B1B2B3 (0x00 << 8) +#define BIT_DPU_LAY_DATA_ENDIAN_B3B2B1B0 (0x01 << 8) +#define BIT_DPU_LAY_NO_SWITCH (0x00 << 10) +#define BIT_DPU_LAY_RB_OR_UV_SWITCH (0x01 << 10) +#define BIT_DPU_LAY_MODE_BLEND_NORMAL (0x00 << 16) +#define BIT_DPU_LAY_MODE_BLEND_PREMULT (0x01 << 16) + +/* Interrupt control & status bits */ +#define BIT_DPU_INT_DONE BIT(0) +#define BIT_DPU_INT_TE BIT(1) +#define BIT_DPU_INT_ERR BIT(2) +#define BIT_DPU_INT_UPDATE_DONE BIT(4) +#define BIT_DPU_INT_VSYNC BIT(5) +#define BIT_DPU_INT_FBC_PLD_ERR BIT(8) +#define BIT_DPU_INT_FBC_HDR_ERR BIT(9) +#define BIT_DPU_INT_MMU_VAOR_RD BIT(16) +#define BIT_DPU_INT_MMU_VAOR_WR BIT(17) +#define BIT_DPU_INT_MMU_INV_RD BIT(18) +#define BIT_DPU_INT_MMU_INV_WR BIT(19) + +/* DPI control bits */ +#define BIT_DPU_EDPI_TE_EN BIT(8) +#define BIT_DPU_EDPI_FROM_EXTERNAL_PAD BIT(10) +#define BIT_DPU_DPI_HALT_EN BIT(16) + +static const u32 primary_fmts[] = { + DRM_FORMAT_XRGB8888, + DRM_FORMAT_XBGR8888, + DRM_FORMAT_ARGB8888, + DRM_FORMAT_ABGR8888, + DRM_FORMAT_RGBA8888, + DRM_FORMAT_BGRA8888, + DRM_FORMAT_RGBX8888, + DRM_FORMAT_RGB565, + DRM_FORMAT_BGR565, + DRM_FORMAT_NV12, + DRM_FORMAT_NV21, + DRM_FORMAT_NV16, + DRM_FORMAT_NV61, + DRM_FORMAT_YUV420, + DRM_FORMAT_YVU420, +}; + +static u32 check_mmu_isr(struct dpu_context *ctx, u32 reg_val) +{ + u32 mmu_mask = BIT_DPU_INT_MMU_VAOR_RD | + BIT_DPU_INT_MMU_VAOR_WR | + BIT_DPU_INT_MMU_INV_RD | + BIT_DPU_INT_MMU_INV_WR; + u32 val = reg_val & mmu_mask; + int i; + + if (val) { + DRM_ERROR("--- iommu interrupt err: 0x%04x ---\n", val); + + if (val & BIT_DPU_INT_MMU_INV_RD) + DRM_ERROR("iommu invalid read error, addr: 0x%08x\n", + readl_relaxed(ctx->base + REG_MMU_INV_ADDR_RD)); + if (val & BIT_DPU_INT_MMU_INV_WR) + DRM_ERROR("iommu invalid write error, addr: 0x%08x\n", + readl_relaxed(ctx->base + REG_MMU_INV_ADDR_WR)); + if (val & BIT_DPU_INT_MMU_VAOR_RD) + DRM_ERROR("iommu va out of range read error, addr: 0x%08x\n", + readl_relaxed(ctx->base + REG_MMU_VAOR_ADDR_RD)); + if (val & BIT_DPU_INT_MMU_VAOR_WR) + DRM_ERROR("iommu va out of range write error, addr: 0x%08x\n", + readl_relaxed(ctx->base + REG_MMU_VAOR_ADDR_WR)); + + for (i = 0; i < 8; i++) { + reg_val = layer_reg_rd(ctx, REG_LAY_CTRL, i); + if (reg_val & 0x1) + DRM_INFO("layer%d: 0x%08x 0x%08x 0x%08x ctrl: 0x%08x\n", i, + layer_reg_rd(ctx, REG_LAY_BASE_ADDR0, i), + layer_reg_rd(ctx, REG_LAY_BASE_ADDR1, i), + layer_reg_rd(ctx, REG_LAY_BASE_ADDR2, i), + layer_reg_rd(ctx, REG_LAY_CTRL, i)); + } + } + + return val; +} + +static void dpu_clean_all(struct dpu_context *ctx) +{ + int i; + + for (i = 0; i < 8; i++) + layer_reg_wr(ctx, REG_LAY_CTRL, 0x00, i); +} + +static int dpu_wait_stop_done(struct dpu_context *ctx) +{ + int rc; + + if (ctx->stopped) + return 0; + + rc = wait_event_interruptible_timeout(ctx->wait_queue, ctx->evt_stop, + msecs_to_jiffies(500)); + ctx->evt_stop = false; + + ctx->stopped = true; + + if (!rc) { + DRM_ERROR("dpu wait for stop done time out!\n"); + return -ETIMEDOUT; + } + + return 0; +} + +static int dpu_wait_update_done(struct dpu_context *ctx) +{ + int rc; + + ctx->evt_update = false; + + rc = wait_event_interruptible_timeout(ctx->wait_queue, ctx->evt_update, + msecs_to_jiffies(500)); + + if (!rc) { + DRM_ERROR("dpu wait for reg update done time out!\n"); + return -ETIMEDOUT; + } + + return 0; +} + +static void dpu_layer(struct dpu_context *ctx, struct dpu_layer *hwlayer) +{ + u32 size, offset, ctrl; + int i; + + offset = (hwlayer->dst_x & 0xffff) | ((hwlayer->dst_y) << 16); + size = (hwlayer->src_w & 0xffff) | ((hwlayer->src_h) << 16); + + for (i = 0; i < hwlayer->planes; i++) + layer_reg_wr(ctx, REG_LAY_BASE_ADDR0, hwlayer->addr[i], hwlayer->index); + + layer_reg_wr(ctx, REG_LAY_POS, offset, hwlayer->index); + layer_reg_wr(ctx, REG_LAY_SIZE, size, hwlayer->index); + layer_reg_wr(ctx, REG_LAY_CROP_START, + hwlayer->src_y << 16 | hwlayer->src_x, hwlayer->index); + layer_reg_wr(ctx, REG_LAY_ALPHA, hwlayer->alpha, hwlayer->index); + layer_reg_wr(ctx, REG_LAY_PITCH, hwlayer->pitch, hwlayer->index); + + ctrl = hwlayer->format | + hwlayer->blending | + (hwlayer->rotation & 0x7) << 20; + + layer_reg_wr(ctx, REG_LAY_CTRL, ctrl | BIT_DPU_LAY_EN, hwlayer->index); +} + +u32 sprd_dpu_isr(struct dpu_context *ctx) +{ + u32 reg_val, int_mask = 0; + + reg_val = readl_relaxed(ctx->base + REG_DPU_INT_STS); + + /* disable err interrupt */ + if (reg_val & BIT_DPU_INT_ERR) + int_mask |= BIT_DPU_INT_ERR; + + /* dpu update done isr */ + if (reg_val & BIT_DPU_INT_UPDATE_DONE) { + ctx->evt_update = true; + wake_up_interruptible_all(&ctx->wait_queue); + } + + /* dpu stop done isr */ + if (reg_val & BIT_DPU_INT_DONE) { + ctx->evt_stop = true; + wake_up_interruptible_all(&ctx->wait_queue); + } + + /* dpu ifbc payload error isr */ + if (reg_val & BIT_DPU_INT_FBC_PLD_ERR) { + int_mask |= BIT_DPU_INT_FBC_PLD_ERR; + DRM_ERROR("dpu ifbc payload error\n"); + } + + /* dpu ifbc header error isr */ + if (reg_val & BIT_DPU_INT_FBC_HDR_ERR) { + int_mask |= BIT_DPU_INT_FBC_HDR_ERR; + DRM_ERROR("dpu ifbc header error\n"); + } + + int_mask |= check_mmu_isr(ctx, reg_val); + + writel_relaxed(reg_val, ctx->base + REG_DPU_INT_CLR); + dpu_reg_clr(ctx, REG_DPU_INT_EN, int_mask); + + return reg_val; +} + +int sprd_dpu_img_ctrl(struct dpu_layer *layer, u32 format, u32 angle, u32 blend) +{ + switch (format) { + case DRM_FORMAT_BGRA8888: + /* BGRA8888 -> ARGB8888 */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B3B2B1B0; + layer->format |= BIT_DPU_LAY_FORMAT_ARGB8888; + break; + case DRM_FORMAT_RGBX8888: + case DRM_FORMAT_RGBA8888: + /* RGBA8888 -> ABGR8888 */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B3B2B1B0; + /* FALLTHRU */ + case DRM_FORMAT_ABGR8888: + /* RB switch */ + layer->format |= BIT_DPU_LAY_RB_OR_UV_SWITCH; + /* FALLTHRU */ + case DRM_FORMAT_ARGB8888: + layer->format |= BIT_DPU_LAY_FORMAT_ARGB8888; + break; + case DRM_FORMAT_XBGR8888: + /* RB switch */ + layer->format |= BIT_DPU_LAY_RB_OR_UV_SWITCH; + /* FALLTHRU */ + case DRM_FORMAT_XRGB8888: + layer->format |= BIT_DPU_LAY_FORMAT_ARGB8888; + break; + case DRM_FORMAT_BGR565: + /* RB switch */ + layer->format |= BIT_DPU_LAY_RB_OR_UV_SWITCH; + /* FALLTHRU */ + case DRM_FORMAT_RGB565: + layer->format |= BIT_DPU_LAY_FORMAT_RGB565; + break; + case DRM_FORMAT_NV12: + /* 2-Lane: Yuv420 */ + layer->format |= BIT_DPU_LAY_FORMAT_YUV420_2PLANE; + /* Y endian */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B0B1B2B3; + /* UV endian */ + layer->format |= BIT_DPU_LAY_NO_SWITCH; + break; + case DRM_FORMAT_NV21: + /* 2-Lane: Yuv420 */ + layer->format |= BIT_DPU_LAY_FORMAT_YUV420_2PLANE; + /* Y endian */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B0B1B2B3; + /* UV endian */ + layer->format |= BIT_DPU_LAY_RB_OR_UV_SWITCH; + break; + case DRM_FORMAT_NV16: + /* 2-Lane: Yuv422 */ + layer->format |= BIT_DPU_LAY_FORMAT_YUV422_2PLANE; + /* Y endian */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B3B2B1B0; + /* UV endian */ + layer->format |= BIT_DPU_LAY_RB_OR_UV_SWITCH; + break; + case DRM_FORMAT_NV61: + /* 2-Lane: Yuv422 */ + layer->format |= BIT_DPU_LAY_FORMAT_YUV422_2PLANE; + /* Y endian */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B0B1B2B3; + /* UV endian */ + layer->format |= BIT_DPU_LAY_NO_SWITCH; + break; + case DRM_FORMAT_YUV420: + layer->format |= BIT_DPU_LAY_FORMAT_YUV420_3PLANE; + /* Y endian */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B0B1B2B3; + /* UV endian */ + layer->format |= BIT_DPU_LAY_NO_SWITCH; + break; + case DRM_FORMAT_YVU420: + layer->format |= BIT_DPU_LAY_FORMAT_YUV420_3PLANE; + /* Y endian */ + layer->format |= BIT_DPU_LAY_DATA_ENDIAN_B0B1B2B3; + /* UV endian */ + layer->format |= BIT_DPU_LAY_RB_OR_UV_SWITCH; + break; + default: + DRM_ERROR("invalid format %c%c%c%c\n", format, + format >> 8, + format >> 16, + format >> 24); + return -EINVAL; + } + + switch (angle) { + case DRM_MODE_ROTATE_0: + layer->rotation = DPU_LAYER_ROTATION_0; + break; + case DRM_MODE_ROTATE_90: + layer->rotation = DPU_LAYER_ROTATION_90; + break; + case DRM_MODE_ROTATE_180: + layer->rotation = DPU_LAYER_ROTATION_180; + break; + case DRM_MODE_ROTATE_270: + layer->rotation = DPU_LAYER_ROTATION_270; + break; + case DRM_MODE_REFLECT_Y: + layer->rotation = DPU_LAYER_ROTATION_180_M; + break; + case (DRM_MODE_REFLECT_Y | DRM_MODE_ROTATE_90): + layer->rotation = DPU_LAYER_ROTATION_90_M; + break; + case DRM_MODE_REFLECT_X: + layer->rotation = DPU_LAYER_ROTATION_0_M; + break; + case (DRM_MODE_REFLECT_X | DRM_MODE_ROTATE_90): + layer->rotation = DPU_LAYER_ROTATION_270_M; + break; + default: + DRM_ERROR("rotation convert unsupport angle (drm)= 0x%x\n", angle); + return -EINVAL; + } + + switch (blend) { + case DRM_MODE_BLEND_COVERAGE: + /* alpha mode select - combo alpha */ + layer->blending |= BIT_DPU_LAY_COMBO_ALPHA; + /* Normal mode */ + layer->blending |= BIT_DPU_LAY_MODE_BLEND_NORMAL; + break; + case DRM_MODE_BLEND_PREMULTI: + /* alpha mode select - combo alpha */ + layer->blending |= BIT_DPU_LAY_COMBO_ALPHA; + /* Pre-mult mode */ + layer->blending |= BIT_DPU_LAY_MODE_BLEND_PREMULT; + break; + case DRM_MODE_BLEND_PIXEL_NONE: + default: + /* don't do blending, maybe RGBX */ + /* alpha mode select - layer alpha */ + layer->blending |= BIT_DPU_LAY_LAYER_ALPHA; + break; + } + + return 0; +} + +void sprd_dpu_flip(struct dpu_context *ctx, + struct dpu_layer layers[], u8 count) +{ + int i; + u32 reg_val; + + /* + * Make sure the dpu is in stop status. DPU_R2P0 has no shadow + * registers in EDPI mode. So the config registers can only be + * updated in the rising edge of DPU_RUN bit. + */ + if (ctx->if_type == SPRD_DPU_IF_EDPI) + dpu_wait_stop_done(ctx); + + /* reset the bgcolor to black */ + writel_relaxed(0x00, ctx->base + REG_BG_COLOR); + + /* disable all the layers */ + dpu_clean_all(ctx); + + /* start configure dpu layers */ + for (i = 0; i < count; i++) + dpu_layer(ctx, &layers[i]); + + /* update trigger and wait */ + if (ctx->if_type == SPRD_DPU_IF_DPI) { + if (!ctx->stopped) { + dpu_reg_set(ctx, REG_DPU_CTRL, BIT_DPU_REG_UPDATE); + dpu_wait_update_done(ctx); + } + + dpu_reg_set(ctx, REG_DPU_INT_EN, BIT_DPU_INT_ERR); + } else if (ctx->if_type == SPRD_DPU_IF_EDPI) { + dpu_reg_set(ctx, REG_DPU_CTRL, BIT_DPU_RUN); + + ctx->stopped = false; + } + + /* + * If the following interrupt was disabled in isr, + * re-enable it. + */ + reg_val = BIT_DPU_INT_FBC_PLD_ERR | + BIT_DPU_INT_FBC_HDR_ERR | + BIT_DPU_INT_MMU_VAOR_RD | + BIT_DPU_INT_MMU_VAOR_WR | + BIT_DPU_INT_MMU_INV_RD | + BIT_DPU_INT_MMU_INV_WR; + dpu_reg_set(ctx, REG_DPU_INT_EN, reg_val); +} + +void sprd_dpu_init(struct dpu_context *ctx) +{ + u32 reg_val, size; + + writel_relaxed(0x00, ctx->base + REG_BG_COLOR); + + size = (ctx->vm.vactive << 16) | ctx->vm.hactive; + + writel_relaxed(size, ctx->base + REG_PANEL_SIZE); + writel_relaxed(size, ctx->base + REG_BLEND_SIZE); + + reg_val = BIT_DPU_COEF_NARROW_RANGE | BIT_DPU_Y2R_COEF_ITU709_STANDARD; + writel_relaxed(reg_val, ctx->base + REG_DPU_CFG0); + writel_relaxed(0x004466da, ctx->base + REG_DPU_CFG1); + writel_relaxed(0x00, ctx->base + REG_DPU_CFG2); + + if (ctx->stopped) + dpu_clean_all(ctx); + + writel_relaxed(0x00, ctx->base + REG_MMU_EN); + writel_relaxed(0x00, ctx->base + REG_MMU_PPN1); + writel_relaxed(0xffff, ctx->base + REG_MMU_RANGE1); + writel_relaxed(0x00, ctx->base + REG_MMU_PPN2); + writel_relaxed(0xffff, ctx->base + REG_MMU_RANGE2); + writel_relaxed(0x1ffff, ctx->base + REG_MMU_VPN_RANGE); + + writel_relaxed(0xffff, ctx->base + REG_DPU_INT_CLR); +} + +void sprd_dpu_fini(struct dpu_context *ctx) +{ + writel_relaxed(0x00, ctx->base + REG_DPU_INT_EN); + writel_relaxed(0xff, ctx->base + REG_DPU_INT_CLR); +} + +void sprd_dpi_init(struct dpu_context *ctx) +{ + u32 int_mask = 0; + u32 reg_val; + + if (ctx->if_type == SPRD_DPU_IF_DPI) { + /* use dpi as interface */ + dpu_reg_clr(ctx, REG_DPU_CFG0, BIT_DPU_IF_EDPI); + + /* disable Halt function for SPRD DSI */ + dpu_reg_clr(ctx, REG_DPI_CTRL, BIT_DPU_DPI_HALT_EN); + + /* select te from external pad */ + dpu_reg_set(ctx, REG_DPI_CTRL, BIT_DPU_EDPI_FROM_EXTERNAL_PAD); + + /* set dpi timing */ + reg_val = ctx->vm.hsync_len << 0 | + ctx->vm.hback_porch << 8 | + ctx->vm.hfront_porch << 20; + writel_relaxed(reg_val, ctx->base + REG_DPI_H_TIMING); + + reg_val = ctx->vm.vsync_len << 0 | + ctx->vm.vback_porch << 8 | + ctx->vm.vfront_porch << 20; + writel_relaxed(reg_val, ctx->base + REG_DPI_V_TIMING); + + if (ctx->vm.vsync_len + ctx->vm.vback_porch < 32) + DRM_WARN("Warning: (vsync + vbp) < 32, " + "underflow risk!\n"); + + /* enable dpu update done INT */ + int_mask |= BIT_DPU_INT_UPDATE_DONE; + /* enable dpu DONE INT */ + int_mask |= BIT_DPU_INT_DONE; + /* enable dpu dpi vsync */ + int_mask |= BIT_DPU_INT_VSYNC; + /* enable dpu TE INT */ + int_mask |= BIT_DPU_INT_TE; + /* enable underflow err INT */ + int_mask |= BIT_DPU_INT_ERR; + } else if (ctx->if_type == SPRD_DPU_IF_EDPI) { + /* use edpi as interface */ + dpu_reg_set(ctx, REG_DPU_CFG0, BIT_DPU_IF_EDPI); + + /* use external te */ + dpu_reg_set(ctx, REG_DPI_CTRL, BIT_DPU_EDPI_FROM_EXTERNAL_PAD); + + /* enable te */ + dpu_reg_set(ctx, REG_DPI_CTRL, BIT_DPU_EDPI_TE_EN); + + /* enable stop DONE INT */ + int_mask |= BIT_DPU_INT_DONE; + /* enable TE INT */ + int_mask |= BIT_DPU_INT_TE; + } + + /* enable ifbc payload error INT */ + int_mask |= BIT_DPU_INT_FBC_PLD_ERR; + /* enable ifbc header error INT */ + int_mask |= BIT_DPU_INT_FBC_HDR_ERR; + /* enable iommu va out of range read error INT */ + int_mask |= BIT_DPU_INT_MMU_VAOR_RD; + /* enable iommu va out of range write error INT */ + int_mask |= BIT_DPU_INT_MMU_VAOR_WR; + /* enable iommu invalid read error INT */ + int_mask |= BIT_DPU_INT_MMU_INV_RD; + /* enable iommu invalid write error INT */ + int_mask |= BIT_DPU_INT_MMU_INV_WR; + + writel_relaxed(int_mask, ctx->base + REG_DPU_INT_EN); +} + +void sprd_dpu_run(struct dpu_context *ctx) +{ + dpu_reg_set(ctx, REG_DPU_CTRL, BIT_DPU_RUN); + + ctx->stopped = false; +} + +void sprd_dpu_stop(struct dpu_context *ctx) +{ + if (ctx->if_type == SPRD_DPU_IF_DPI) + dpu_reg_set(ctx, REG_DPU_CTRL, BIT_DPU_STOP); + + dpu_wait_stop_done(ctx); +} + +void sprd_dpu_enable_vsync(struct dpu_context *ctx) +{ + dpu_reg_set(ctx, REG_DPU_INT_EN, BIT_DPU_INT_VSYNC); +} + +void sprd_dpu_disable_vsync(struct dpu_context *ctx) +{ + dpu_reg_clr(ctx, REG_DPU_INT_EN, BIT_DPU_INT_VSYNC); +} + +void sprd_dpu_capability(struct dpu_context *ctx, struct dpu_capability *cap) +{ + cap->max_layers = 6; + cap->fmts_ptr = primary_fmts; + cap->fmts_cnt = ARRAY_SIZE(primary_fmts); +} diff --git a/drivers/gpu/drm/sprd/sprd_dpu.c b/drivers/gpu/drm/sprd/sprd_dpu.c new file mode 100644 index 0000000..1aa2a34 --- /dev/null +++ b/drivers/gpu/drm/sprd/sprd_dpu.c @@ -0,0 +1,457 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2020 Unisoc Inc. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "sprd_drm.h" +#include "sprd_dpu.h" + +struct sprd_plane { + struct drm_plane plane; + u32 index; +}; + +static inline struct sprd_plane *to_sprd_plane(struct drm_plane *plane) +{ + return container_of(plane, struct sprd_plane, plane); +} + +static int sprd_plane_atomic_check(struct drm_plane *plane, + struct drm_plane_state *state) +{ + struct sprd_plane *p = to_sprd_plane(plane); + struct drm_framebuffer *fb = state->fb; + struct drm_crtc_state *crtc_state; + struct drm_gem_cma_object *cma_obj; + const struct drm_format_info *info; + struct sprd_dpu *dpu; + struct dpu_layer *layer; + int i, ret; + u32 addr; + + if (!fb || !state->crtc) + return 0; + + crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc); + if (IS_ERR(crtc_state)) + return PTR_ERR(crtc_state); + + dpu = to_sprd_crtc(state->crtc); + layer = &dpu->layers[p->index]; + + ret = sprd_dpu_img_ctrl(layer, fb->format->format, + state->rotation, state->pixel_blend_mode); + if (ret) + return ret; + + layer->index = p->index; + layer->src_x = state->src_x >> 16; + layer->src_y = state->src_y >> 16; + layer->src_w = state->src_w >> 16; + layer->src_h = state->src_h >> 16; + layer->dst_x = state->crtc_x; + layer->dst_y = state->crtc_y; + layer->alpha = state->alpha; + layer->planes = fb->format->num_planes; + + for (i = 0; i < fb->format->num_planes; i++) { + cma_obj = drm_fb_cma_get_gem_obj(fb, i); + addr = cma_obj->paddr + fb->offsets[i]; + if (addr % 16) { + DRM_ERROR("layer addr[%d] is not 16 bytes align, it's 0x%08x\n", + i, addr); + return -EFAULT; + } + + layer->addr[i] = addr; + } + + info = drm_format_info(fb->format->format); + if (fb->format->num_planes == 3) { + /* UV pitch is 1/2 of Y pitch */ + layer->pitch = (fb->pitches[0] / info->cpp[0]) | + (fb->pitches[0] / info->cpp[0] << 15); + } else { + layer->pitch = fb->pitches[0] / info->cpp[0]; + } + + dpu->pending_planes++; + + return 0; +} + +/* plane doesn't represent a real HW, so there is no HW update for plane. + * dpu handles all the HW update in crtc->atomic_flush + */ +static void sprd_plane_atomic_update(struct drm_plane *plane, + struct drm_plane_state *old_state) +{ + DRM_DEBUG("%s()\n", __func__); +} + +static void sprd_plane_create_properties(struct sprd_plane *p, int index) +{ + unsigned int supported_modes = BIT(DRM_MODE_BLEND_PIXEL_NONE) | + BIT(DRM_MODE_BLEND_PREMULTI) | + BIT(DRM_MODE_BLEND_COVERAGE); + + /* create rotation property */ + drm_plane_create_rotation_property(&p->plane, + DRM_MODE_ROTATE_0, + DRM_MODE_ROTATE_MASK | + DRM_MODE_REFLECT_MASK); + + /* create alpha property */ + drm_plane_create_alpha_property(&p->plane); + + /* create blend mode property */ + drm_plane_create_blend_mode_property(&p->plane, supported_modes); + + /* create zpos property */ + drm_plane_create_zpos_immutable_property(&p->plane, index); +} + +static const struct drm_plane_helper_funcs sprd_plane_helper_funcs = { + .atomic_check = sprd_plane_atomic_check, + .atomic_update = sprd_plane_atomic_update, +}; + +static const struct drm_plane_funcs sprd_plane_funcs = { + .update_plane = drm_atomic_helper_update_plane, + .disable_plane = drm_atomic_helper_disable_plane, + .destroy = drm_plane_cleanup, + .reset = drm_atomic_helper_plane_reset, + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, +}; + +static struct drm_plane *sprd_plane_init(struct drm_device *drm, + struct sprd_dpu *dpu) +{ + struct drm_plane *primary = NULL; + struct sprd_plane *p = NULL; + struct dpu_capability cap = {}; + int ret, i; + + sprd_dpu_capability(&dpu->ctx, &cap); + + dpu->layers = devm_kcalloc(drm->dev, cap.max_layers, + sizeof(struct dpu_layer), GFP_KERNEL); + if (!dpu->layers) + return ERR_PTR(-ENOMEM); + + for (i = 0; i < cap.max_layers; i++) { + + p = devm_kzalloc(drm->dev, sizeof(*p), GFP_KERNEL); + if (!p) + return ERR_PTR(-ENOMEM); + + ret = drm_universal_plane_init(drm, &p->plane, 1, + &sprd_plane_funcs, cap.fmts_ptr, + cap.fmts_cnt, NULL, + DRM_PLANE_TYPE_PRIMARY, NULL); + if (ret) { + DRM_ERROR("fail to init primary plane\n"); + return ERR_PTR(ret); + } + + drm_plane_helper_add(&p->plane, &sprd_plane_helper_funcs); + + sprd_plane_create_properties(p, i); + + p->index = i; + if (i == 0) + primary = &p->plane; + } + + return primary; +} + +static enum drm_mode_status sprd_crtc_mode_valid(struct drm_crtc *crtc, + const struct drm_display_mode *mode) +{ + struct sprd_dpu *dpu = to_sprd_crtc(crtc); + + DRM_DEBUG("%s() mode: "DRM_MODE_FMT"\n", __func__, DRM_MODE_ARG(mode)); + + if (mode->type & DRM_MODE_TYPE_PREFERRED) { + drm_display_mode_to_videomode(mode, &dpu->ctx.vm); + + if ((mode->hdisplay == mode->htotal) || + (mode->vdisplay == mode->vtotal)) + dpu->ctx.if_type = SPRD_DPU_IF_EDPI; + else + dpu->ctx.if_type = SPRD_DPU_IF_DPI; + } + + return MODE_OK; +} + +static void sprd_crtc_atomic_enable(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) +{ + struct sprd_dpu *dpu = to_sprd_crtc(crtc); + + sprd_dpu_init(&dpu->ctx); + + sprd_dpi_init(&dpu->ctx); + + enable_irq(dpu->ctx.irq); + + drm_crtc_vblank_on(&dpu->crtc); +} + +static void sprd_crtc_atomic_disable(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) +{ + struct sprd_dpu *dpu = to_sprd_crtc(crtc); + struct drm_device *drm = dpu->crtc.dev; + + drm_crtc_vblank_off(&dpu->crtc); + + disable_irq(dpu->ctx.irq); + + sprd_dpu_fini(&dpu->ctx); + + spin_lock_irq(&drm->event_lock); + if (crtc->state->event) { + drm_crtc_send_vblank_event(crtc, crtc->state->event); + crtc->state->event = NULL; + } + spin_unlock_irq(&drm->event_lock); +} + +static int sprd_crtc_atomic_check(struct drm_crtc *crtc, + struct drm_crtc_state *state) +{ + DRM_DEBUG("%s()\n", __func__); + + return 0; +} + +static void sprd_crtc_atomic_flush(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) + +{ + struct sprd_dpu *dpu = to_sprd_crtc(crtc); + struct drm_device *drm = dpu->crtc.dev; + + if (dpu->pending_planes) + sprd_dpu_flip(&dpu->ctx, dpu->layers, dpu->pending_planes); + + spin_lock_irq(&drm->event_lock); + if (crtc->state->event) { + drm_crtc_send_vblank_event(crtc, crtc->state->event); + crtc->state->event = NULL; + } + spin_unlock_irq(&drm->event_lock); + + dpu->pending_planes = 0; +} + +static int sprd_crtc_enable_vblank(struct drm_crtc *crtc) +{ + struct sprd_dpu *dpu = to_sprd_crtc(crtc); + + sprd_dpu_enable_vsync(&dpu->ctx); + + return 0; +} + +static void sprd_crtc_disable_vblank(struct drm_crtc *crtc) +{ + struct sprd_dpu *dpu = to_sprd_crtc(crtc); + + sprd_dpu_disable_vsync(&dpu->ctx); +} + +static const struct drm_crtc_helper_funcs sprd_crtc_helper_funcs = { + .mode_valid = sprd_crtc_mode_valid, + .atomic_check = sprd_crtc_atomic_check, + .atomic_flush = sprd_crtc_atomic_flush, + .atomic_enable = sprd_crtc_atomic_enable, + .atomic_disable = sprd_crtc_atomic_disable, +}; + +static const struct drm_crtc_funcs sprd_crtc_funcs = { + .destroy = drm_crtc_cleanup, + .set_config = drm_atomic_helper_set_config, + .page_flip = drm_atomic_helper_page_flip, + .reset = drm_atomic_helper_crtc_reset, + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, + .enable_vblank = sprd_crtc_enable_vblank, + .disable_vblank = sprd_crtc_disable_vblank, +}; + +static int sprd_crtc_init(struct drm_device *drm, struct drm_crtc *crtc, + struct drm_plane *primary) +{ + struct device_node *port; + int ret; + + /* + * set crtc port so that drm_of_find_possible_crtcs call works + */ + port = of_parse_phandle(drm->dev->of_node, "ports", 0); + if (!port) { + DRM_ERROR("find 'ports' phandle of %s failed\n", + drm->dev->of_node->full_name); + return -EINVAL; + } + of_node_put(port); + crtc->port = port; + + ret = drm_crtc_init_with_planes(drm, crtc, primary, NULL, + &sprd_crtc_funcs, NULL); + if (ret) { + DRM_ERROR("failed to init crtc.\n"); + return ret; + } + + drm_crtc_helper_add(crtc, &sprd_crtc_helper_funcs); + + return 0; +} + +static irqreturn_t sprd_dpu_isr_handler(int irq, void *data) +{ + struct sprd_dpu *dpu = data; + struct dpu_context *ctx = &dpu->ctx; + u32 int_mask = 0; + + int_mask = sprd_dpu_isr(ctx); + + if (int_mask & BIT_DPU_INT_ERR) + DRM_WARN("Warning: dpu underflow!\n"); + + if (int_mask & BIT_DPU_INT_VSYNC) + drm_crtc_handle_vblank(&dpu->crtc); + + return IRQ_HANDLED; +} + +static int sprd_dpu_bind(struct device *dev, struct device *master, void *data) +{ + struct drm_device *drm = data; + struct sprd_dpu *dpu = dev_get_drvdata(dev); + struct drm_plane *plane; + int ret; + + plane = sprd_plane_init(drm, dpu); + if (IS_ERR_OR_NULL(plane)) { + ret = PTR_ERR(plane); + return ret; + } + + ret = sprd_crtc_init(drm, &dpu->crtc, plane); + if (ret) + return ret; + + return 0; +} + +static void sprd_dpu_unbind(struct device *dev, struct device *master, + void *data) +{ + struct sprd_dpu *dpu = dev_get_drvdata(dev); + + drm_crtc_cleanup(&dpu->crtc); +} + +static const struct component_ops dpu_component_ops = { + .bind = sprd_dpu_bind, + .unbind = sprd_dpu_unbind, +}; + +static int sprd_dpu_context_init(struct sprd_dpu *dpu, + struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct dpu_context *ctx = &dpu->ctx; + struct resource *res; + int ret; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + ctx->base = devm_ioremap(dev, res->start, resource_size(res)); + if (!ctx->base) { + dev_err(dev, "failed to map dpu registers\n"); + return -EFAULT; + } + + ctx->irq = platform_get_irq(pdev, 0); + if (ctx->irq < 0) { + dev_err(dev, "failed to get dpu irq\n"); + return ctx->irq; + } + + irq_set_status_flags(ctx->irq, IRQ_NOAUTOEN); + ret = devm_request_irq(dev, ctx->irq, sprd_dpu_isr_handler, + 0, "DPU", dpu); + if (ret) { + dev_err(dev, "failed to register dpu irq handler\n"); + return ret; + } + + init_waitqueue_head(&ctx->wait_queue); + + return 0; +} + +static const struct of_device_id dpu_match_table[] = { + { .compatible = "sprd,sharkl3-dpu" }, + { /* sentinel */ }, +}; + +static int sprd_dpu_probe(struct platform_device *pdev) +{ + struct sprd_dpu *dpu; + int ret; + + dpu = devm_kzalloc(&pdev->dev, sizeof(*dpu), GFP_KERNEL); + if (!dpu) + return -ENOMEM; + + ret = sprd_dpu_context_init(dpu, &pdev->dev); + if (ret) + return ret; + + platform_set_drvdata(pdev, dpu); + + return component_add(&pdev->dev, &dpu_component_ops); +} + +static int sprd_dpu_remove(struct platform_device *pdev) +{ + component_del(&pdev->dev, &dpu_component_ops); + return 0; +} + +struct platform_driver sprd_dpu_driver = { + .probe = sprd_dpu_probe, + .remove = sprd_dpu_remove, + .driver = { + .name = "sprd-dpu-drv", + .of_match_table = dpu_match_table, + }, +}; + +MODULE_AUTHOR("Leon He "); +MODULE_AUTHOR("Kevin Tang "); +MODULE_DESCRIPTION("Unisoc Display Controller Driver"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/gpu/drm/sprd/sprd_dpu.h b/drivers/gpu/drm/sprd/sprd_dpu.h new file mode 100644 index 0000000..3f64f4c --- /dev/null +++ b/drivers/gpu/drm/sprd/sprd_dpu.h @@ -0,0 +1,175 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (C) 2020 Unisoc Inc. + */ + +#ifndef __SPRD_DPU_H__ +#define __SPRD_DPU_H__ + +#include +#include +#include +#include +#include +#include +#include