drm/mediatek/mtk_disp_gamma.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2021 MediaTek Inc.
0004  */
0005
0006 #include <linux/clk.h>
0007 #include <linux/component.h>
0008 #include <linux/module.h>
0009 #include <linux/of_device.h>
0010 #include <linux/of_irq.h>
0011 #include <linux/platform_device.h>
0012 #include <linux/soc/mediatek/mtk-cmdq.h>
0013
0014 #include "mtk_disp_drv.h"
0015 #include "mtk_drm_crtc.h"
0016 #include "mtk_drm_ddp_comp.h"
0017
0018 #define DISP_GAMMA_EN               0x0000
0019 #define GAMMA_EN                    BIT(0)
0020 #define DISP_GAMMA_CFG              0x0020
0021 #define GAMMA_LUT_EN                    BIT(1)
0022 #define GAMMA_DITHERING                 BIT(2)
0023 #define DISP_GAMMA_SIZE             0x0030
0024 #define DISP_GAMMA_LUT              0x0700
0025
0026 #define LUT_10BIT_MASK              0x03ff
0027
0028 struct mtk_disp_gamma_data {
0029     bool has_dither;
0030     bool lut_diff;
0031 };
0032
0033 /*
0034  * struct mtk_disp_gamma - DISP_GAMMA driver structure
0035  */
0036 struct mtk_disp_gamma {
0037     struct clk *clk;
0038     void __iomem *regs;
0039     struct cmdq_client_reg cmdq_reg;
0040     const struct mtk_disp_gamma_data *data;
0041 };
0042
0043 int mtk_gamma_clk_enable(struct device *dev)
0044 {
0045     struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
0046
0047     return clk_prepare_enable(gamma->clk);
0048 }
0049
0050 void mtk_gamma_clk_disable(struct device *dev)
0051 {
0052     struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
0053
0054     clk_disable_unprepare(gamma->clk);
0055 }
0056
0057 void mtk_gamma_set_common(void __iomem *regs, struct drm_crtc_state *state, bool lut_diff)
0058 {
0059     unsigned int i, reg;
0060     struct drm_color_lut *lut;
0061     void __iomem *lut_base;
0062     u32 word;
0063     u32 diff[3] = {0};
0064
0065     if (state->gamma_lut) {
0066         reg = readl(regs + DISP_GAMMA_CFG);
0067         reg = reg | GAMMA_LUT_EN;
0068         writel(reg, regs + DISP_GAMMA_CFG);
0069         lut_base = regs + DISP_GAMMA_LUT;
0070         lut = (struct drm_color_lut *)state->gamma_lut->data;
0071         for (i = 0; i < MTK_LUT_SIZE; i++) {
0072
0073             if (!lut_diff || (i % 2 == 0)) {
0074                 word = (((lut[i].red >> 6) & LUT_10BIT_MASK) << 20) +
0075                     (((lut[i].green >> 6) & LUT_10BIT_MASK) << 10) +
0076                     ((lut[i].blue >> 6) & LUT_10BIT_MASK);
0077             } else {
0078                 diff[0] = (lut[i].red >> 6) - (lut[i - 1].red >> 6);
0079                 diff[1] = (lut[i].green >> 6) - (lut[i - 1].green >> 6);
0080                 diff[2] = (lut[i].blue >> 6) - (lut[i - 1].blue >> 6);
0081
0082                 word = ((diff[0] & LUT_10BIT_MASK) << 20) +
0083                     ((diff[1] & LUT_10BIT_MASK) << 10) +
0084                     (diff[2] & LUT_10BIT_MASK);
0085             }
0086             writel(word, (lut_base + i * 4));
0087         }
0088     }
0089 }
0090
0091 void mtk_gamma_set(struct device *dev, struct drm_crtc_state *state)
0092 {
0093     struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
0094     bool lut_diff = false;
0095
0096     if (gamma->data)
0097         lut_diff = gamma->data->lut_diff;
0098
0099     mtk_gamma_set_common(gamma->regs, state, lut_diff);
0100 }
0101
0102 void mtk_gamma_config(struct device *dev, unsigned int w,
0103               unsigned int h, unsigned int vrefresh,
0104               unsigned int bpc, struct cmdq_pkt *cmdq_pkt)
0105 {
0106     struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
0107
0108     mtk_ddp_write(cmdq_pkt, h << 16 | w, &gamma->cmdq_reg, gamma->regs,
0109               DISP_GAMMA_SIZE);
0110     if (gamma->data && gamma->data->has_dither)
0111         mtk_dither_set_common(gamma->regs, &gamma->cmdq_reg, bpc,
0112                       DISP_GAMMA_CFG, GAMMA_DITHERING, cmdq_pkt);
0113 }
0114
0115 void mtk_gamma_start(struct device *dev)
0116 {
0117     struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
0118
0119     writel(GAMMA_EN, gamma->regs + DISP_GAMMA_EN);
0120 }
0121
0122 void mtk_gamma_stop(struct device *dev)
0123 {
0124     struct mtk_disp_gamma *gamma = dev_get_drvdata(dev);
0125
0126     writel_relaxed(0x0, gamma->regs + DISP_GAMMA_EN);
0127 }
0128
0129 static int mtk_disp_gamma_bind(struct device *dev, struct device *master,
0130                    void *data)
0131 {
0132     return 0;
0133 }
0134
0135 static void mtk_disp_gamma_unbind(struct device *dev, struct device *master,
0136                   void *data)
0137 {
0138 }
0139
0140 static const struct component_ops mtk_disp_gamma_component_ops = {
0141     .bind   = mtk_disp_gamma_bind,
0142     .unbind = mtk_disp_gamma_unbind,
0143 };
0144
0145 static int mtk_disp_gamma_probe(struct platform_device *pdev)
0146 {
0147     struct device *dev = &pdev->dev;
0148     struct mtk_disp_gamma *priv;
0149     struct resource *res;
0150     int ret;
0151
0152     priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
0153     if (!priv)
0154         return -ENOMEM;
0155
0156     priv->clk = devm_clk_get(dev, NULL);
0157     if (IS_ERR(priv->clk)) {
0158         dev_err(dev, "failed to get gamma clk\n");
0159         return PTR_ERR(priv->clk);
0160     }
0161
0162     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0163     priv->regs = devm_ioremap_resource(dev, res);
0164     if (IS_ERR(priv->regs)) {
0165         dev_err(dev, "failed to ioremap gamma\n");
0166         return PTR_ERR(priv->regs);
0167     }
0168
0169 #if IS_REACHABLE(CONFIG_MTK_CMDQ)
0170     ret = cmdq_dev_get_client_reg(dev, &priv->cmdq_reg, 0);
0171     if (ret)
0172         dev_dbg(dev, "get mediatek,gce-client-reg fail!\n");
0173 #endif
0174
0175     priv->data = of_device_get_match_data(dev);
0176     platform_set_drvdata(pdev, priv);
0177
0178     ret = component_add(dev, &mtk_disp_gamma_component_ops);
0179     if (ret)
0180         dev_err(dev, "Failed to add component: %d\n", ret);
0181
0182     return ret;
0183 }
0184
0185 static int mtk_disp_gamma_remove(struct platform_device *pdev)
0186 {
0187     component_del(&pdev->dev, &mtk_disp_gamma_component_ops);
0188
0189     return 0;
0190 }
0191
0192 static const struct mtk_disp_gamma_data mt8173_gamma_driver_data = {
0193     .has_dither = true,
0194 };
0195
0196 static const struct mtk_disp_gamma_data mt8183_gamma_driver_data = {
0197     .lut_diff = true,
0198 };
0199
0200 static const struct of_device_id mtk_disp_gamma_driver_dt_match[] = {
0201     { .compatible = "mediatek,mt8173-disp-gamma",
0202       .data = &mt8173_gamma_driver_data},
0203     { .compatible = "mediatek,mt8183-disp-gamma",
0204       .data = &mt8183_gamma_driver_data},
0205     {},
0206 };
0207 MODULE_DEVICE_TABLE(of, mtk_disp_gamma_driver_dt_match);
0208
0209 struct platform_driver mtk_disp_gamma_driver = {
0210     .probe      = mtk_disp_gamma_probe,
0211     .remove     = mtk_disp_gamma_remove,
0212     .driver     = {
0213         .name   = "mediatek-disp-gamma",
0214         .owner  = THIS_MODULE,
0215         .of_match_table = mtk_disp_gamma_driver_dt_match,
0216     },
0217 };