Add post processor ops for MDNIE and their support functions. Expose an interface for the FIMD to register MDNIE PP.
Signed-off-by: Ajay Kumar ajaykumar.rs@samsung.com Signed-off-by: Shirish S s.shirish@samsung.com Signed-off-by: Rahul Sharma rahul.sharma@samsung.com --- drivers/gpu/drm/exynos/Makefile | 2 +- drivers/gpu/drm/exynos/exynos_mdnie.c | 707 +++++++++++++++++++++++++++++ drivers/gpu/drm/exynos/exynos_mdnie_regs.h | 154 +++++++ 3 files changed, 862 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/exynos/exynos_mdnie.c create mode 100644 drivers/gpu/drm/exynos/exynos_mdnie_regs.h
diff --git a/drivers/gpu/drm/exynos/Makefile b/drivers/gpu/drm/exynos/Makefile index 02dde22..653eab5 100644 --- a/drivers/gpu/drm/exynos/Makefile +++ b/drivers/gpu/drm/exynos/Makefile @@ -10,7 +10,7 @@ exynosdrm-y := exynos_drm_drv.o exynos_drm_encoder.o \
exynosdrm-$(CONFIG_DRM_EXYNOS_IOMMU) += exynos_drm_iommu.o exynosdrm-$(CONFIG_DRM_EXYNOS_DMABUF) += exynos_drm_dmabuf.o -exynosdrm-$(CONFIG_DRM_EXYNOS_FIMD) += exynos_drm_fimd.o +exynosdrm-$(CONFIG_DRM_EXYNOS_FIMD) += exynos_drm_fimd.o exynos_mdnie.o exynosdrm-$(CONFIG_DRM_EXYNOS_DSI) += exynos_drm_dsi.o exynosdrm-$(CONFIG_DRM_EXYNOS_DP) += exynos_dp_core.o exynos_dp_reg.o exynosdrm-$(CONFIG_DRM_EXYNOS_HDMI) += exynos_hdmi.o exynos_mixer.o diff --git a/drivers/gpu/drm/exynos/exynos_mdnie.c b/drivers/gpu/drm/exynos/exynos_mdnie.c new file mode 100644 index 0000000..a043853 --- /dev/null +++ b/drivers/gpu/drm/exynos/exynos_mdnie.c @@ -0,0 +1,707 @@ +/* drivers/gpu/drm/exynos/exynos_mdnie.c + * + * Samsung mDNIe driver + * + * Copyright (C) 2014 Samsung Electronics Co., Ltd. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. +*/ + +#include <linux/clk.h> +#include <linux/errno.h> +#include <linux/of_device.h> + +#include <video/samsung_fimd.h> + +#include <drm/drmP.h> + +#include "exynos_drm_drv.h" +#include "exynos_fimd_pp.h" +#include "exynos_mdnie_regs.h" + +#define GAMMA_RAMP_LENGTH 17 +#define COLOR_COMPONENTS 3 + +#define MDNIE_ON 1 +#define MDNIE_OFF 0 + +#define PARAM_IN_RANGE(r, p, l, u) \ + do { \ + r = ((p >= l) && (p <= u)) ? 0 : 1; \ + if (r) \ + DRM_ERROR("Wrong param: %s:%llu\n", #p, (u64)p); \ + } while (0) + +struct exynos_mdnie_drm_gamma { + u8 gamma_r[GAMMA_RAMP_LENGTH]; + u8 gamma_g[GAMMA_RAMP_LENGTH]; + u8 gamma_b[GAMMA_RAMP_LENGTH]; +}; + +struct mdnie_conf_params { + u32 modules_enabled; + struct exynos_mdnie_drm_gamma gamma_params; + struct drm_exynos_mdnie_window win; + struct drm_mode_color_reproduction cr_params; + struct drm_mode_color_saturation cs_params; + struct drm_mode_edge_enhancement de_params; +}; + +struct mdnie_context { + struct mdnie_conf_params params; + struct clk *mdnie_mux_clk; + struct clk *mdnie_bus_clk; + struct clk *mdnie_src_clk; + struct clk *sclk_mout_fimd; + void __iomem *exynos_mdnie_base; + void __iomem *sysreg_disp1blk; + struct drm_display_mode mode; +}; + +static void exynos_mdnie_unmask(struct mdnie_context *mdnie) +{ + writel(!MDNIE_RELEASE_RFF_MASK_REGISTERS, + mdnie->exynos_mdnie_base + + MDNIE_RELEASE_RFF * sizeof(u32)); +} + +static u32 mdnie_read(struct mdnie_context *mdnie, u32 reg) +{ + return readl(mdnie->exynos_mdnie_base + reg * sizeof(u32)) & + MDNIE_REG_WIDTH; +} + +static void mdnie_write(struct mdnie_context *mdnie, u32 reg, u32 val) +{ + writel(val & MDNIE_REG_WIDTH, mdnie->exynos_mdnie_base + + (reg & MDNIE_REG_OFFSET_LIMIT) * sizeof(u32)); + + exynos_mdnie_unmask(mdnie); +} + +static void exynos_mdnie_bank_sel(struct mdnie_context *mdnie, int bank) +{ + if (bank) + writel(MDNIE_TOP_R0_BANK1_SEL | + MDNIE_TOP_R0_SHADOW_SEL , + mdnie->exynos_mdnie_base); + else + writel(MDNIE_TOP_R0_BANK0_SEL | + MDNIE_TOP_R0_SHADOW_SEL , + mdnie->exynos_mdnie_base); + + exynos_mdnie_unmask(mdnie); +} + +static int exynos_mdnie_set_size(struct mdnie_context *mdnie) +{ + unsigned int cfg; + + if ((mdnie->mode.crtc_hdisplay > MDNIE_TOP_RSIZE_MAX) || + (mdnie->mode.crtc_vdisplay > MDNIE_TOP_RSIZE_MAX)) + return -EINVAL; + + exynos_mdnie_bank_sel(mdnie, 0); + + /* Input Data Unmask */ + cfg = mdnie_read(mdnie, MDNIE_TOP_R1); + cfg &= ~(MDNIE_TOP_R1_MASK_INPUT_DATA_ENABLE); + cfg &= ~(MDNIE_TOP_R1_MASK_INPUT_HSYNC); + mdnie_write(mdnie, MDNIE_TOP_R1, cfg); + + /* LCD width */ + mdnie_write(mdnie, MDNIE_TOP_RIHSIZE, + mdnie->mode.crtc_hdisplay); + + /* LCD height */ + mdnie_write(mdnie, MDNIE_TOP_RIVSIZE, + mdnie->mode.crtc_vdisplay); + return 0; +} + +static void mdnie_set_all_modules_off(struct mdnie_context *mdnie) +{ + u32 val; + + val = mdnie_read(mdnie, MDNIE_TOP_R8); + val &= ~(MDNIE_TOP_R8_DITH_MODULE_ON | + MDNIE_TOP_R8_ABC_MODULE_ON | + MDNIE_TOP_R8_SCR_MODULE_ON | + MDNIE_TOP_R8_CC_MODULE_ON | + MDNIE_TOP_R8_CS_MODULE_ON | + MDNIE_TOP_R8_DE_MODULE_ON); + mdnie_write(mdnie, MDNIE_TOP_R8, val); + + val = mdnie_read(mdnie, MDNIE_TOP_R9); + val &= ~(MDNIE_TOP_R9_MCM_MODULE_ON); + mdnie_write(mdnie, MDNIE_TOP_R9, val); + + val = mdnie_read(mdnie, MDNIE_TOP_RA); + val &= ~(MDNIE_TOP_RA_UC_MODULE_ON); + mdnie_write(mdnie, MDNIE_TOP_RA, val); +} + +static void mdnie_set_req_modules_on(struct mdnie_context *mdnie) +{ + u32 val; + + val = mdnie_read(mdnie, MDNIE_TOP_R8); + if (mdnie->params.modules_enabled & BIT(MDNIE_COLOR_REPRODUCTION)) + val |= MDNIE_TOP_R8_SCR_MODULE_ON; + if (mdnie->params.modules_enabled & BIT(MDNIE_CURVE_CONTROL)) + val |= MDNIE_TOP_R8_CC_MODULE_ON; + if (mdnie->params.modules_enabled & BIT(MDNIE_COLOR_SATURATION)) + val |= MDNIE_TOP_R8_CS_MODULE_ON; + if (mdnie->params.modules_enabled & BIT(MDNIE_DETAIL_ENHANCEMENT)) + val |= MDNIE_TOP_R8_DE_MODULE_ON; + + mdnie_write(mdnie, MDNIE_TOP_R8, val); +} + +static int mdnie_set_color_saturation_params( + struct mdnie_context *mdnie, + const struct drm_mode_color_saturation *params) +{ + int ret; + + PARAM_IN_RANGE(ret, params->hue_gain_red, HG_MIN, HG_MAX); + PARAM_IN_RANGE(ret, params->hue_gain_green, HG_MIN, HG_MAX); + PARAM_IN_RANGE(ret, params->hue_gain_blue, HG_MIN, HG_MAX); + PARAM_IN_RANGE(ret, params->hue_gain_cyan, HG_MIN, HG_MAX); + PARAM_IN_RANGE(ret, params->hue_gain_magenta, HG_MIN, HG_MAX); + PARAM_IN_RANGE(ret, params->hue_gain_yellow, HG_MIN, HG_MAX); + PARAM_IN_RANGE(ret, params->hue_gain_overall, HG_MIN, HG_MAX); + + if (ret) + return -EINVAL; + + memcpy(&mdnie->params.cs_params, params, sizeof(*params)); + + return 0; +} + +static int mdnie_set_color_reproduction_params( + struct mdnie_context *mdnie, + const struct drm_mode_color_reproduction *params) +{ + int ret; + + PARAM_IN_RANGE(ret, params->red_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->red_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->red_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->green_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->green_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->green_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->blue_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->blue_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->blue_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->cyan_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->cyan_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->cyan_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->magenta_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->magenta_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->magenta_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->yellow_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->yellow_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->yellow_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->white_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->white_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->white_rgb[2], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->black_rgb[0], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->black_rgb[1], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, params->black_rgb[2], CC_MIN, CC_MAX); + + if (ret) + return -EINVAL; + + memcpy(&mdnie->params.cr_params, params, sizeof(*params)); + return 0; +} + +static int mdnie_set_edge_enhancement_params( + struct mdnie_context *mdnie, + const struct drm_mode_edge_enhancement *params) +{ + int ret; + + PARAM_IN_RANGE(ret, params->edge_th, TH_MIN, TH_MAX); + PARAM_IN_RANGE(ret, params->background_th, TH_MIN, TH_MAX); + PARAM_IN_RANGE(ret, params->pg_edge, GAIN_MIN, GAIN_MAX); + PARAM_IN_RANGE(ret, params->pg_flat, GAIN_MIN, GAIN_MAX); + PARAM_IN_RANGE(ret, params->pg_background, GAIN_MIN, GAIN_MAX); + PARAM_IN_RANGE(ret, params->ng_edge, GAIN_MIN, GAIN_MAX); + PARAM_IN_RANGE(ret, params->ng_flat, GAIN_MIN, GAIN_MAX); + PARAM_IN_RANGE(ret, params->ng_background, GAIN_MIN, GAIN_MAX); + + if (ret) + return -EINVAL; + + memcpy(&mdnie->params.de_params, params, sizeof(*params)); + return 0; +} + +static int mdnie_set_window_params( + struct mdnie_context *mdnie, + const struct drm_exynos_mdnie_window *params) +{ + int ret; + + PARAM_IN_RANGE(ret, params->win_x, X_MIN, X_MAX); + PARAM_IN_RANGE(ret, params->win_y, Y_MIN, Y_MAX); + PARAM_IN_RANGE(ret, params->win_w, params->win_x, X_MAX); + PARAM_IN_RANGE(ret, params->win_h, params->win_y, Y_MAX); + + if (ret) + return -EINVAL; + + memcpy(&mdnie->params.win, params, sizeof(*params)); + return 0; +} + +static int mdnie_enable_sub_modules(struct mdnie_context *mdnie, + uint64_t module_en) +{ + uint64_t mask; + int ret; + + mask = BIT(MDNIE_COLOR_REPRODUCTION) | + BIT(MDNIE_CURVE_CONTROL) | + BIT(MDNIE_COLOR_SATURATION) | + BIT(MDNIE_DETAIL_ENHANCEMENT); + + ret = module_en & ~mask; + + if (ret) + return -EINVAL; + + mdnie->params.modules_enabled = (uint32_t)module_en; + return 0; +} + +static void mdnie_apply_de_params(struct mdnie_context *mdnie) +{ + struct drm_mode_edge_enhancement de = mdnie->params.de_params; + + /* remains contant for all mdnie modes */ + u32 max_out_ratio = 0x1000; + u32 min_out_ratio = 0x0100; + + mdnie_write(mdnie, MDNIE_DE_TH_EDGE, de.edge_th); + mdnie_write(mdnie, MDNIE_DE_TH_BKG, de.background_th); + mdnie_write(mdnie, MDNIE_DE_GAINPOS_EDGE, de.pg_edge); + mdnie_write(mdnie, MDNIE_DE_GAINPOS_FLAT, de.pg_flat); + mdnie_write(mdnie, MDNIE_DE_GAINPOS_BKG, de.pg_background); + mdnie_write(mdnie, MDNIE_DE_GAINNEG_EDGE, de.ng_edge); + mdnie_write(mdnie, MDNIE_DE_GAINNEG_FLAT, de.ng_flat); + mdnie_write(mdnie, MDNIE_DE_GAINNEG_BKG, de.ng_background); + mdnie_write(mdnie, MDNIE_DE_MAX_RATIO, max_out_ratio); + mdnie_write(mdnie, MDNIE_DE_MIN_RATIO, min_out_ratio); +} + +static void mdnie_apply_cs_params(struct mdnie_context *mdnie) +{ + struct drm_mode_color_saturation cs = mdnie->params.cs_params; + + mdnie_write(mdnie, MDNIE_CS_RED_YELLOW_HUE_GAIN, + MDNIE_CS_RED_HUE_GAIN(cs.hue_gain_red) | + MDNIE_CS_YELLOW_HUE_GAIN(cs.hue_gain_yellow)); + + mdnie_write(mdnie, MDNIE_CS_GREEN_CYAN_HUE_GAIN, + MDNIE_CS_GREEN_HUE_GAIN(cs.hue_gain_green) | + MDNIE_CS_CYAN_HUE_GAIN(cs.hue_gain_cyan)); + + mdnie_write(mdnie, MDNIE_CS_BLUE_MAG_HUE_GAIN, + MDNIE_CS_BLUE_HUE_GAIN(cs.hue_gain_blue) | + MDNIE_CS_MAGENTA_HUE_GAIN(cs.hue_gain_magenta)); + + mdnie_write(mdnie, MDNIE_CS_OVERALL_HUE_GAIN_REG, + mdnie_read(mdnie, MDNIE_CS_OVERALL_HUE_GAIN_REG) | + MDNIE_CS_OVERALL_HUE_GAIN(cs.hue_gain_overall)); +} + +static void mdnie_apply_cc_gamma_params(struct mdnie_context *mdnie) +{ + struct exynos_mdnie_drm_gamma *cc = &mdnie->params.gamma_params; + u32 i, val; + u8 strength = MDNIE_DEFAULT_CC_STRENGTH; + u8 gamma_channel = RGB_GAMMA_R; + + val = mdnie_read(mdnie, MDNIE_CC_CHSEL_STRENGTH); + val &= ~(MDNIE_CC_CHSEL_MASK); + val |= MDNIE_CC_CHSEL(gamma_channel); + val &= ~(MDNIE_CC_STRENGTH_MASK); + val |= MDNIE_CC_STRENGTH(strength); + mdnie_write(mdnie, MDNIE_CC_CHSEL_STRENGTH, val); + + mdnie_write(mdnie, MDNIE_CC_GAMMA_RED_0_REG, cc->gamma_r[0]); + for (i = 1; i <= 8; i++) + mdnie_write(mdnie, + MDNIE_CC_GAMMA_RED_0_REG + i, + MDNIE_CC_GAMMA_MSB(cc->gamma_r[i]) | + MDNIE_CC_GAMMA_LSB(cc->gamma_r[i + 8])); + + mdnie_write(mdnie, MDNIE_CC_GAMMA_GREEN_0_REG, cc->gamma_g[0]); + for (i = 1; i <= 8; i++) + mdnie_write(mdnie, + MDNIE_CC_GAMMA_GREEN_0_REG + i, + MDNIE_CC_GAMMA_MSB(cc->gamma_g[i]) | + MDNIE_CC_GAMMA_LSB(cc->gamma_g[i + 8])); + + mdnie_write(mdnie, MDNIE_CC_GAMMA_BLUE_0_REG, cc->gamma_b[0]); + for (i = 1; i <= 8; i++) + mdnie_write(mdnie, + MDNIE_CC_GAMMA_BLUE_0_REG + i, + MDNIE_CC_GAMMA_MSB(cc->gamma_b[i]) | + MDNIE_CC_GAMMA_LSB(cc->gamma_b[i + 8])); +} + +static void mdnie_apply_cr_params(struct mdnie_context *mdnie) +{ + struct drm_mode_color_reproduction cr = mdnie->params.cr_params; + + mdnie_write(mdnie, MDNIE_SCR_R_R, + MDNIE_SCR_MSB(cr.red_rgb[0]) | + MDNIE_SCR_LSB(cr.cyan_rgb[0])); + + mdnie_write(mdnie, MDNIE_SCR_R_G, + MDNIE_SCR_MSB(cr.red_rgb[1]) | + MDNIE_SCR_LSB(cr.cyan_rgb[1])); + + mdnie_write(mdnie, MDNIE_SCR_R_B, + MDNIE_SCR_MSB(cr.red_rgb[2]) | + MDNIE_SCR_LSB(cr.cyan_rgb[2])); + + mdnie_write(mdnie, MDNIE_SCR_G_R, + MDNIE_SCR_MSB(cr.green_rgb[0]) | + MDNIE_SCR_LSB(cr.magenta_rgb[0])); + + mdnie_write(mdnie, MDNIE_SCR_G_G, + MDNIE_SCR_MSB(cr.green_rgb[1]) | + MDNIE_SCR_LSB(cr.magenta_rgb[1])); + + mdnie_write(mdnie, MDNIE_SCR_G_B, + MDNIE_SCR_MSB(cr.green_rgb[2]) | + MDNIE_SCR_LSB(cr.magenta_rgb[2])); + + mdnie_write(mdnie, MDNIE_SCR_B_R, + MDNIE_SCR_MSB(cr.blue_rgb[0]) | + MDNIE_SCR_LSB(cr.yellow_rgb[0])); + + mdnie_write(mdnie, MDNIE_SCR_B_G, + MDNIE_SCR_MSB(cr.blue_rgb[1]) | + MDNIE_SCR_LSB(cr.yellow_rgb[1])); + + mdnie_write(mdnie, MDNIE_SCR_B_B, + MDNIE_SCR_MSB(cr.blue_rgb[2]) | + MDNIE_SCR_LSB(cr.yellow_rgb[2])); + + mdnie_write(mdnie, MDNIE_SCR_K_R, + MDNIE_SCR_MSB(cr.black_rgb[0]) | + MDNIE_SCR_LSB(cr.white_rgb[0])); + + mdnie_write(mdnie, MDNIE_SCR_K_G, + MDNIE_SCR_MSB(cr.black_rgb[1]) | + MDNIE_SCR_LSB(cr.white_rgb[1])); + + mdnie_write(mdnie, MDNIE_SCR_K_B, + MDNIE_SCR_MSB(cr.black_rgb[2]) | + MDNIE_SCR_LSB(cr.white_rgb[2])); +} + +static int exynos_mdnie_update(struct mdnie_context *mdnie) +{ + /* Bank 0 controls */ + exynos_mdnie_bank_sel(mdnie, 0); + + mdnie_set_all_modules_off(mdnie); + mdnie_set_req_modules_on(mdnie); + + if (mdnie->params.modules_enabled & BIT(MDNIE_DETAIL_ENHANCEMENT)) + mdnie_apply_de_params(mdnie); + if (mdnie->params.modules_enabled & BIT(MDNIE_COLOR_SATURATION)) + mdnie_apply_cs_params(mdnie); + + /* Bank 1 controls */ + exynos_mdnie_bank_sel(mdnie, 1); + + if (mdnie->params.modules_enabled & BIT(MDNIE_CURVE_CONTROL)) + mdnie_apply_cc_gamma_params(mdnie); + if (mdnie->params.modules_enabled & BIT(MDNIE_COLOR_REPRODUCTION)) + mdnie_apply_cr_params(mdnie); + + return 0; +} + +static void exynos_fimd_mdnie_cfg(struct mdnie_context *mdnie, int mdnie_on) +{ + u32 val = readl(mdnie->sysreg_disp1blk); + + val &= ~EXYNOS_FIFORST_DISP1; /* DISP1_BLK FIFO reset */ + val &= ~EXYNOS_CLEAR_DISP0; /* Clear DISP0 */ + val &= ~EXYNOS_VT_DISP1_MASK; + val |= EXYNOS_VT_DISP1_RGB; /* Set RGB interface */ + + val |= EXYNOS_FIFORST_DISP1; + + if (mdnie_on) { + val &= ~EXYNOS_FIMDBYPASS_DISP1; /* MIE, MDNIE path */ + val |= EXYNOS_MDNIE_SEL; /* MDNIE */ + val |= EXYNOS_MDNIE_ENABLE; /* ENABLE */ + } else { + val |= EXYNOS_FIMDBYPASS_DISP1; /* FIMD path */ + val &= ~EXYNOS_MDNIE_SEL; /* Clear MDNIE */ + val &= ~EXYNOS_MDNIE_ENABLE; /* Clear MDNIE ENABLE */ + } + writel(val, mdnie->sysreg_disp1blk); +} + +static int exynos_mdnie_power_on(void *pp_ctx) +{ + struct mdnie_context *mdnie = pp_ctx; + int ret = 0; + + exynos_fimd_mdnie_cfg(mdnie, MDNIE_ON); + + ret = clk_prepare_enable(mdnie->mdnie_bus_clk); + if (ret < 0) { + DRM_ERROR("failed to enable mdnie bus clk [%d]\n", ret); + return ret; + } + + ret = clk_prepare_enable(mdnie->mdnie_src_clk); + if (ret < 0) { + DRM_ERROR("failed to enable mdnie src clk [%d]\n", ret); + clk_disable_unprepare(mdnie->mdnie_bus_clk); + return ret; + } + + ret = exynos_mdnie_set_size(mdnie); + exynos_mdnie_update(mdnie); + + return ret; +} + +static int exynos_mdnie_power_off(void *pp_ctx) +{ + struct mdnie_context *mdnie = pp_ctx; + + clk_disable_unprepare(mdnie->mdnie_src_clk); + clk_disable_unprepare(mdnie->mdnie_bus_clk); + + exynos_fimd_mdnie_cfg(mdnie, MDNIE_OFF); + + return 0; +} + +static int exynos_mdnie_set_property(struct drm_device *drm_dev, + void *pp_ctx, struct drm_property *property, uint64_t val) +{ + struct mdnie_context *mdnie = pp_ctx; + struct drm_property_blob *blob; + struct drm_mode_object *blob_obj; + int ret = 0; + + DRM_DEBUG("[PROP:%s, VALUE:%llu]\n", property->name, val); + + if (drm_dev->mode_config.color_saturation_property == property) { + blob = drm_dev->mode_config.color_saturation_blob_ptr; + ret = mdnie_set_color_saturation_params(mdnie, + (struct drm_mode_color_saturation *)blob->data); + if (ret) + return ret; + } + + if (drm_dev->mode_config.color_reproduction_property == property) { + blob = drm_dev->mode_config.color_reproduction_blob_ptr; + mdnie_set_color_reproduction_params(mdnie, + (struct drm_mode_color_reproduction *)blob->data); + if (ret) + return ret; + } + + if (drm_dev->mode_config.edge_enhancement_property == property) { + blob = drm_dev->mode_config.edge_enhancement_blob_ptr; + mdnie_set_edge_enhancement_params(mdnie, + (struct drm_mode_edge_enhancement *)blob->data); + if (ret) + return ret; + } + + if (!strcmp("mdnie_window", property->name)) { + blob_obj = drm_mode_object_find(drm_dev, val, + DRM_MODE_OBJECT_BLOB); + blob = obj_to_blob(blob_obj); + + mdnie_set_window_params(mdnie, + (struct drm_exynos_mdnie_window *)blob->data); + if (ret) + return ret; + } + + if (!strcmp("mdnie_modules_enable", property->name)) { + mdnie_enable_sub_modules(mdnie, val); + if (ret) + return ret; + } + + return 0; +} + +static int exynos_mdnie_set_gamma(void *pp_ctx, u16 *r, u16 *g, + u16 *b, uint32_t start, uint32_t size) +{ + struct mdnie_context *mdnie = pp_ctx; + struct exynos_mdnie_drm_gamma *gamma = &mdnie->params.gamma_params; + int i, ret; + + DRM_DEBUG("[LENGTH :%u]\n", size); + + if (size > GAMMA_RAMP_LENGTH) + return -EINVAL; + + for (i = 0; i < size; i++) { + PARAM_IN_RANGE(ret, r[i], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, g[i], CC_MIN, CC_MAX); + PARAM_IN_RANGE(ret, b[i], CC_MIN, CC_MAX); + } + + if (ret) + return -EINVAL; + + for (i = 0; i < size; i++) { + gamma->gamma_r[i] = r[i]; + gamma->gamma_g[i] = g[i]; + gamma->gamma_b[i] = b[i]; + } + + return 0; +} + +void exynos_mdnie_mode_set(void *pp_ctx, + const struct drm_display_mode *in_mode) +{ + struct mdnie_context *mdnie = pp_ctx; + + DRM_DEBUG("[MODE :%s]\n", in_mode->name); + + /* preserve mode everytime for later use */ + drm_mode_copy(&mdnie->mode, in_mode); +} + +static struct exynos_fimd_pp_ops mdnie_ops = { + .power_on = exynos_mdnie_power_on, + .power_off = exynos_mdnie_power_off, + .set_property = exynos_mdnie_set_property, + .set_gamma = exynos_mdnie_set_gamma, + .mode_set = exynos_mdnie_mode_set, +}; + +static struct exynos_fimd_pp mdnie_pp = { + .ops = &mdnie_ops, +}; + +static int dt_parse_disp1blk_cfg(struct device *dev, u32 *disp1blk_addr) +{ + struct device_node *np = dev->of_node; + + if (of_property_read_u32(np, "samsung,disp1blk-cfg", disp1blk_addr)) { + DRM_INFO("No DISP1BLK_CFG property present, " + "MDNIE feature will be disabled\n"); + return -EINVAL; + } + + return 0; +} + +static int exynos_iomap_disp1blk(struct mdnie_context *mdnie, + u32 disp1blk_addr) +{ + mdnie->sysreg_disp1blk = ioremap(disp1blk_addr, 4); + if (!mdnie->sysreg_disp1blk) { + DRM_ERROR("failed to ioremap DISP1BLK_CFG\n"); + return -ENOMEM; + } + + return 0; +} + +int exynos_mdnie_init(struct device *dev, struct exynos_fimd_pp **pp) +{ + struct device_node *np = dev->of_node; + struct device_node *mdnie_np; + struct mdnie_context *mdnie = NULL; + u32 disp1blk_phyaddr; + int ret = 0; + u32 buf[2]; + + mdnie_np = of_parse_phandle(np, "samsung,mdnie", 0); + if (!mdnie_np) { + DRM_INFO("No mdnie node present, " + "MDNIE feature will be disabled\n"); + ret = -EINVAL; + goto err0; + } + + if (of_property_read_u32_array(mdnie_np, "reg", buf, 2)) { + DRM_ERROR("failed to get base address for MDNIE\n"); + ret = -ENOMEM; + goto err0; + } + + mdnie = kzalloc(sizeof(struct mdnie_context), GFP_KERNEL); + if (!mdnie) { + DRM_ERROR("failed to allocate mdnie\n"); + ret = -ENOMEM; + goto err0; + } + + mdnie->exynos_mdnie_base = ioremap(buf[0], buf[1]); + if (!mdnie->exynos_mdnie_base) { + DRM_ERROR("failed to ioremap mdnie device\n"); + ret = -ENOMEM; + goto err1; + } + + if (dt_parse_disp1blk_cfg(dev, &disp1blk_phyaddr)) { + DRM_ERROR("failed to get disp1blk property.\n"); + ret = -ENODEV; + goto err1; + } + + if (exynos_iomap_disp1blk(mdnie, disp1blk_phyaddr)) { + DRM_ERROR("failed to iopmap disp1blk sysreg.\n"); + ret = -ENODEV; + goto err1; + } + + /* Setup MDNIE clocks */ + mdnie->mdnie_bus_clk = devm_clk_get(dev, "mdnie"); + if (IS_ERR(mdnie->mdnie_bus_clk)) { + DRM_ERROR("failed to get mdnie bus clock\n"); + ret = PTR_ERR(mdnie->mdnie_bus_clk); + goto err1; + } + + mdnie->mdnie_src_clk = devm_clk_get(dev, "sclk_mdnie"); + if (IS_ERR(mdnie->mdnie_src_clk)) { + DRM_ERROR("failed to get mdnie_src_clk\n"); + ret = PTR_ERR(mdnie->mdnie_src_clk); + goto err1; + } + + mdnie_pp.ctx = mdnie; + *pp = &mdnie_pp; + + DRM_INFO("MDNIE initialzation done\n"); + + return 0; + +err1: + kfree(mdnie); +err0: + return ret; +} +EXPORT_SYMBOL(exynos_mdnie_init); diff --git a/drivers/gpu/drm/exynos/exynos_mdnie_regs.h b/drivers/gpu/drm/exynos/exynos_mdnie_regs.h new file mode 100644 index 0000000..66a8edc --- /dev/null +++ b/drivers/gpu/drm/exynos/exynos_mdnie_regs.h @@ -0,0 +1,154 @@ +/* drivers/gpu/drm/exynos/exynos_mdnie_regs.h + * + * Header file for Samsung (MDNIE) driver + * + * Copyright (c) 2014 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#ifndef __REGS_MDNIE_H__ +#define __REGS_MDNIE_H__ + +/* Exynos DISP1BLK_CFG register */ +#define EXYNOS_MDNIE_ENABLE (1 << 0) +#define EXYNOS_MDNIE_SEL (1 << 14) +#define EXYNOS_FIMDBYPASS_DISP1 (1 << 15) +#define EXYNOS_FIFORST_DISP1 (1 << 23) +#define EXYNOS_CLEAR_DISP0 (1 << 27) +#define EXYNOS_VT_DISP1_MASK (3 << 24) +#define EXYNOS_VT_DISP1_RGB (0 << 24) +#define EXYNOS_VT_DISP1_I80 (1 << 24) + +#define MDNIE_REG_WIDTH 0xFFFF +#define MDNIE_REG_OFFSET_LIMIT 0xFF + +/* BANK 0: MODULE_TOP */ +#define MDNIE_TOP_R0 0x0000 +#define MDNIE_TOP_R0_BANK0_SEL (0 << 0) +#define MDNIE_TOP_R0_BANK1_SEL (1 << 0) +#define MDNIE_TOP_R0_SHADOW_SEL (1 << 3) +#define MDNIE_TOP_R1 0x0001 +#define MDNIE_TOP_R1_MASK_INPUT_DATA_ENABLE (1 << 10) +#define MDNIE_TOP_R1_MASK_INPUT_HSYNC (1 << 9) +#define MDNIE_TOP_RIHSIZE 0x0003 +#define MDNIE_TOP_RSIZE_MAX 2560 +#define MDNIE_TOP_RIVSIZE 0x0004 +#define MDNIE_TOP_R8 0x0008 +#define MDNIE_TOP_R8_DITH_MODULE_ON (1 << 13) +#define MDNIE_TOP_R8_ABC_MODULE_ON (1 << 11) +#define MDNIE_TOP_R8_SCR_MODULE_ON (1 << 9) +#define MDNIE_TOP_R8_CC_MODULE_ON (1 << 8) +#define MDNIE_TOP_R8_CS_MODULE_ON (1 << 5) +#define MDNIE_TOP_R8_DE_MODULE_ON (1 << 4) +#define MDNIE_TOP_R9 0x0009 +#define MDNIE_TOP_R9_MCM_MODULE_ON (1 << 0) +#define MDNIE_TOP_RA 0x000A +#define MDNIE_TOP_RA_UC_MODULE_ON (1 << 0) +#define MDNIE_TOP_RB 0x000B + +/* BANK 0: MODULE_DE */ +#define MDNIE_DE_TH_EDGE 0xB0 +#define MDNIE_DE_TH_BKG 0xB1 +#define MDNIE_DE_TH_MAX 2047 + +#define MDNIE_DE_GAINPOS_EDGE 0xB2 +#define MDNIE_DE_GAINPOS_FLAT 0xB3 +#define MDNIE_DE_GAINPOS_BKG 0xB4 +#define MDNIE_DE_GAINNEG_EDGE 0xB5 +#define MDNIE_DE_GAINNEG_FLAT 0xB6 +#define MDNIE_DE_GAINNEG_BKG 0xB7 +#define MDNIE_DE_GAIN_MAX 8191 + +#define MDNIE_DE_MAX_RATIO 0xB8 +#define MDNIE_DE_MAX_RATIO_MIN 1024 +#define MDNIE_DE_MAX_RATIO_MAX 65535 +#define MDNIE_DE_MIN_RATIO 0xB9 +#define MDNIE_DE_MIN_RATIO_MIN 0 +#define MDNIE_DE_MIN_RATIO_MAX 1024 +#define MDNIE_DE_RBA 0xBA +#define MDNIE_DE_RBA_MAXPLUS(x) ((x & 0xFF) << 8) +#define MDNIE_DE_RBA_MAXMINUS(x) ((x & 0xFF) << 0) + +/* BANK 0: MODULE_CS */ +#define MDNIE_CS_RED_YELLOW_HUE_GAIN 0xC0 +#define MDNIE_CS_RED_HUE_GAIN(x) ((x & 0x3F) << 8) +#define MDNIE_CS_YELLOW_HUE_GAIN(x) ((x & 0x3F) << 0) +#define MDNIE_CS_GREEN_CYAN_HUE_GAIN 0xC1 +#define MDNIE_CS_GREEN_HUE_GAIN(x) ((x & 0x3F) << 8) +#define MDNIE_CS_CYAN_HUE_GAIN(x) ((x & 0x3F) << 0) +#define MDNIE_CS_BLUE_MAG_HUE_GAIN 0xC2 +#define MDNIE_CS_BLUE_HUE_GAIN(x) ((x & 0x3F) << 8) +#define MDNIE_CS_MAGENTA_HUE_GAIN(x) ((x & 0x3F) << 0) +#define MDNIE_CS_OVERALL_HUE_GAIN_REG 0xC3 +#define MDNIE_CS_OVERALL_HUE_GAIN(x) ((x & 0x3F) << 8) +#define MDNIE_CS_HUE_GAIN_MAX 0x3F + +/* BANK 0: RELEASE0 */ +#define MDNIE_RELEASE_RFF 0x00FF +#define MDNIE_RELEASE_RFF_MASK_REGISTERS (1 << 0) + +/* BANK 1: MODULE_CC */ +#define MDNIE_CC_CHSEL_STRENGTH 0x13F +#define MDNIE_CC_CHSEL_MASK ((0x3 << 0x8)) +#define MDNIE_CC_CHSEL(x) ((x) << 0x8) +#define MDNIE_CC_STRENGTH_MASK 0xFF +#define MDNIE_CC_STRENGTH(x) (x << 0) +#define MDNIE_DEFAULT_CC_STRENGTH 0x80 + +/* Gamma Ramp */ +#define MDNIE_CC_GAMMA_RED_0_REG 0x140 +#define MDNIE_CC_GAMMA_GREEN_0_REG 0x150 +#define MDNIE_CC_GAMMA_BLUE_0_REG 0x160 +#define MDNIE_CC_GAMMA_MSB(x) ((x & 0xFF) << 8) +#define MDNIE_CC_GAMMA_LSB(x) ((x & 0xFF) << 0) + +/* MODULE SCRPLUS */ +#define MDNIE_SCR_GCC_ONOFF 0x170 +#define MDNIE_SCR_GCC_ON (1 << 0) +#define MDNIE_SCR_R_R 0x171 +#define MDNIE_SCR_R_G 0x172 +#define MDNIE_SCR_R_B 0x173 +#define MDNIE_SCR_G_R 0x174 +#define MDNIE_SCR_G_G 0x175 +#define MDNIE_SCR_G_B 0x176 +#define MDNIE_SCR_B_R 0x177 +#define MDNIE_SCR_B_G 0x178 +#define MDNIE_SCR_B_B 0x179 +#define MDNIE_SCR_K_R 0x17A +#define MDNIE_SCR_K_G 0x17B +#define MDNIE_SCR_K_B 0x17C +#define MDNIE_SCR_MSB(x) ((x & 0xFF) << 8) +#define MDNIE_SCR_LSB(x) ((x & 0xFF) << 0) + +/* Hue gain ranges */ +#define HG_MIN 0 +#define HG_MAX 63 + +/* Color Component ranges */ +#define CC_MIN 0 +#define CC_MAX 255 + +/* threshold ranges */ +#define TH_MIN 0 +#define TH_MAX 2047 + +/* pos/neg gain ranges */ +#define GAIN_MIN 0 +#define GAIN_MAX 8191 + +/* window ranges */ +#define X_MIN 0 +#define X_MAX 1920 +#define Y_MIN 0 +#define Y_MAX 1080 + +/* gamma modes */ +#define RGB_GAMMA_R 0 +#define R_GAMMA_R 1 +#define Y_GAMMA_R 2 + +#endif