Commit 54c820d0 authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge tag 'mediatek-drm-next-5.12' of... 

Merge tag 'mediatek-drm-next-5.12' of https://git.kernel.org/pub/scm/linux/kernel/git/chunkuang.hu/linux

 into drm-next

Mediatek DRM Next for Linux 5.12

1. Decouple Mediatek DRM sub driver
2. Share mtk mutex driver for both DRM and MDP
3. Add support for SoC MT8183

Signed-off-by: default avatarDave Airlie <airlied@redhat.com>

From: Chun-Kuang Hu <chunkuang.hu@kernel.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20210204151750.7550-1-chunkuang.hu@kernel.org
parents ce7c3bde 738ed415

Documentation/devicetree/bindings/display/mediatek/mediatek,disp.txt

+11 −1
Original line number Diff line number Diff line
@@ -37,13 +37,14 @@ Required properties (all function blocks): 
	"mediatek,<chip>-disp-aal"   		- adaptive ambient light controller

	"mediatek,<chip>-disp-gamma" 		- gamma correction

	"mediatek,<chip>-disp-merge" 		- merge streams from two RDMA sources

	"mediatek,<chip>-disp-postmask" 	- control round corner for display frame

	"mediatek,<chip>-disp-split" 		- split stream to two encoders

	"mediatek,<chip>-disp-ufoe"  		- data compression engine

	"mediatek,<chip>-dsi"        		- DSI controller, see mediatek,dsi.txt

	"mediatek,<chip>-dpi"        		- DPI controller, see mediatek,dpi.txt

	"mediatek,<chip>-disp-mutex" 		- display mutex

	"mediatek,<chip>-disp-od"    		- overdrive

  the supported chips are mt2701, mt7623, mt2712, mt8167 and mt8173.

  the supported chips are mt2701, mt7623, mt2712, mt8167, mt8173, mt8183 and mt8192.

- reg: Physical base address and length of the function block register space

- interrupts: The interrupt signal from the function block (required, except for

  merge and split function blocks).
@@ -66,6 +67,14 @@ Required properties (DMA function blocks): 
  argument, see Documentation/devicetree/bindings/iommu/mediatek,iommu.txt

  for details.



Optional properties (RDMA function blocks):

- mediatek,rdma-fifo-size: rdma fifo size may be different even in same SOC, add this

  property to the corresponding rdma

  the value is the Max value which defined in hardware data sheet.

  mediatek,rdma-fifo-size of mt8173-rdma0 is 8K

  mediatek,rdma-fifo-size of mt8183-rdma0 is 5K

  mediatek,rdma-fifo-size of mt8183-rdma1 is 2K



Examples:



mmsys: clock-controller@14000000 {
@@ -103,6 +112,7 @@ rdma0: rdma@1400e000 { 
	clocks = <&mmsys CLK_MM_DISP_RDMA0>;

	iommus = <&iommu M4U_PORT_DISP_RDMA0>;

	mediatek,larb = <&larb0>;

	mediatek,rdma-fifosize = <8192>;

};



rdma1: rdma@1400f000 {

drivers/gpu/drm/mediatek/Makefile

+3 −2
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0



mediatek-drm-y := mtk_disp_color.o \

mediatek-drm-y := mtk_disp_ccorr.o \

		  mtk_disp_color.o \

		  mtk_disp_gamma.o \

		  mtk_disp_ovl.o \

		  mtk_disp_rdma.o \

		  mtk_drm_crtc.o \

		  mtk_drm_ddp.o \

		  mtk_drm_ddp_comp.o \

		  mtk_drm_drv.o \

		  mtk_drm_gem.o \

drivers/gpu/drm/mediatek/mtk_disp_ccorr.c

0 → 100644
+223 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2021 MediaTek Inc.

 */



#include <linux/clk.h>

#include <linux/component.h>

#include <linux/module.h>

#include <linux/of_device.h>

#include <linux/of_irq.h>

#include <linux/platform_device.h>

#include <linux/soc/mediatek/mtk-cmdq.h>



#include "mtk_disp_drv.h"

#include "mtk_drm_crtc.h"

#include "mtk_drm_ddp_comp.h"



#define DISP_CCORR_EN				0x0000

#define CCORR_EN					BIT(0)

#define DISP_CCORR_CFG				0x0020

#define CCORR_RELAY_MODE				BIT(0)

#define CCORR_ENGINE_EN					BIT(1)

#define CCORR_GAMMA_OFF					BIT(2)

#define CCORR_WGAMUT_SRC_CLIP				BIT(3)

#define DISP_CCORR_SIZE				0x0030

#define DISP_CCORR_COEF_0			0x0080

#define DISP_CCORR_COEF_1			0x0084

#define DISP_CCORR_COEF_2			0x0088

#define DISP_CCORR_COEF_3			0x008C

#define DISP_CCORR_COEF_4			0x0090



struct mtk_disp_ccorr_data {

	u32 matrix_bits;

};



/**

 * struct mtk_disp_ccorr - DISP_CCORR driver structure

 * @ddp_comp - structure containing type enum and hardware resources

 * @crtc - associated crtc to report irq events to

 */

struct mtk_disp_ccorr {

	struct clk *clk;

	void __iomem *regs;

	struct cmdq_client_reg cmdq_reg;

	const struct mtk_disp_ccorr_data	*data;

};



int mtk_ccorr_clk_enable(struct device *dev)

{

	struct mtk_disp_ccorr *ccorr = dev_get_drvdata(dev);



	return clk_prepare_enable(ccorr->clk);

}



void mtk_ccorr_clk_disable(struct device *dev)

{

	struct mtk_disp_ccorr *ccorr = dev_get_drvdata(dev);



	clk_disable_unprepare(ccorr->clk);

}



void mtk_ccorr_config(struct device *dev, unsigned int w,

			     unsigned int h, unsigned int vrefresh,

			     unsigned int bpc, struct cmdq_pkt *cmdq_pkt)

{

	struct mtk_disp_ccorr *ccorr = dev_get_drvdata(dev);



	mtk_ddp_write(cmdq_pkt, w << 16 | h, &ccorr->cmdq_reg, ccorr->regs,

		      DISP_CCORR_SIZE);

	mtk_ddp_write(cmdq_pkt, CCORR_ENGINE_EN, &ccorr->cmdq_reg, ccorr->regs,

		      DISP_CCORR_CFG);

}



void mtk_ccorr_start(struct device *dev)

{

	struct mtk_disp_ccorr *ccorr = dev_get_drvdata(dev);



	writel(CCORR_EN, ccorr->regs + DISP_CCORR_EN);

}



void mtk_ccorr_stop(struct device *dev)

{

	struct mtk_disp_ccorr *ccorr = dev_get_drvdata(dev);



	writel_relaxed(0x0, ccorr->regs + DISP_CCORR_EN);

}



/* Converts a DRM S31.32 value to the HW S1.n format. */

static u16 mtk_ctm_s31_32_to_s1_n(u64 in, u32 n)

{

	u16 r;



	/* Sign bit. */

	r = in & BIT_ULL(63) ? BIT(n + 1) : 0;



	if ((in & GENMASK_ULL(62, 33)) > 0) {

		/* identity value 0x100000000 -> 0x400(mt8183), */

		/* identity value 0x100000000 -> 0x800(mt8192), */

		/* if bigger this, set it to max 0x7ff. */

		r |= GENMASK(n, 0);

	} else {

		/* take the n+1 most important bits. */

		r |= (in >> (32 - n)) & GENMASK(n, 0);

	}



	return r;

}



void mtk_ccorr_ctm_set(struct device *dev, struct drm_crtc_state *state)

{

	struct mtk_disp_ccorr *ccorr = dev_get_drvdata(dev);

	struct drm_property_blob *blob = state->ctm;

	struct drm_color_ctm *ctm;

	const u64 *input;

	uint16_t coeffs[9] = { 0 };

	int i;

	struct cmdq_pkt *cmdq_pkt = NULL;

	u32 matrix_bits = ccorr->data->matrix_bits;



	if (!blob)

		return;



	ctm = (struct drm_color_ctm *)blob->data;

	input = ctm->matrix;



	for (i = 0; i < ARRAY_SIZE(coeffs); i++)

		coeffs[i] = mtk_ctm_s31_32_to_s1_n(input[i], matrix_bits);



	mtk_ddp_write(cmdq_pkt, coeffs[0] << 16 | coeffs[1],

		      &ccorr->cmdq_reg, ccorr->regs, DISP_CCORR_COEF_0);

	mtk_ddp_write(cmdq_pkt, coeffs[2] << 16 | coeffs[3],

		      &ccorr->cmdq_reg, ccorr->regs, DISP_CCORR_COEF_1);

	mtk_ddp_write(cmdq_pkt, coeffs[4] << 16 | coeffs[5],

		      &ccorr->cmdq_reg, ccorr->regs, DISP_CCORR_COEF_2);

	mtk_ddp_write(cmdq_pkt, coeffs[6] << 16 | coeffs[7],

		      &ccorr->cmdq_reg, ccorr->regs, DISP_CCORR_COEF_3);

	mtk_ddp_write(cmdq_pkt, coeffs[8] << 16,

		      &ccorr->cmdq_reg, ccorr->regs, DISP_CCORR_COEF_4);

}



static int mtk_disp_ccorr_bind(struct device *dev, struct device *master,

			       void *data)

{

	return 0;

}



static void mtk_disp_ccorr_unbind(struct device *dev, struct device *master,

				  void *data)

{

}



static const struct component_ops mtk_disp_ccorr_component_ops = {

	.bind	= mtk_disp_ccorr_bind,

	.unbind	= mtk_disp_ccorr_unbind,

};



static int mtk_disp_ccorr_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct mtk_disp_ccorr *priv;

	struct resource *res;

	int ret;



	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



	priv->clk = devm_clk_get(dev, NULL);

	if (IS_ERR(priv->clk)) {

		dev_err(dev, "failed to get ccorr clk\n");

		return PTR_ERR(priv->clk);

	}



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	priv->regs = devm_ioremap_resource(dev, res);

	if (IS_ERR(priv->regs)) {

		dev_err(dev, "failed to ioremap ccorr\n");

		return PTR_ERR(priv->regs);

	}



#if IS_REACHABLE(CONFIG_MTK_CMDQ)

	ret = cmdq_dev_get_client_reg(dev, &priv->cmdq_reg, 0);

	if (ret)

		dev_dbg(dev, "get mediatek,gce-client-reg fail!\n");

#endif



	priv->data = of_device_get_match_data(dev);

	platform_set_drvdata(pdev, priv);



	ret = component_add(dev, &mtk_disp_ccorr_component_ops);

	if (ret)

		dev_err(dev, "Failed to add component: %d\n", ret);



	return ret;

}



static int mtk_disp_ccorr_remove(struct platform_device *pdev)

{

	component_del(&pdev->dev, &mtk_disp_ccorr_component_ops);



	return 0;

}



static const struct mtk_disp_ccorr_data mt8183_ccorr_driver_data = {

	.matrix_bits = 10,

};



static const struct of_device_id mtk_disp_ccorr_driver_dt_match[] = {

	{ .compatible = "mediatek,mt8183-disp-ccorr",

	  .data = &mt8183_ccorr_driver_data},

	{},

};

MODULE_DEVICE_TABLE(of, mtk_disp_ccorr_driver_dt_match);



struct platform_driver mtk_disp_ccorr_driver = {

	.probe		= mtk_disp_ccorr_probe,

	.remove		= mtk_disp_ccorr_remove,

	.driver		= {

		.name	= "mediatek-disp-ccorr",

		.owner	= THIS_MODULE,

		.of_match_table = mtk_disp_ccorr_driver_dt_match,

	},

};

drivers/gpu/drm/mediatek/mtk_disp_color.c

+40 −49
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/platform_device.h>

#include <linux/soc/mediatek/mtk-cmdq.h>



#include "mtk_disp_drv.h"

#include "mtk_drm_crtc.h"

#include "mtk_drm_ddp_comp.h"
@@ -36,64 +37,55 @@ struct mtk_disp_color_data { 
 * @data: platform colour driver data

 */

struct mtk_disp_color {

	struct mtk_ddp_comp			ddp_comp;

	struct drm_crtc				*crtc;

	struct clk				*clk;

	void __iomem				*regs;

	struct cmdq_client_reg			cmdq_reg;

	const struct mtk_disp_color_data	*data;

};



static inline struct mtk_disp_color *comp_to_color(struct mtk_ddp_comp *comp)

int mtk_color_clk_enable(struct device *dev)

{

	return container_of(comp, struct mtk_disp_color, ddp_comp);

	struct mtk_disp_color *color = dev_get_drvdata(dev);



	return clk_prepare_enable(color->clk);

}



void mtk_color_clk_disable(struct device *dev)

{

	struct mtk_disp_color *color = dev_get_drvdata(dev);



	clk_disable_unprepare(color->clk);

}



static void mtk_color_config(struct mtk_ddp_comp *comp, unsigned int w,

void mtk_color_config(struct device *dev, unsigned int w,

		      unsigned int h, unsigned int vrefresh,

		      unsigned int bpc, struct cmdq_pkt *cmdq_pkt)

{

	struct mtk_disp_color *color = comp_to_color(comp);

	struct mtk_disp_color *color = dev_get_drvdata(dev);



	mtk_ddp_write(cmdq_pkt, w, comp, DISP_COLOR_WIDTH(color));

	mtk_ddp_write(cmdq_pkt, h, comp, DISP_COLOR_HEIGHT(color));

	mtk_ddp_write(cmdq_pkt, w, &color->cmdq_reg, color->regs, DISP_COLOR_WIDTH(color));

	mtk_ddp_write(cmdq_pkt, h, &color->cmdq_reg, color->regs, DISP_COLOR_HEIGHT(color));

}



static void mtk_color_start(struct mtk_ddp_comp *comp)

void mtk_color_start(struct device *dev)

{

	struct mtk_disp_color *color = comp_to_color(comp);

	struct mtk_disp_color *color = dev_get_drvdata(dev);



	writel(COLOR_BYPASS_ALL | COLOR_SEQ_SEL,

	       comp->regs + DISP_COLOR_CFG_MAIN);

	writel(0x1, comp->regs + DISP_COLOR_START(color));

	       color->regs + DISP_COLOR_CFG_MAIN);

	writel(0x1, color->regs + DISP_COLOR_START(color));

}



static const struct mtk_ddp_comp_funcs mtk_disp_color_funcs = {

	.config = mtk_color_config,

	.start = mtk_color_start,

};



static int mtk_disp_color_bind(struct device *dev, struct device *master,

			       void *data)

{

	struct mtk_disp_color *priv = dev_get_drvdata(dev);

	struct drm_device *drm_dev = data;

	int ret;



	ret = mtk_ddp_comp_register(drm_dev, &priv->ddp_comp);

	if (ret < 0) {

		dev_err(dev, "Failed to register component %pOF: %d\n",

			dev->of_node, ret);

		return ret;

	}



	return 0;

}



static void mtk_disp_color_unbind(struct device *dev, struct device *master,

				  void *data)

{

	struct mtk_disp_color *priv = dev_get_drvdata(dev);

	struct drm_device *drm_dev = data;



	mtk_ddp_comp_unregister(drm_dev, &priv->ddp_comp);

}



static const struct component_ops mtk_disp_color_component_ops = {
@@ -105,31 +97,32 @@ static int mtk_disp_color_probe(struct platform_device *pdev) 
{

	struct device *dev = &pdev->dev;

	struct mtk_disp_color *priv;

	int comp_id;

	struct resource *res;

	int ret;



	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



	comp_id = mtk_ddp_comp_get_id(dev->of_node, MTK_DISP_COLOR);

	if (comp_id < 0) {

		dev_err(dev, "Failed to identify by alias: %d\n", comp_id);

		return comp_id;

	priv->clk = devm_clk_get(dev, NULL);

	if (IS_ERR(priv->clk)) {

		dev_err(dev, "failed to get color clk\n");

		return PTR_ERR(priv->clk);

	}



	ret = mtk_ddp_comp_init(dev, dev->of_node, &priv->ddp_comp, comp_id,

				&mtk_disp_color_funcs);

	if (ret) {

		if (ret != -EPROBE_DEFER)

			dev_err(dev, "Failed to initialize component: %d\n",

				ret);



		return ret;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	priv->regs = devm_ioremap_resource(dev, res);

	if (IS_ERR(priv->regs)) {

		dev_err(dev, "failed to ioremap color\n");

		return PTR_ERR(priv->regs);

	}

#if IS_REACHABLE(CONFIG_MTK_CMDQ)

	ret = cmdq_dev_get_client_reg(dev, &priv->cmdq_reg, 0);

	if (ret)

		dev_dbg(dev, "get mediatek,gce-client-reg fail!\n");

#endif



	priv->data = of_device_get_match_data(dev);



	platform_set_drvdata(pdev, priv);



	ret = component_add(dev, &mtk_disp_color_component_ops);
@@ -141,8 +134,6 @@ static int mtk_disp_color_probe(struct platform_device *pdev) 


static int mtk_disp_color_remove(struct platform_device *pdev)

{

	component_del(&pdev->dev, &mtk_disp_color_component_ops);



	return 0;

}

drivers/gpu/drm/mediatek/mtk_disp_drv.h

0 → 100644
+92 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (c) 2020 MediaTek Inc.

 */



#ifndef _MTK_DISP_DRV_H_

#define _MTK_DISP_DRV_H_



#include <linux/soc/mediatek/mtk-cmdq.h>

#include "mtk_drm_plane.h"



void mtk_ccorr_ctm_set(struct device *dev, struct drm_crtc_state *state);

int mtk_ccorr_clk_enable(struct device *dev);

void mtk_ccorr_clk_disable(struct device *dev);

void mtk_ccorr_config(struct device *dev, unsigned int w,

		      unsigned int h, unsigned int vrefresh,

		      unsigned int bpc, struct cmdq_pkt *cmdq_pkt);

void mtk_ccorr_start(struct device *dev);

void mtk_ccorr_stop(struct device *dev);



void mtk_color_bypass_shadow(struct device *dev);

int mtk_color_clk_enable(struct device *dev);

void mtk_color_clk_disable(struct device *dev);

void mtk_color_config(struct device *dev, unsigned int w,

		      unsigned int h, unsigned int vrefresh,

		      unsigned int bpc, struct cmdq_pkt *cmdq_pkt);

void mtk_color_start(struct device *dev);



void mtk_dither_set_common(void __iomem *regs, struct cmdq_client_reg *cmdq_reg,

			   unsigned int bpc, unsigned int cfg,

			   unsigned int dither_en, struct cmdq_pkt *cmdq_pkt);



void mtk_dpi_start(struct device *dev);

void mtk_dpi_stop(struct device *dev);



void mtk_dsi_ddp_start(struct device *dev);

void mtk_dsi_ddp_stop(struct device *dev);



int mtk_gamma_clk_enable(struct device *dev);

void mtk_gamma_clk_disable(struct device *dev);

void mtk_gamma_config(struct device *dev, unsigned int w,

		      unsigned int h, unsigned int vrefresh,

		      unsigned int bpc, struct cmdq_pkt *cmdq_pkt);

void mtk_gamma_set(struct device *dev, struct drm_crtc_state *state);

void mtk_gamma_set_common(void __iomem *regs, struct drm_crtc_state *state);

void mtk_gamma_start(struct device *dev);

void mtk_gamma_stop(struct device *dev);



void mtk_ovl_bgclr_in_on(struct device *dev);

void mtk_ovl_bgclr_in_off(struct device *dev);

void mtk_ovl_bypass_shadow(struct device *dev);

int mtk_ovl_clk_enable(struct device *dev);

void mtk_ovl_clk_disable(struct device *dev);

void mtk_ovl_config(struct device *dev, unsigned int w,

		    unsigned int h, unsigned int vrefresh,

		    unsigned int bpc, struct cmdq_pkt *cmdq_pkt);

int mtk_ovl_layer_check(struct device *dev, unsigned int idx,

			struct mtk_plane_state *mtk_state);

void mtk_ovl_layer_config(struct device *dev, unsigned int idx,

			  struct mtk_plane_state *state,

			  struct cmdq_pkt *cmdq_pkt);

unsigned int mtk_ovl_layer_nr(struct device *dev);

void mtk_ovl_layer_on(struct device *dev, unsigned int idx,

		      struct cmdq_pkt *cmdq_pkt);

void mtk_ovl_layer_off(struct device *dev, unsigned int idx,

		       struct cmdq_pkt *cmdq_pkt);

void mtk_ovl_start(struct device *dev);

void mtk_ovl_stop(struct device *dev);

unsigned int mtk_ovl_supported_rotations(struct device *dev);

void mtk_ovl_enable_vblank(struct device *dev,

			   void (*vblank_cb)(void *),

			   void *vblank_cb_data);

void mtk_ovl_disable_vblank(struct device *dev);



void mtk_rdma_bypass_shadow(struct device *dev);

int mtk_rdma_clk_enable(struct device *dev);

void mtk_rdma_clk_disable(struct device *dev);

void mtk_rdma_config(struct device *dev, unsigned int width,

		     unsigned int height, unsigned int vrefresh,

		     unsigned int bpc, struct cmdq_pkt *cmdq_pkt);

unsigned int mtk_rdma_layer_nr(struct device *dev);

void mtk_rdma_layer_config(struct device *dev, unsigned int idx,

			   struct mtk_plane_state *state,

			   struct cmdq_pkt *cmdq_pkt);

void mtk_rdma_start(struct device *dev);

void mtk_rdma_stop(struct device *dev);

void mtk_rdma_enable_vblank(struct device *dev,

			    void (*vblank_cb)(void *),

			    void *vblank_cb_data);

void mtk_rdma_disable_vblank(struct device *dev);



#endif