1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2021 MediaTek Inc.
4 */
5
6#include <linux/clk.h>
7#include <linux/component.h>
8#include <linux/module.h>
9#include <linux/of.h>
10#include <linux/platform_device.h>
11#include <linux/soc/mediatek/mtk-cmdq.h>
12
13#include "mtk_disp_drv.h"
14#include "mtk_drm_crtc.h"
15#include "mtk_drm_ddp_comp.h"
16#include "mtk_drm_drv.h"
17
18#define DISP_GAMMA_EN				0x0000
19#define GAMMA_EN					BIT(0)
20#define DISP_GAMMA_CFG				0x0020
21#define GAMMA_LUT_EN					BIT(1)
22#define GAMMA_DITHERING					BIT(2)
23#define DISP_GAMMA_SIZE				0x0030
24#define DISP_GAMMA_LUT				0x0700
25
26#define LUT_10BIT_MASK				0x03ff
27
28struct mtk_disp_gamma_data {
29	bool has_dither;
30	bool lut_diff;
31};
32
33/*
34 * struct mtk_disp_gamma - DISP_GAMMA driver structure
35 */
36struct mtk_disp_gamma {
37	struct clk *clk;
38	void __iomem *regs;
39	struct cmdq_client_reg cmdq_reg;
40	const struct mtk_disp_gamma_data *data;
41};
42
43int mtk_gamma_clk_enable(struct device *dev)
44{
45	struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
46
47	return clk_prepare_enable(gamma->clk);
48}
49
50void mtk_gamma_clk_disable(struct device *dev)
51{
52	struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
53
54	clk_disable_unprepare(gamma->clk);
55}
56
57void mtk_gamma_set_common(void __iomem *regs, struct drm_crtc_state *state, bool lut_diff)
58{
59	unsigned int i, reg;
60	struct drm_color_lut *lut;
61	void __iomem *lut_base;
62	u32 word;
63	u32 diff[3] = {0};
64
65	if (state->gamma_lut) {
66		reg = readl(regs + DISP_GAMMA_CFG);
67		reg = reg | GAMMA_LUT_EN;
68		writel(reg, regs + DISP_GAMMA_CFG);
69		lut_base = regs + DISP_GAMMA_LUT;
70		lut = (struct drm_color_lut *)state->gamma_lut->data;
71		for (i = 0; i < MTK_LUT_SIZE; i++) {
72
73			if (!lut_diff || (i % 2 == 0)) {
74				word = (((lut[i].red >> 6) & LUT_10BIT_MASK) << 20) +
75					(((lut[i].green >> 6) & LUT_10BIT_MASK) << 10) +
76					((lut[i].blue >> 6) & LUT_10BIT_MASK);
77			} else {
78				diff[0] = (lut[i].red >> 6) - (lut[i - 1].red >> 6);
79				diff[1] = (lut[i].green >> 6) - (lut[i - 1].green >> 6);
80				diff[2] = (lut[i].blue >> 6) - (lut[i - 1].blue >> 6);
81
82				word = ((diff[0] & LUT_10BIT_MASK) << 20) +
83					((diff[1] & LUT_10BIT_MASK) << 10) +
84					(diff[2] & LUT_10BIT_MASK);
85			}
86			writel(word, (lut_base + i * 4));
87		}
88	}
89}
90
91void mtk_gamma_set(struct device *dev, struct drm_crtc_state *state)
92{
93	struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
94	bool lut_diff = false;
95
96	if (gamma->data)
97		lut_diff = gamma->data->lut_diff;
98
99	mtk_gamma_set_common(gamma->regs, state, lut_diff);
100}
101
102void mtk_gamma_config(struct device *dev, unsigned int w,
103		      unsigned int h, unsigned int vrefresh,
104		      unsigned int bpc, struct cmdq_pkt *cmdq_pkt)
105{
106	struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
107
108	mtk_ddp_write(cmdq_pkt, h << 16 | w, &gamma->cmdq_reg, gamma->regs,
109		      DISP_GAMMA_SIZE);
110	if (gamma->data && gamma->data->has_dither)
111		mtk_dither_set_common(gamma->regs, &gamma->cmdq_reg, bpc,
112				      DISP_GAMMA_CFG, GAMMA_DITHERING, cmdq_pkt);
113}
114
115void mtk_gamma_start(struct device *dev)
116{
117	struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
118
119	writel(GAMMA_EN, gamma->regs + DISP_GAMMA_EN);
120}
121
122void mtk_gamma_stop(struct device *dev)
123{
124	struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
125
126	writel_relaxed(0x0, gamma->regs + DISP_GAMMA_EN);
127}
128
129static int mtk_disp_gamma_bind(struct device *dev, struct device *master,
130			       void *data)
131{
132	return 0;
133}
134
135static void mtk_disp_gamma_unbind(struct device *dev, struct device *master,
136				  void *data)
137{
138}
139
140static const struct component_ops mtk_disp_gamma_component_ops = {
141	.bind	= mtk_disp_gamma_bind,
142	.unbind = mtk_disp_gamma_unbind,
143};
144
145static int mtk_disp_gamma_probe(struct platform_device *pdev)
146{
147	struct device *dev = &pdev->dev;
148	struct mtk_disp_gamma *priv;
149	struct resource *res;
150	int ret;
151
152	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
153	if (!priv)
154		return -ENOMEM;
155
156	priv->clk = devm_clk_get(dev, NULL);
157	if (IS_ERR(priv->clk)) {
158		dev_err(dev, "failed to get gamma clk\n");
159		return PTR_ERR(priv->clk);
160	}
161
162	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
163	priv->regs = devm_ioremap_resource(dev, res);
164	if (IS_ERR(priv->regs)) {
165		dev_err(dev, "failed to ioremap gamma\n");
166		return PTR_ERR(priv->regs);
167	}
168
169#if IS_REACHABLE(CONFIG_MTK_CMDQ)
170	ret = cmdq_dev_get_client_reg(dev, &priv->cmdq_reg, 0);
171	if (ret)
172		dev_dbg(dev, "get mediatek,gce-client-reg fail!\n");
173#endif
174
175	priv->data = of_device_get_match_data(dev);
176	platform_set_drvdata(pdev, priv);
177
178	ret = component_add(dev, &mtk_disp_gamma_component_ops);
179	if (ret)
180		dev_err(dev, "Failed to add component: %d\n", ret);
181
182	return ret;
183}
184
185static void mtk_disp_gamma_remove(struct platform_device *pdev)
186{
187	component_del(&pdev->dev, &mtk_disp_gamma_component_ops);
188}
189
190static const struct mtk_disp_gamma_data mt8173_gamma_driver_data = {
191	.has_dither = true,
192};
193
194static const struct mtk_disp_gamma_data mt8183_gamma_driver_data = {
195	.lut_diff = true,
196};
197
198static const struct of_device_id mtk_disp_gamma_driver_dt_match[] = {
199	{ .compatible = "mediatek,mt8173-disp-gamma",
200	  .data = &mt8173_gamma_driver_data},
201	{ .compatible = "mediatek,mt8183-disp-gamma",
202	  .data = &mt8183_gamma_driver_data},
203	{},
204};
205MODULE_DEVICE_TABLE(of, mtk_disp_gamma_driver_dt_match);
206
207struct platform_driver mtk_disp_gamma_driver = {
208	.probe		= mtk_disp_gamma_probe,
209	.remove_new	= mtk_disp_gamma_remove,
210	.driver		= {
211		.name	= "mediatek-disp-gamma",
212		.owner	= THIS_MODULE,
213		.of_match_table = mtk_disp_gamma_driver_dt_match,
214	},
215};
216