Ksawlii/kernel_samsung_a53x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kernel_samsung_a53x/drivers/gpu/drm/samsung/panel/mdnie.c

1900 lines
49 KiB
C
Raw Normal View History

Import A536BXXU9EXDC
2024-06-15 16:02:09 -03:00
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 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 version 2 as
* published by the Free Software Foundation.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/mm.h>
#include <linux/device.h>
#include <linux/backlight.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/lcd.h>
#include <linux/fb.h>
#include <linux/pm_runtime.h>
#include "panel_kunit.h"
#include "panel_drv.h"
#include "mdnie.h"
#include "panel_debug.h"
#ifdef CONFIG_EXYNOS_DECON_LCD_COPR
#include "copr.h"
#endif
#ifdef CONFIG_DISPLAY_USE_INFO
#include "dpui.h"
#endif
#ifdef MDNIE_SELF_TEST
int g_coord_x = MIN_WCRD_X;
int g_coord_y = MIN_WCRD_Y;
#endif
static const char * const mdnie_maptbl_name[] = {
[MDNIE_UI_MAPTBL] = "ui",
[MDNIE_VIDEO_MAPTBL] = "video",
[MDNIE_CAMERA_MAPTBL] = "camera",
[MDNIE_GALLERY_MAPTBL] = "gallery",
[MDNIE_VT_MAPTBL] = "vt",
[MDNIE_BROWSER_MAPTBL] = "browser",
[MDNIE_EBOOK_MAPTBL] = "ebook",
[MDNIE_EMAIL_MAPTBL] = "email",
[MDNIE_GAME_LOW_MAPTBL] = "game_low",
[MDNIE_GAME_MID_MAPTBL] = "game_mid",
[MDNIE_GAME_HIGH_MAPTBL] = "game_high",
[MDNIE_VIDEO_ENHANCER_MAPTBL] = "video_enhancer",
[MDNIE_VIDEO_ENHANCER_THIRD_MAPTBL] = "video_enhancer_third",
[MDNIE_HMD_8_MAPTBL] = "hmd_8",
[MDNIE_HMD_16_MAPTBL] = "hmd_16",
#if defined(CONFIG_TDMB)
[MDNIE_DMB_MAPTBL] = "dmb",
#endif
/* ACCESSIBILITY */
[MDNIE_NEGATIVE_MAPTBL] = "negative",
[MDNIE_COLOR_BLIND_MAPTBL] = "color_blind",
[MDNIE_SCREEN_CURTAIN_MAPTBL] = "screen_curtain",
[MDNIE_GRAYSCALE_MAPTBL] = "grayscale",
[MDNIE_GRAYSCALE_NEGATIVE_MAPTBL] = "grayscale_negative",
[MDNIE_COLOR_BLIND_HBM_MAPTBL] = "color_blind_hbm",
/* BYPASS */
[MDNIE_BYPASS_MAPTBL] = "bypass",
/* HBM */
[MDNIE_HBM_MAPTBL] = "hbm",
/* HMD */
[MDNIE_HMD_MAPTBL] = "hmd",
/* HDR */
[MDNIE_HDR_MAPTBL] = "hdr",
/* NIGHT */
[MDNIE_NIGHT_MAPTBL] = "night",
/* LIGHT_NOTIFICATION */
[MDNIE_LIGHT_NOTIFICATION_MAPTBL] = "light_notification",
/* COLOR_LENS */
[MDNIE_COLOR_LENS_MAPTBL] = "color_lens",
};
static const char * const scr_white_mode_name[] = {
[SCR_WHITE_MODE_NONE] = "none",
[SCR_WHITE_MODE_COLOR_COORDINATE] = "coordinate",
[SCR_WHITE_MODE_ADJUST_LDU] = "adjust-ldu",
[SCR_WHITE_MODE_SENSOR_RGB] = "sensor-rgb",
};
static const char * const mdnie_mode_name[] = {
[MDNIE_OFF_MODE] = "off",
[MDNIE_BYPASS_MODE] = "bypass",
[MDNIE_LIGHT_NOTIFICATION_MODE] = "light_notification",
[MDNIE_ACCESSIBILITY_MODE] = "accessibility",
[MDNIE_COLOR_LENS_MODE] = "color_lens",
[MDNIE_HDR_MODE] = "hdr",
[MDNIE_HMD_MODE] = "hmd",
[MDNIE_NIGHT_MODE] = "night",
[MDNIE_HBM_MODE] = "hbm",
[MDNIE_DMB_MODE] = "dmb",
[MDNIE_SCENARIO_MODE] = "scenario",
};
static const char * const scenario_mode_name[] = {
[DYNAMIC] = "dynamic",
[STANDARD] = "standard",
[NATURAL] = "natural",
[MOVIE] = "movie",
[AUTO] = "auto",
};
static const char * const scenario_name[] = {
[UI_MODE] = "ui",
[VIDEO_NORMAL_MODE] = "video_normal",
[CAMERA_MODE] = "camera",
[NAVI_MODE] = "navi",
[GALLERY_MODE] = "gallery",
[VT_MODE] = "vt",
[BROWSER_MODE] = "browser",
[EBOOK_MODE] = "ebook",
[EMAIL_MODE] = "email",
[GAME_LOW_MODE] = "game_low",
[GAME_MID_MODE] = "game_mid",
[GAME_HIGH_MODE] = "game_high",
[VIDEO_ENHANCER] = "video_enhancer",
[VIDEO_ENHANCER_THIRD] = "video_enhancer_third",
[HMD_8_MODE] = "hmd_8",
[HMD_16_MODE] = "hmd_16",
[DMB_NORMAL_MODE] = "dmb_normal",
};
static const char * const accessibility_name[] = {
[ACCESSIBILITY_OFF] = "off",
[NEGATIVE] = "negative",
[COLOR_BLIND] = "color_blind",
[SCREEN_CURTAIN] = "screen_curtain",
[GRAYSCALE] = "grayscale",
[GRAYSCALE_NEGATIVE] = "grayscale_negative",
[COLOR_BLIND_HBM] = "color_blind_hbm",
};
int mdnie_current_state(struct mdnie_info *mdnie)
{
struct panel_device *panel =
container_of(mdnie, struct panel_device, mdnie);
int mdnie_mode;
if (IS_BYPASS_MODE(mdnie))
mdnie_mode = MDNIE_BYPASS_MODE;
else if (IS_LIGHT_NOTIFICATION_MODE(mdnie))
mdnie_mode = MDNIE_LIGHT_NOTIFICATION_MODE;
else if (IS_ACCESSIBILITY_MODE(mdnie))
mdnie_mode = MDNIE_ACCESSIBILITY_MODE;
else if (IS_COLOR_LENS_MODE(mdnie))
mdnie_mode = MDNIE_COLOR_LENS_MODE;
else if (IS_HMD_MODE(mdnie))
mdnie_mode = MDNIE_HMD_MODE;
else if (IS_NIGHT_MODE(mdnie))
mdnie_mode = MDNIE_NIGHT_MODE;
else if (IS_HBM_MODE(mdnie))
mdnie_mode = MDNIE_HBM_MODE;
else if (IS_HDR_MODE(mdnie))
mdnie_mode = MDNIE_HDR_MODE;
#if defined(CONFIG_TDMB)
else if (IS_DMB_MODE(mdnie))
mdnie_mode = MDNIE_DMB_MODE;
#endif
else if (IS_SCENARIO_MODE(mdnie))
mdnie_mode = MDNIE_SCENARIO_MODE;
else
mdnie_mode = MDNIE_OFF_MODE;
if (panel->state.cur_state == PANEL_STATE_ALPM &&
((mdnie_mode == MDNIE_ACCESSIBILITY_MODE &&
(mdnie->props.accessibility == NEGATIVE ||
mdnie->props.accessibility == GRAYSCALE_NEGATIVE)) ||
(mdnie_mode == MDNIE_SCENARIO_MODE && !IS_LDU_MODE(mdnie)) ||
mdnie_mode == MDNIE_COLOR_LENS_MODE ||
mdnie_mode == MDNIE_DMB_MODE ||
mdnie_mode == MDNIE_HDR_MODE ||
mdnie_mode == MDNIE_LIGHT_NOTIFICATION_MODE ||
mdnie_mode == MDNIE_HMD_MODE)) {
panel_dbg("block mdnie (%s->%s) in doze mode\n",
mdnie_mode_name[mdnie_mode],
mdnie_mode_name[MDNIE_BYPASS_MODE]);
mdnie_mode = MDNIE_BYPASS_MODE;
}
return mdnie_mode;
}
__mockable int mdnie_get_maptbl_index(struct mdnie_info *mdnie)
{
int index;
int mdnie_mode = mdnie_current_state(mdnie);
switch (mdnie_mode) {
case MDNIE_BYPASS_MODE:
index = MDNIE_BYPASS_MAPTBL;
break;
case MDNIE_LIGHT_NOTIFICATION_MODE:
index = MDNIE_LIGHT_NOTIFICATION_MAPTBL;
break;
case MDNIE_ACCESSIBILITY_MODE:
index = MAPTBL_IDX_ACCESSIBILITY(mdnie->props.accessibility);
break;
case MDNIE_COLOR_LENS_MODE:
index = MDNIE_COLOR_LENS_MAPTBL;
break;
case MDNIE_HDR_MODE:
index = MDNIE_HDR_MAPTBL;
break;
case MDNIE_HMD_MODE:
index = MDNIE_HMD_MAPTBL;
break;
case MDNIE_NIGHT_MODE:
index = MDNIE_NIGHT_MAPTBL;
break;
case MDNIE_HBM_MODE:
index = MDNIE_HBM_MAPTBL;
break;
#if defined(CONFIG_TDMB)
case MDNIE_DMB_MODE:
index = MDNIE_DMB_MAPTBL;
break;
#endif
case MDNIE_SCENARIO_MODE:
index = MAPTBL_IDX_SCENARIO(mdnie->props.scenario);
break;
default:
index = -EINVAL;
panel_err("unknown mdnie\n");
break;
}
if (index >= 0 && index < MAX_MDNIE_MAPTBL) {
panel_dbg("mdnie %s(%d), maptbl %s(%d) found\n",
mdnie_mode_name[mdnie_mode],
mdnie_mode, mdnie_maptbl_name[index], index);
} else {
panel_err("mdnie %s(%d), maptbl not found!! (%d)\n",
mdnie_mode_name[mdnie_mode],
mdnie_mode, index);
index = MDNIE_UI_MAPTBL;
}
return index;
}
EXPORT_SYMBOL(mdnie_get_maptbl_index);
struct maptbl *mdnie_find_maptbl(struct mdnie_info *mdnie)
{
int index = mdnie_get_maptbl_index(mdnie);
if (unlikely(index < 0 || index >= MAX_MDNIE_MAPTBL)) {
panel_err("failed to find maptbl %d\n", index);
return NULL;
}
return &mdnie->maptbl[index];
}
EXPORT_SYMBOL(mdnie_find_maptbl);
struct maptbl *mdnie_find_etc_maptbl(struct mdnie_info *mdnie, int index)
{
if (unlikely(index < 0 || index >= mdnie->nr_etc_maptbl)) {
panel_err("failed to find maptbl %d\n", index);
return NULL;
}
return &mdnie->etc_maptbl[index];
}
EXPORT_SYMBOL(mdnie_find_etc_maptbl);
struct maptbl *mdnie_find_scr_white_maptbl(struct mdnie_info *mdnie, int index)
{
if (unlikely(index < 0 || index >= mdnie->nr_scr_white_maptbl)) {
panel_err("failed to find maptbl %d\n", index);
return NULL;
}
return &mdnie->scr_white_maptbl[index];
}
__visible_for_testing int mdnie_get_coordinate(struct mdnie_info *mdnie, int *x, int *y)
{
struct panel_device *panel =
container_of(mdnie, struct panel_device, mdnie);
struct panel_info *panel_data = &panel->panel_data;
u8 coordinate[PANEL_COORD_LEN] = { 0, };
int ret;
if (!mdnie || !x || !y) {
panel_err("invalid parameter\n");
return -EINVAL;
}
ret = resource_copy_by_name(panel_data, coordinate, "coordinate");
if (ret < 0) {
panel_err("failed to copy 'coordinate' resource\n");
return -EINVAL;
}
*x = (coordinate[0] << 8) | coordinate[1];
*y = (coordinate[2] << 8) | coordinate[3];
#ifdef MDNIE_SELF_TEST
*x = g_coord_x;
*y = g_coord_y;
#endif
if (*x < MIN_WCRD_X || *x > MAX_WCRD_X ||
*y < MIN_WCRD_Y || *y > MAX_WCRD_Y)
panel_warn("need to check coord_x:%d coord_y:%d)\n", *x, *y);
return 0;
}
static bool mdnie_coordinate_changed(struct mdnie_info *mdnie)
{
int x, y;
mdnie_get_coordinate(mdnie, &x, &y);
return (mdnie->props.wcrd_x != x || mdnie->props.wcrd_y != y);
}
static int mdnie_coordinate_area(struct mdnie_info *mdnie, int x, int y)
{
s64 result[MAX_CAL_LINE];
int i, area;
for (i = 0; i < MAX_CAL_LINE; i++)
result[i] = COLOR_OFFSET_FUNC(x, y,
mdnie->props.line[i].num,
mdnie->props.line[i].den,
mdnie->props.line[i].con);
area = RECOGNIZE_REGION(result[H_LINE], result[V_LINE]);
panel_dbg("coord %d %d area Q%d, result %lld %lld\n",
x, y, area + 1, result[H_LINE], result[V_LINE]);
return area;
}
static int mdnie_coordinate_tune_x(struct mdnie_info *mdnie, int x, int y)
{
int res, area;
area = mdnie_coordinate_area(mdnie, x, y);
res = ((mdnie->props.coef[area].a * x) + (mdnie->props.coef[area].b * y) +
(((mdnie->props.coef[area].c * x + (1L << 9)) >> 10) * y) +
(mdnie->props.coef[area].d * 10000) + (1L << 9)) >> 10;
return max(min(res, 1024), 0);
}
static int mdnie_coordinate_tune_y(struct mdnie_info *mdnie, int x, int y)
{
int res, area;
area = mdnie_coordinate_area(mdnie, x, y);
res = ((mdnie->props.coef[area].e * x) + (mdnie->props.coef[area].f * y) +
(((mdnie->props.coef[area].g * x + (1L << 9)) >> 10) * y) +
(mdnie->props.coef[area].h * 10000) + (1L << 9)) >> 10;
return max(min(res, 1024), 0);
}
static void mdnie_coordinate_tune_rgb(struct mdnie_info *mdnie, int x, int y, u8 (*tune_rgb)[MAX_COLOR])
{
static int pt[MAX_QUAD][MAX_RGB_PT] = {
{ CCRD_PT_5, CCRD_PT_2, CCRD_PT_6, CCRD_PT_3 }, /* QUAD_1 */
{ CCRD_PT_5, CCRD_PT_2, CCRD_PT_4, CCRD_PT_1 }, /* QUAD_2 */
{ CCRD_PT_5, CCRD_PT_8, CCRD_PT_4, CCRD_PT_7 }, /* QUAD_3 */
{ CCRD_PT_5, CCRD_PT_8, CCRD_PT_6, CCRD_PT_9 }, /* QUAD_4 */
};
int i, c, type, area, tune_x, tune_y, res[MAX_COLOR][MAX_RGB_PT];
s64 result[MAX_CAL_LINE];
area = mdnie_coordinate_area(mdnie, x, y);
if (((x - mdnie->props.cal_x_center) * (x - mdnie->props.cal_x_center) + (y - mdnie->props.cal_y_center) * (y - mdnie->props.cal_y_center)) <= mdnie->props.cal_boundary_center) {
tune_x = 0;
tune_y = 0;
} else {
tune_x = mdnie_coordinate_tune_x(mdnie, x, y);
tune_y = mdnie_coordinate_tune_y(mdnie, x, y);
}
for (i = 0; i < MAX_CAL_LINE; i++)
result[i] = COLOR_OFFSET_FUNC(x, y,
mdnie->props.line[i].num,
mdnie->props.line[i].den,
mdnie->props.line[i].con);
for (type = 0; type < MAX_WCRD_TYPE; type++) {
for (c = 0; c < MAX_COLOR; c++) {
for (i = 0; i < MAX_RGB_PT; i++)
res[c][i] = mdnie->props.vtx[type][pt[area][i]][c];
tune_rgb[type][c] =
((((res[c][RGB_00] * (1024 - tune_x) + (res[c][RGB_10] * tune_x)) * (1024 - tune_y)) +
((res[c][RGB_01] * (1024 - tune_x) + (res[c][RGB_11] * tune_x)) * tune_y)) + (1L << 19)) >> 20;
}
}
panel_info("coord (x:%4d y:%4d Q%d compV:%8lld compH:%8lld)\t"
"tune_coord (%4d %4d) tune_rgb[ADT] (%3d %3d %3d) tune_rgb[D65] (%3d %3d %3d)\n",
x, y, area + 1, result[H_LINE], result[V_LINE], tune_x, tune_y,
tune_rgb[WCRD_TYPE_ADAPTIVE][0], tune_rgb[WCRD_TYPE_ADAPTIVE][1],
tune_rgb[WCRD_TYPE_ADAPTIVE][2], tune_rgb[WCRD_TYPE_D65][0],
tune_rgb[WCRD_TYPE_D65][1], tune_rgb[WCRD_TYPE_D65][2]);
}
__visible_for_testing int mdnie_init_coordinate_tune(struct mdnie_info *mdnie)
{
int x, y;
if (!mdnie)
return -EINVAL;
mdnie_get_coordinate(mdnie, &x, &y);
mdnie->props.wcrd_x = x;
mdnie->props.wcrd_y = y;
mdnie_coordinate_tune_rgb(mdnie, x, y, mdnie->props.coord_wrgb);
return 0;
}
static int panel_set_mdnie(struct panel_device *panel)
{
int ret;
struct mdnie_info *mdnie = &panel->mdnie;
int mdnie_mode = mdnie_current_state(mdnie);
if (panel == NULL) {
panel_err("panel is null\n");
return -EINVAL;
}
if (!IS_PANEL_ACTIVE(panel))
return -EAGAIN;
#ifdef CONFIG_SUPPORT_AFC
panel_info("do mdnie-seq (mode:%s, afc:%s)\n",
mdnie_mode_name[mdnie_mode],
!mdnie->props.afc_on ? "off" : "on");
#else
panel_info("do mdnie-seq (mode:%s)\n",
mdnie_mode_name[mdnie_mode]);
#endif
ret = 0;
mutex_lock(&panel->op_lock);
ret = panel_do_seqtbl(panel, &mdnie->seqtbl[MDNIE_SET_SEQ]);
if (unlikely(ret < 0))
panel_err("failed to write mdnie seqtbl\n");
#ifdef CONFIG_SUPPORT_AFC
ret = panel_do_seqtbl(panel, !mdnie->props.afc_on ?
&mdnie->seqtbl[MDNIE_AFC_OFF_SEQ] :
&mdnie->seqtbl[MDNIE_AFC_ON_SEQ]);
if (unlikely(ret < 0))
panel_err("failed to write afc seqtbl\n");
#endif
mutex_unlock(&panel->op_lock);
return ret;
}
static void mdnie_maptbl_init(struct mdnie_info *mdnie, int index)
{
int i;
if (((index + 1) * mdnie->nr_reg) > mdnie->nr_maptbl) {
panel_err("out of range index %d\n", index);
return;
}
for (i = 0; i < mdnie->nr_reg; i++)
maptbl_init(&mdnie->maptbl[index * mdnie->nr_reg + i]);
}
static void scr_white_maptbl_init(struct mdnie_info *mdnie, int index)
{
if ((index + 1) > mdnie->nr_scr_white_maptbl) {
panel_err("out of range index %d\n", index);
return;
}
maptbl_init(&mdnie->scr_white_maptbl[index]);
}
static void scr_white_maptbls_init(struct mdnie_info *mdnie)
{
int i;
for (i = 0; i < mdnie->nr_scr_white_maptbl; i++)
maptbl_init(&mdnie->scr_white_maptbl[i]);
}
static void mdnie_update_scr_white_mode(struct mdnie_info *mdnie)
{
int mdnie_mode = mdnie_current_state(mdnie);
if (mdnie_mode == MDNIE_SCENARIO_MODE) {
if ((IS_LDU_MODE(mdnie)) && (mdnie->props.scenario != EBOOK_MODE)) {
mdnie->props.scr_white_mode = SCR_WHITE_MODE_ADJUST_LDU;
} else if (mdnie->props.update_sensorRGB &&
mdnie->props.mode == AUTO &&
(mdnie->props.scenario == BROWSER_MODE ||
mdnie->props.scenario == EBOOK_MODE)) {
mdnie->props.scr_white_mode = SCR_WHITE_MODE_SENSOR_RGB;
mdnie->props.update_sensorRGB = false;
} else if (mdnie->props.scenario <= SCENARIO_MAX &&
mdnie->props.scenario != EBOOK_MODE) {
mdnie->props.scr_white_mode =
SCR_WHITE_MODE_COLOR_COORDINATE;
} else {
mdnie->props.scr_white_mode = SCR_WHITE_MODE_NONE;
}
} else if (mdnie_mode == MDNIE_HBM_MODE) {
mdnie->props.scr_white_mode =
SCR_WHITE_MODE_COLOR_COORDINATE;
} else {
mdnie->props.scr_white_mode = SCR_WHITE_MODE_NONE;
}
panel_dbg("scr_white_mode %s\n",
scr_white_mode_name[mdnie->props.scr_white_mode]);
}
int mdnie_set_def_wrgb(struct mdnie_info *mdnie,
unsigned char r, unsigned char g, unsigned char b)
{
if (!mdnie)
return -EINVAL;
mdnie->props.def_wrgb[RED] = r;
mdnie->props.def_wrgb[GREEN] = g;
mdnie->props.def_wrgb[BLUE] = b;
panel_dbg("def_wrgb: %d(%02X) %d(%02X) %d(%02X)\n",
mdnie->props.def_wrgb[RED], mdnie->props.def_wrgb[RED],
mdnie->props.def_wrgb[GREEN], mdnie->props.def_wrgb[GREEN],
mdnie->props.def_wrgb[BLUE], mdnie->props.def_wrgb[BLUE]);
return 0;
}
EXPORT_SYMBOL(mdnie_set_def_wrgb);
int mdnie_set_cur_wrgb(struct mdnie_info *mdnie,
unsigned char r, unsigned char g, unsigned char b)
{
if (!mdnie)
return -EINVAL;
mdnie->props.cur_wrgb[RED] = r;
mdnie->props.cur_wrgb[GREEN] = g;
mdnie->props.cur_wrgb[BLUE] = b;
panel_dbg("cur_wrgb: %d(%02X) %d(%02X) %d(%02X)\n",
mdnie->props.cur_wrgb[RED], mdnie->props.cur_wrgb[RED],
mdnie->props.cur_wrgb[GREEN], mdnie->props.cur_wrgb[GREEN],
mdnie->props.cur_wrgb[BLUE], mdnie->props.cur_wrgb[BLUE]);
return 0;
}
EXPORT_SYMBOL(mdnie_set_cur_wrgb);
int mdnie_cur_wrgb_to_byte_array(struct mdnie_info *mdnie,
unsigned char *dst, unsigned int stride)
{
if (!mdnie || !dst || !stride)
return -EINVAL;
copy_to_sliced_byte_array(dst,
mdnie->props.cur_wrgb, 0, MAX_COLOR * stride, stride);
return 0;
}
EXPORT_SYMBOL(mdnie_cur_wrgb_to_byte_array);
int mdnie_update_wrgb(struct mdnie_info *mdnie,
unsigned char r, unsigned char g, unsigned char b)
{
unsigned char src[MAX_COLOR] = { r, g, b };
unsigned char dst[MAX_COLOR] = { 0, };
int i, value;
if (!mdnie)
return -EINVAL;
if (mdnie->props.scr_white_mode < 0 ||
mdnie->props.scr_white_mode >= MAX_SCR_WHITE_MODE) {
panel_warn("out of range %d\n",
mdnie->props.scr_white_mode);
return -EINVAL;
}
if (mdnie->props.scr_white_mode == SCR_WHITE_MODE_COLOR_COORDINATE) {
mdnie_set_def_wrgb(mdnie, r, g, b);
for_each_color(i) {
value = (int)mdnie->props.def_wrgb[i] +
(int)((mdnie->props.mode == AUTO) ?
mdnie->props.def_wrgb_ofs[i] : 0);
dst[i] = min(max(value, 0), 255);
}
mdnie_set_cur_wrgb(mdnie, dst[RED], dst[GREEN], dst[BLUE]);
} else if (mdnie->props.scr_white_mode == SCR_WHITE_MODE_ADJUST_LDU) {
for_each_color(i) {
value = (int)src[i] + (int)(((mdnie->props.mode == AUTO) &&
(mdnie->props.scenario != EBOOK_MODE)) ?
mdnie->props.def_wrgb_ofs[i] : 0);
dst[i] = min(max(value, 0), 255);
}
mdnie_set_cur_wrgb(mdnie, dst[RED], dst[GREEN], dst[BLUE]);
} else if (mdnie->props.scr_white_mode == SCR_WHITE_MODE_SENSOR_RGB) {
mdnie_set_cur_wrgb(mdnie, r, g, b);
} else {
panel_warn("wrgb is not updated in scr_white_mode(%d)\n",
mdnie->props.scr_white_mode);
}
return 0;
}
EXPORT_SYMBOL(mdnie_update_wrgb);
int panel_mdnie_update(struct panel_device *panel)
{
int ret;
struct mdnie_info *mdnie = &panel->mdnie;
mutex_lock(&mdnie->lock);
if (!IS_MDNIE_ENABLED(mdnie)) {
panel_info("mdnie is off state\n");
mutex_unlock(&mdnie->lock);
return -EINVAL;
}
if (mdnie_coordinate_changed(mdnie)) {
mdnie_init_coordinate_tune(mdnie);
scr_white_maptbls_init(mdnie);
}
mdnie_update_scr_white_mode(mdnie);
ret = panel_set_mdnie(panel);
if (ret < 0 && ret != -EAGAIN) {
panel_err("failed to set mdnie %d\n", ret);
mutex_unlock(&mdnie->lock);
return ret;
}
mutex_unlock(&mdnie->lock);
#ifdef CONFIG_EXYNOS_DECON_LCD_COPR
copr_update_start(&panel->copr, 3);
#endif
return 0;
}
static int mdnie_update(struct mdnie_info *mdnie)
{
int ret;
struct panel_device *panel =
container_of(mdnie, struct panel_device, mdnie);
panel_wake_lock(panel, WAKE_TIMEOUT_MSEC);
ret = panel_mdnie_update(panel);
panel_wake_unlock(panel);
return ret;
}
#ifdef MDNIE_SELF_TEST
static void mdnie_coordinate_tune_test(struct mdnie_info *mdnie)
{
int i, x, y;
u8 tune_rgb[MAX_WCRD_TYPE][MAX_COLOR];
int input[27][2] = {
{ 2936, 3144 }, { 2987, 3203 }, { 3032, 3265 }, { 2954, 3108 }, { 2991, 3158 }, { 3041, 3210 }, { 2967, 3058 }, { 3004, 3091 },
{ 3063, 3156 }, { 2985, 3206 }, { 3032, 3238 }, { 2955, 3094 }, { 2997, 3151 }, { 3045, 3191 }, { 2971, 3047 }, { 3020, 3100 },
{ 3066, 3144 }, { 2983, 3131 }, { 2987, 3170 }, { 2975, 3159 }, { 3021, 3112 }, { 2982, 3122 }, { 2987, 3130 }, { 2930, 3260 },
{ 2930, 3050 }, { 3060, 3050 }, { 3060, 3260 },
};
u8 output[27][MAX_COLOR] = {
{ 0xFF, 0xFA, 0xF9 }, { 0xFE, 0xFA, 0xFE }, { 0xF8, 0xF6, 0xFF }, { 0xFF, 0xFD, 0xFB },
{ 0xFF, 0xFE, 0xFF }, { 0xF9, 0xFA, 0xFF }, { 0xFC, 0xFF, 0xF9 }, { 0xFB, 0xFF, 0xFB },
{ 0xF9, 0xFF, 0xFF }, { 0xFE, 0xFA, 0xFE }, { 0xF9, 0xF8, 0xFF }, { 0xFE, 0xFE, 0xFA },
{ 0xFE, 0xFF, 0xFF }, { 0xF8, 0xFC, 0xFF }, { 0xFA, 0xFF, 0xF8 }, { 0xF9, 0xFF, 0xFC },
{ 0xF8, 0xFF, 0xFF }, { 0xFE, 0xFF, 0xFD }, { 0xFF, 0xFD, 0xFF }, { 0xFF, 0xFD, 0xFD },
{ 0xF9, 0xFF, 0xFC }, { 0xFE, 0xFF, 0xFD }, { 0xFE, 0xFF, 0xFD }, { 0xFF, 0xFF, 0xFF },
{ 0xFF, 0xFF, 0xFF }, { 0xFF, 0xFF, 0xFF }, { 0xFF, 0xFF, 0xFF },
};
for (x = MIN_WCRD_X; x <= MAX_WCRD_X; x += 10)
for (y = MIN_WCRD_Y; y <= MAX_WCRD_Y; y += 10)
mdnie_coordinate_tune_rgb(mdnie, x, y, tune_rgb);
for (i = 0; i < 27; i++) {
g_coord_x = input[i][0];
g_coord_y = input[i][1];
mdnie_update(mdnie);
panel_info("compare %02X %02X %02X : %02X %02X %02X (%s)\n",
output[i][0], output[i][1], output[i][2],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][0],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][1],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][2],
output[i][0] == mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][0] &&
output[i][1] == mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][1] &&
output[i][2] == mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][2] ? "SUCCESS" : "FAILED");
}
}
#endif
static ssize_t mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.mode);
}
static ssize_t mode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int value = 0;
int ret;
ret = kstrtouint(buf, 0, &value);
if (ret < 0)
return ret;
if (value >= MODE_MAX) {
panel_err("invalid value=%d\n", value);
return -EINVAL;
}
panel_info("value=%d\n", value);
mutex_lock(&mdnie->lock);
mdnie->props.mode = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t scenario_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.scenario);
}
static ssize_t scenario_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int value;
int ret;
ret = kstrtouint(buf, 0, &value);
if (ret < 0)
return ret;
if (!SCENARIO_IS_VALID(value)) {
panel_err("invalid scenario %d\n", value);
return -EINVAL;
}
panel_info("value=%d\n", value);
mutex_lock(&mdnie->lock);
mdnie->props.scenario = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t accessibility_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.accessibility);
}
static ssize_t accessibility_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int s[12] = {0, };
int i, value = 0, ret;
ret = sscanf(buf, "%d %x %x %x %x %x %x %x %x %x %x %x %x",
&value, &s[0], &s[1], &s[2], &s[3],
&s[4], &s[5], &s[6], &s[7], &s[8], &s[9], &s[10], &s[11]);
if (ret <= 0 || ret > ARRAY_SIZE(s) + 1 ||
((ret - 1) > (MAX_MDNIE_SCR_LEN / 2))) {
panel_err("invalid size %d\n", ret);
return -EINVAL;
}
if (value < 0 || value >= ACCESSIBILITY_MAX) {
panel_err("unknown accessibility %d\n", value);
return -EINVAL;
}
panel_info("value: %d, cnt: %d\n", value, ret);
mutex_lock(&mdnie->lock);
mdnie->props.accessibility = value;
if (ret > 1 && (value == COLOR_BLIND || value == COLOR_BLIND_HBM)) {
for (i = 0; i < ret - 1; i++) {
mdnie->props.scr[i * 2 + 0] = GET_LSB_8BIT(s[i]);
mdnie->props.scr[i * 2 + 1] = GET_MSB_8BIT(s[i]);
}
mdnie->props.sz_scr = (ret - 1) * 2;
mdnie_maptbl_init(mdnie,
MAPTBL_IDX_ACCESSIBILITY(mdnie->props.accessibility));
}
mutex_unlock(&mdnie->lock);
panel_info("%s\n", buf);
mdnie_update(mdnie);
return count;
}
static ssize_t bypass_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.bypass);
}
static ssize_t bypass_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int value;
int ret;
ret = kstrtouint(buf, 0, &value);
if (ret < 0)
return ret;
if (value >= BYPASS_MAX) {
panel_err("invalid value=%d\n", value);
return -EINVAL;
}
panel_info("value=%d\n", value);
value = (value) ? BYPASS_ON : BYPASS_OFF;
mutex_lock(&mdnie->lock);
mdnie->props.bypass = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t lux_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.hbm);
}
static ssize_t lux_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int ret, value;
int hbm_ce_lux = (mdnie->props.hbm_ce_lux > 0) ?
mdnie->props.hbm_ce_lux : 40000;
ret = kstrtoint(buf, 0, &value);
if (ret < 0)
return ret;
mutex_lock(&mdnie->lock);
mdnie->props.hbm = (value < hbm_ce_lux) ? 0 : 1;
mutex_unlock(&mdnie->lock);
panel_info("hbm:%d (lux:%d hbm_ce_lux:%d)\n",
mdnie->props.hbm, value, hbm_ce_lux);
mdnie_update(mdnie);
return count;
}
/* Temporary solution: Do not use this sysfs as official purpose */
static ssize_t mdnie_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int maptbl_index = mdnie_get_maptbl_index(mdnie);
int mdnie_mode = mdnie_current_state(mdnie);
unsigned int i, len = 0;
if (!IS_MDNIE_ENABLED(mdnie)) {
panel_err("mdnie state is off\n");
return -EINVAL;
}
len += snprintf(buf + len, PAGE_SIZE - len,
"mdnie %s-mode, maptbl %s(%d)\n",
mdnie_mode_name[mdnie_mode], (maptbl_index < 0) ?
"invalid" : mdnie_maptbl_name[maptbl_index], maptbl_index);
len += snprintf(buf + len, PAGE_SIZE - len,
"accessibility %s(%d), hdr %d, hmd %d, hbm %d\n",
accessibility_name[mdnie->props.accessibility],
mdnie->props.accessibility, mdnie->props.hdr,
mdnie->props.hmd, mdnie->props.hbm);
len += snprintf(buf + len, PAGE_SIZE - len,
"scenario %s(%d), mode %s(%d)\n",
scenario_name[mdnie->props.scenario], mdnie->props.scenario,
scenario_mode_name[mdnie->props.mode], mdnie->props.mode);
len += snprintf(buf + len, PAGE_SIZE - len, "scr_white_mode %s\n",
scr_white_mode_name[mdnie->props.scr_white_mode]);
len += snprintf(buf + len, PAGE_SIZE - len,
"mdnie_ldu %d, coord x %d, y %d area Q%d\n",
mdnie->props.ldu, mdnie->props.wcrd_x, mdnie->props.wcrd_y,
mdnie_coordinate_area(mdnie, mdnie->props.wcrd_x, mdnie->props.wcrd_y) + 1);
len += snprintf(buf + len, PAGE_SIZE - len,
"coord_wrgb[adpt] r:%d(%02X) g:%d(%02X) b:%d(%02X)\n",
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][0],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][0],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][1],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][1],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][2],
mdnie->props.coord_wrgb[WCRD_TYPE_ADAPTIVE][2]);
len += snprintf(buf + len, PAGE_SIZE - len,
"coord_wrgb[d65] r:%d(%02X) g:%d(%02X) b:%d(%02X)\n",
mdnie->props.coord_wrgb[WCRD_TYPE_D65][0],
mdnie->props.coord_wrgb[WCRD_TYPE_D65][0],
mdnie->props.coord_wrgb[WCRD_TYPE_D65][1],
mdnie->props.coord_wrgb[WCRD_TYPE_D65][1],
mdnie->props.coord_wrgb[WCRD_TYPE_D65][2],
mdnie->props.coord_wrgb[WCRD_TYPE_D65][2]);
len += snprintf(buf + len, PAGE_SIZE - len, "cur_wrgb r:%d(%02X) g:%d(%02X) b:%d(%02X)\n",
mdnie->props.cur_wrgb[0], mdnie->props.cur_wrgb[0],
mdnie->props.cur_wrgb[1], mdnie->props.cur_wrgb[1],
mdnie->props.cur_wrgb[2], mdnie->props.cur_wrgb[2]);
len += snprintf(buf + len, PAGE_SIZE - len,
"ssr_wrgb r:%d(%02X) g:%d(%02X) b:%d(%02X)\n",
mdnie->props.ssr_wrgb[0], mdnie->props.ssr_wrgb[0],
mdnie->props.ssr_wrgb[1], mdnie->props.ssr_wrgb[1],
mdnie->props.ssr_wrgb[2], mdnie->props.ssr_wrgb[2]);
len += snprintf(buf + len, PAGE_SIZE - len,
"def_wrgb r:%d(%02X) g:%d(%02X) b:%d(%02X) offset r:%d g:%d b:%d\n",
mdnie->props.def_wrgb[0], mdnie->props.def_wrgb[0],
mdnie->props.def_wrgb[1], mdnie->props.def_wrgb[1],
mdnie->props.def_wrgb[2], mdnie->props.def_wrgb[2],
mdnie->props.def_wrgb_ofs[0], mdnie->props.def_wrgb_ofs[1],
mdnie->props.def_wrgb_ofs[2]);
len += snprintf(buf + len, PAGE_SIZE - len, "scr : ");
if (mdnie->props.sz_scr) {
for (i = 0; i < mdnie->props.sz_scr; i++)
len += snprintf(buf + len, PAGE_SIZE - len,
"%02x ", mdnie->props.scr[i]);
} else {
len += snprintf(buf + len, PAGE_SIZE - len, "none");
}
len += snprintf(buf + len, PAGE_SIZE - len, "\n");
len += snprintf(buf + len, PAGE_SIZE - len,
"night_mode %s, level %d\n",
mdnie->props.night ? "on" : "off",
mdnie->props.night_level);
#ifdef MDNIE_SELF_TEST
mdnie_coordinate_tune_test(mdnie);
#endif
return len;
}
static ssize_t sensorRGB_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d %d %d\n", mdnie->props.cur_wrgb[0],
mdnie->props.cur_wrgb[1], mdnie->props.cur_wrgb[2]);
}
static ssize_t sensorRGB_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int white_red, white_green, white_blue;
int mdnie_mode = mdnie_current_state(mdnie), ret;
ret = sscanf(buf, "%u %u %u",
&white_red, &white_green, &white_blue);
if (ret != 3)
return -EINVAL;
panel_info("white_r %u, white_g %u, white_b %u\n",
white_red, white_green, white_blue);
if (mdnie_mode == MDNIE_SCENARIO_MODE &&
mdnie->props.mode == AUTO &&
(mdnie->props.scenario == BROWSER_MODE ||
mdnie->props.scenario == EBOOK_MODE)) {
mutex_lock(&mdnie->lock);
mdnie->props.ssr_wrgb[0] = white_red;
mdnie->props.ssr_wrgb[1] = white_green;
mdnie->props.ssr_wrgb[2] = white_blue;
mdnie->props.update_sensorRGB = true;
scr_white_maptbl_init(mdnie, MDNIE_SENSOR_RGB_MAPTBL);
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
}
return count;
}
static ssize_t whiteRGB_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d %d %d\n", mdnie->props.def_wrgb_ofs[0],
mdnie->props.def_wrgb_ofs[1], mdnie->props.def_wrgb_ofs[2]);
}
static ssize_t whiteRGB_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int wr_offset, wg_offset, wb_offset;
int ret;
ret = sscanf(buf, "%d %d %d",
&wr_offset, &wg_offset, &wb_offset);
if (ret != 3)
return -EINVAL;
if (!IS_VALID_WRGB_OFS(wr_offset) ||
!IS_VALID_WRGB_OFS(wg_offset) ||
!IS_VALID_WRGB_OFS(wb_offset)) {
panel_err("invalid offset %d %d %d\n",
wr_offset, wg_offset, wb_offset);
return -EINVAL;
}
panel_info("wr_offset %d, wg_offset %d, wb_offset %d\n",
wr_offset, wg_offset, wb_offset);
mutex_lock(&mdnie->lock);
mdnie->props.def_wrgb_ofs[0] = wr_offset;
mdnie->props.def_wrgb_ofs[1] = wg_offset;
mdnie->props.def_wrgb_ofs[2] = wb_offset;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t night_mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d %d\n",
mdnie->props.night, mdnie->props.night_level);
}
static ssize_t night_mode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int enable, level, ret;
ret = sscanf(buf, "%d %d", &enable, &level);
if (ret != 2)
return -EINVAL;
if (level < 0 || level >= mdnie->props.num_night_level)
return -EINVAL;
panel_info("night_mode %s level %d\n",
enable ? "on" : "off", level);
mutex_lock(&mdnie->lock);
mdnie->props.night = !!enable;
mdnie->props.night_level = level;
if (enable) {
/* MDNIE_NIGHT_MAPTBL update using MDNIE_ETC_NIGHT_MAPTBL */
mdnie_maptbl_init(mdnie, MDNIE_NIGHT_MAPTBL);
}
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t color_lens_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d %d %d\n",
mdnie->props.color_lens,
mdnie->props.color_lens_color,
mdnie->props.color_lens_level);
}
static ssize_t color_lens_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int enable, level, color, ret;
ret = sscanf(buf, "%d %d %d", &enable, &color, &level);
if (ret != 3)
return -EINVAL;
if (color < 0 || color >= COLOR_LENS_COLOR_MAX)
return -EINVAL;
if (level < 0 || level >= COLOR_LENS_LEVEL_MAX)
return -EINVAL;
panel_info("color_lens_mode %s color %d level %d\n",
enable ? "on" : "off", color, level);
mutex_lock(&mdnie->lock);
mdnie->props.color_lens = !!enable;
mdnie->props.color_lens_color = color;
mdnie->props.color_lens_level = level;
if (enable) {
/* MDNIE_COLOR_LENS_MAPTBL update using MDNIE_ETC_COLOR_LENS_MAPTBL */
mdnie_maptbl_init(mdnie, MDNIE_COLOR_LENS_MAPTBL);
}
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t hdr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.hdr);
}
static ssize_t hdr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int value;
int ret;
ret = kstrtouint(buf, 0, &value);
if (ret < 0)
return ret;
if (value >= HDR_MAX) {
panel_err("invalid value=%d\n", value);
return -EINVAL;
}
panel_info("value=%d\n", value);
mutex_lock(&mdnie->lock);
mdnie->props.hdr = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t light_notification_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", mdnie->props.light_notification);
}
static ssize_t light_notification_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int value;
int ret;
ret = kstrtouint(buf, 0, &value);
if (ret < 0)
return ret;
if (value >= LIGHT_NOTIFICATION_MAX)
return -EINVAL;
panel_info("value=%d\n", value);
mutex_lock(&mdnie->lock);
mdnie->props.light_notification = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
static ssize_t mdnie_ldu_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d %d %d\n", mdnie->props.cur_wrgb[0],
mdnie->props.cur_wrgb[1], mdnie->props.cur_wrgb[2]);
}
static ssize_t mdnie_ldu_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int value, ret;
ret = kstrtoint(buf, 10, &value);
if (ret < 0)
return ret;
if (value < 0 || value >= MAX_LDU_MODE) {
panel_err("out of range %d\n",
value);
return -EINVAL;
}
panel_info("value=%d\n", value);
mutex_lock(&mdnie->lock);
mdnie->props.ldu = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
#ifdef CONFIG_SUPPORT_HMD
static ssize_t hmt_color_temperature_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "hmd_mode: %d\n", mdnie->props.hmd);
}
static ssize_t hmt_color_temperature_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
unsigned int value;
int ret;
ret = kstrtouint(buf, 0, &value);
if (ret < 0)
return ret;
if (value >= HMD_MDNIE_MAX)
return -EINVAL;
if (value == mdnie->props.hmd)
return count;
panel_info("value=%d\n", value);
mutex_lock(&mdnie->lock);
mdnie->props.hmd = value;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
return count;
}
#endif
#ifdef CONFIG_SUPPORT_AFC
static ssize_t afc_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int len = 0;
size_t i;
len += snprintf(buf + len, PAGE_SIZE - len,
"%d", mdnie->props.afc_on);
for (i = 0; i < ARRAY_SIZE(mdnie->props.afc_roi); i++)
len += snprintf(buf + len, PAGE_SIZE - len,
" %d", mdnie->props.afc_roi[i]);
len += snprintf(buf + len, PAGE_SIZE - len, "\n");
return len;
}
static ssize_t afc_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct mdnie_info *mdnie = dev_get_drvdata(dev);
int s[12] = {0, };
int value = 0, ret;
size_t i;
ret = sscanf(buf, "%i %i %i %i %i %i %i %i %i %i %i %i %i",
&value, &s[0], &s[1], &s[2], &s[3],
&s[4], &s[5], &s[6], &s[7], &s[8], &s[9], &s[10], &s[11]);
if ((ret != 1 && ret != ARRAY_SIZE(s) + 1) ||
ARRAY_SIZE(s) != MAX_AFC_ROI_LEN) {
panel_err("invalid size %d\n", ret);
return -EINVAL;
}
panel_info("value=%d, cnt=%d\n", value, ret);
mutex_lock(&mdnie->lock);
mdnie->props.afc_on = !!value;
for (i = 0; i < ARRAY_SIZE(mdnie->props.afc_roi); i++)
mdnie->props.afc_roi[i] = s[i] & 0xFF;
mutex_unlock(&mdnie->lock);
panel_info("%s\n", buf);
mdnie_update(mdnie);
return count;
}
#endif
struct device_attribute mdnie_dev_attrs[] = {
__PANEL_ATTR_RW(mode, 0664),
__PANEL_ATTR_RW(scenario, 0664),
__PANEL_ATTR_RW(accessibility, 0664),
__PANEL_ATTR_RW(bypass, 0664),
__PANEL_ATTR_RW(lux, 0000),
__PANEL_ATTR_RO(mdnie, 0444),
__PANEL_ATTR_RW(sensorRGB, 0664),
__PANEL_ATTR_RW(whiteRGB, 0664),
__PANEL_ATTR_RW(night_mode, 0664),
__PANEL_ATTR_RW(color_lens, 0664),
__PANEL_ATTR_RW(hdr, 0664),
__PANEL_ATTR_RW(light_notification, 0664),
__PANEL_ATTR_RW(mdnie_ldu, 0664),
#ifdef CONFIG_SUPPORT_HMD
__PANEL_ATTR_RW(hmt_color_temperature, 0664),
#endif
#ifdef CONFIG_SUPPORT_AFC
__PANEL_ATTR_RW(afc, 0664),
#endif
};
int mdnie_enable(struct mdnie_info *mdnie)
{
struct panel_device *panel =
container_of(mdnie, struct panel_device, mdnie);
int ret;
if (IS_MDNIE_ENABLED(mdnie)) {
panel_info("mdnie already enabled\n");
panel_mdnie_update(panel);
return 0;
}
mutex_lock(&mdnie->lock);
mdnie->props.enable = 1;
mdnie->props.light_notification = LIGHT_NOTIFICATION_OFF;
if (IS_HBM_MODE(mdnie))
mdnie->props.trans_mode = TRANS_ON;
mutex_unlock(&mdnie->lock);
ret = panel_mdnie_update(panel);
if (ret < 0)
mdnie->props.enable = 0;
mutex_lock(&mdnie->lock);
mdnie->props.trans_mode = TRANS_ON;
mutex_unlock(&mdnie->lock);
panel_info("done %u\n", mdnie->props.enable);
return 0;
}
int mdnie_disable(struct mdnie_info *mdnie)
{
if (!IS_MDNIE_ENABLED(mdnie)) {
panel_info("mdnie already disabled\n");
return 0;
}
mutex_lock(&mdnie->lock);
mdnie->props.enable = 0;
mdnie->props.trans_mode = TRANS_OFF;
mdnie->props.update_sensorRGB = false;
mutex_unlock(&mdnie->lock);
panel_info("done\n");
return 0;
}
static int fb_notifier_callback(struct notifier_block *self,
unsigned long event, void *data)
{
struct mdnie_info *mdnie;
struct fb_event *evdata = data;
int fb_blank;
switch (event) {
case FB_EVENT_BLANK:
break;
default:
return 0;
}
mdnie = container_of(self, struct mdnie_info, fb_notif);
fb_blank = *(int *)evdata->data;
panel_dbg("%d\n", fb_blank);
if (evdata->info->node != 0)
return 0;
if (fb_blank == FB_BLANK_UNBLANK) {
mutex_lock(&mdnie->lock);
mdnie->props.light_notification = LIGHT_NOTIFICATION_OFF;
if (IS_HBM_MODE(mdnie))
mdnie->props.trans_mode = TRANS_ON;
mutex_unlock(&mdnie->lock);
mdnie_update(mdnie);
}
return 0;
}
static int mdnie_register_fb(struct mdnie_info *mdnie)
{
memset(&mdnie->fb_notif, 0, sizeof(mdnie->fb_notif));
mdnie->fb_notif.notifier_call = fb_notifier_callback;
fb_register_client(&mdnie->fb_notif);
return 0;
}
static int mdnie_unregister_fb(struct mdnie_info *mdnie)
{
fb_unregister_client(&mdnie->fb_notif);
mdnie->fb_notif.notifier_call = NULL;
return 0;
}
#ifdef CONFIG_DISPLAY_USE_INFO
static int dpui_notifier_callback(struct notifier_block *self,
unsigned long event, void *data)
{
struct mdnie_info *mdnie;
struct panel_device *panel;
struct panel_info *panel_data;
char tbuf[MAX_DPUI_VAL_LEN];
u8 coordinate[PANEL_COORD_LEN] = { 0, };
int size;
mdnie = container_of(self, struct mdnie_info, dpui_notif);
panel = container_of(mdnie, struct panel_device, mdnie);
panel_data = &panel->panel_data;
mutex_lock(&mdnie->lock);
resource_copy_by_name(panel_data, coordinate, "coordinate");
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d",
(coordinate[0] << 8) | coordinate[1]);
set_dpui_field(DPUI_KEY_WCRD_X, tbuf, size);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d",
(coordinate[2] << 8) | coordinate[3]);
set_dpui_field(DPUI_KEY_WCRD_Y, tbuf, size);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d",
mdnie->props.def_wrgb_ofs[0]);
set_dpui_field(DPUI_KEY_WOFS_R, tbuf, size);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d",
mdnie->props.def_wrgb_ofs[1]);
set_dpui_field(DPUI_KEY_WOFS_G, tbuf, size);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d",
mdnie->props.def_wrgb_ofs[2]);
set_dpui_field(DPUI_KEY_WOFS_B, tbuf, size);
#if 0 /* disable for GKI build */
mdnie_get_efs(MDNIE_WOFS_ORG_PATH, def_wrgb_ofs_org);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d", def_wrgb_ofs_org[0]);
set_dpui_field(DPUI_KEY_WOFS_R_ORG, tbuf, size);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d", def_wrgb_ofs_org[1]);
set_dpui_field(DPUI_KEY_WOFS_G_ORG, tbuf, size);
size = snprintf(tbuf, MAX_DPUI_VAL_LEN, "%d", def_wrgb_ofs_org[2]);
set_dpui_field(DPUI_KEY_WOFS_B_ORG, tbuf, size);
#endif
mutex_unlock(&mdnie->lock);
return 0;
}
static int mdnie_register_dpui(struct mdnie_info *mdnie)
{
memset(&mdnie->dpui_notif, 0, sizeof(mdnie->dpui_notif));
mdnie->dpui_notif.notifier_call = dpui_notifier_callback;
return dpui_logging_register(&mdnie->dpui_notif, DPUI_TYPE_PANEL);
}
static int mdnie_unregister_dpui(struct mdnie_info *mdnie)
{
dpui_logging_unregister(&mdnie->dpui_notif);
mdnie->dpui_notif.notifier_call = NULL;
return 0;
}
#endif /* CONFIG_DISPLAY_USE_INFO */
__visible_for_testing int mdnie_init_property(struct mdnie_info *mdnie, struct mdnie_tune *mdnie_tune)
{
if (!mdnie || !mdnie_tune)
return -EINVAL;
mdnie->props.enable = 0;
mdnie->props.scenario = UI_MODE;
mdnie->props.mode = AUTO;
mdnie->props.tuning = 0;
mdnie->props.bypass = BYPASS_OFF;
mdnie->props.hdr = HDR_OFF;
mdnie->props.light_notification = LIGHT_NOTIFICATION_OFF;
mdnie->props.hmd = HMD_MDNIE_OFF;
mdnie->props.night = NIGHT_MODE_OFF;
mdnie->props.night_level = NIGHT_LEVEL_6500K;
mdnie->props.color_lens = COLOR_LENS_OFF;
mdnie->props.color_lens_color = COLOR_LENS_COLOR_BLUE;
mdnie->props.color_lens_level = COLOR_LENS_LEVEL_20P;
mdnie->props.accessibility = ACCESSIBILITY_OFF;
mdnie->props.ldu = LDU_MODE_OFF;
mdnie->props.scr_white_mode = SCR_WHITE_MODE_NONE;
mdnie->props.trans_mode = TRANS_ON;
mdnie->props.update_sensorRGB = false;
mdnie->props.sz_scr = 0;
/* initialization by mdnie_tune */
mdnie->props.num_ldu_mode = mdnie_tune->num_ldu_mode;
mdnie->props.num_night_level = mdnie_tune->num_night_level;
mdnie->props.num_color_lens_color = mdnie_tune->num_color_lens_color;
mdnie->props.num_color_lens_level = mdnie_tune->num_color_lens_level;
memcpy(mdnie->props.line, mdnie_tune->line, sizeof(mdnie->props.line));
memcpy(mdnie->props.coef, mdnie_tune->coef, sizeof(mdnie->props.coef));
memcpy(mdnie->props.vtx, mdnie_tune->vtx, sizeof(mdnie->props.vtx));
mdnie->props.cal_x_center = mdnie_tune->cal_x_center;
mdnie->props.cal_y_center = mdnie_tune->cal_y_center;
mdnie->props.cal_boundary_center = mdnie_tune->cal_boundary_center;
mdnie->props.hbm_ce_lux = mdnie_tune->hbm_ce_lux;
return 0;
}
__visible_for_testing int mdnie_init_tables(struct mdnie_info *mdnie, struct mdnie_tune *mdnie_tune)
{
if (!mdnie || !mdnie_tune)
return -EINVAL;
if (mdnie_tune->nr_maptbl % MAX_MDNIE_MAPTBL) {
panel_err("invalid size of maptbl %d\n", mdnie_tune->nr_maptbl);
return -EINVAL;
}
mdnie->seqtbl = mdnie_tune->seqtbl;
mdnie->nr_seqtbl = mdnie_tune->nr_seqtbl;
mdnie->etc_maptbl = mdnie_tune->etc_maptbl;
mdnie->nr_etc_maptbl = mdnie_tune->nr_etc_maptbl;
mdnie->maptbl = mdnie_tune->maptbl;
mdnie->nr_maptbl = mdnie_tune->nr_maptbl;
mdnie->scr_white_maptbl = mdnie_tune->scr_white_maptbl;
mdnie->nr_scr_white_maptbl = mdnie_tune->nr_scr_white_maptbl;
#ifdef CONFIG_SUPPORT_AFC
mdnie->afc_maptbl = mdnie_tune->afc_maptbl;
mdnie->nr_afc_maptbl = mdnie_tune->nr_afc_maptbl;
#endif
mdnie->nr_reg = mdnie->nr_maptbl / MAX_MDNIE_MAPTBL;
return 0;
}
__visible_for_testing int mdnie_init_maptbls(struct mdnie_info *mdnie)
{
int i;
if (!mdnie)
return -EINVAL;
for (i = 0; i < mdnie->nr_etc_maptbl; i++) {
mdnie->etc_maptbl[i].pdata = mdnie;
maptbl_init(&mdnie->etc_maptbl[i]);
}
for (i = 0; i < mdnie->nr_maptbl; i++) {
mdnie->maptbl[i].pdata = mdnie;
maptbl_init(&mdnie->maptbl[i]);
}
for (i = 0; i < mdnie->nr_scr_white_maptbl; i++) {
mdnie->scr_white_maptbl[i].pdata = mdnie;
maptbl_init(&mdnie->scr_white_maptbl[i]);
}
#ifdef CONFIG_SUPPORT_AFC
for (i = 0; i < mdnie->nr_afc_maptbl; i++) {
mdnie->afc_maptbl[i].pdata = mdnie;
maptbl_init(&mdnie->afc_maptbl[i]);
}
#endif
return 0;
}
__visible_for_testing int mdnie_set_name(struct mdnie_info *mdnie, unsigned int id)
{
if (!mdnie)
return -EINVAL;
if (id == 0)
snprintf(mdnie->name, MAX_MDNIE_DEV_NAME_SIZE,
"%s", MDNIE_DEV_NAME);
else
snprintf(mdnie->name, MAX_MDNIE_DEV_NAME_SIZE,
"%s-%d", MDNIE_DEV_NAME, id);
return 0;
}
__visible_for_testing const char *mdnie_get_name(struct mdnie_info *mdnie)
{
return mdnie ? mdnie->name : NULL;
}
__visible_for_testing int mdnie_create_class(struct mdnie_info *mdnie)
{
if (!mdnie)
return -EINVAL;
mdnie->class = class_create(THIS_MODULE, mdnie_get_name(mdnie));
if (IS_ERR_OR_NULL(mdnie->class)) {
panel_err("failed to create mdnie class\n");
return -EINVAL;
}
return 0;
}
__visible_for_testing int mdnie_destroy_class(struct mdnie_info *mdnie)
{
if (!mdnie || !mdnie->class)
return -EINVAL;
class_destroy(mdnie->class);
mdnie->class = NULL;
return 0;
}
__visible_for_testing int mdnie_create_device(struct mdnie_info *mdnie)
{
if (!mdnie)
return -EINVAL;
if (!to_panel_device(mdnie)->lcd_dev) {
panel_err("lcd_device is null\n");
return -EINVAL;
}
mdnie->dev = device_create(mdnie->class,
to_panel_device(mdnie)->lcd_dev,
0, &mdnie, "%s", mdnie_get_name(mdnie));
if (IS_ERR_OR_NULL(mdnie->dev)) {
panel_err("failed to create mdnie device\n");
return -EINVAL;
}
dev_set_drvdata(mdnie->dev, mdnie);
return 0;
}
__visible_for_testing int mdnie_destroy_device(struct mdnie_info *mdnie)
{
if (!mdnie)
return -EINVAL;
if (!mdnie->dev) {
panel_err("mdnie device is null\n");
return -ENODEV;
}
device_unregister(mdnie->dev);
mdnie->dev = NULL;
return 0;
}
__visible_for_testing int mdnie_create_device_files(struct mdnie_info *mdnie)
{
int i, ret;
if (!mdnie || !mdnie->dev)
return -EINVAL;
for (i = 0; i < ARRAY_SIZE(mdnie_dev_attrs); i++) {
ret = device_create_file(mdnie->dev, &mdnie_dev_attrs[i]);
if (ret < 0) {
panel_err("failed to add %s sysfs entries, %d\n",
mdnie_dev_attrs[i].attr.name, ret);
return ret;
}
}
return 0;
}
__visible_for_testing int mdnie_remove_device_files(struct mdnie_info *mdnie)
{
int i;
if (!mdnie || !mdnie->dev)
return -EINVAL;
for (i = 0; i < ARRAY_SIZE(mdnie_dev_attrs); i++)
device_remove_file(mdnie->dev, &mdnie_dev_attrs[i]);
return 0;
}
__visible_for_testing int mdnie_create_class_and_device(struct mdnie_info *mdnie)
{
int ret;
if (!mdnie)
return -EINVAL;
ret = mdnie_create_class(mdnie);
if (ret < 0)
return ret;
ret = mdnie_create_device(mdnie);
if (ret < 0)
goto error1;
ret = mdnie_create_device_files(mdnie);
if (ret < 0)
goto error2;
return 0;
error2:
mdnie_destroy_device(mdnie);
error1:
mdnie_destroy_class(mdnie);
return ret;
}
__visible_for_testing int mdnie_remove_class_and_device(struct mdnie_info *mdnie)
{
int ret;
ret = mdnie_remove_device_files(mdnie);
if (ret < 0)
return -EINVAL;
ret = mdnie_destroy_device(mdnie);
if (ret < 0)
return -EINVAL;
ret = mdnie_destroy_class(mdnie);
if (ret < 0)
return -EINVAL;
return 0;
}
int mdnie_init(struct mdnie_info *mdnie)
{
int ret;
if (!mdnie)
return -EINVAL;
mutex_init(&mdnie->lock);
ret = mdnie_set_name(mdnie,
to_panel_device(mdnie)->id);
if (ret < 0)
return -EINVAL;
ret = mdnie_create_class_and_device(mdnie);
if (ret < 0)
return -EINVAL;
panel_info("mdnie init success\n");
return 0;
}
int mdnie_exit(struct mdnie_info *mdnie)
{
if (!mdnie)
return -EINVAL;
mutex_lock(&mdnie->lock);
mdnie_remove_class_and_device(mdnie);
memset(mdnie->name, 0, sizeof(mdnie->name));
mutex_unlock(&mdnie->lock);
return 0;
}
int mdnie_probe(struct mdnie_info *mdnie, struct mdnie_tune *mdnie_tune)
{
int ret;
if (unlikely(!mdnie || !mdnie_tune)) {
panel_err("invalid argument\n");
return -ENODEV;
}
mutex_lock(&mdnie->lock);
ret = mdnie_init_property(mdnie, mdnie_tune);
if (ret < 0)
goto err;
ret = mdnie_init_tables(mdnie, mdnie_tune);
if (ret < 0)
goto err;
ret = mdnie_init_coordinate_tune(mdnie);
if (ret < 0)
goto err;
ret = mdnie_init_maptbls(mdnie);
if (ret < 0)
goto err;
ret = mdnie_register_fb(mdnie);
if (ret < 0)
goto err;
#ifdef CONFIG_DISPLAY_USE_INFO
ret = mdnie_register_dpui(mdnie);
if (ret < 0)
goto err;
#endif
mutex_unlock(&mdnie->lock);
ret = mdnie_enable(mdnie);
if (ret < 0) {
panel_err("failed to enable mdnie\n");
return ret;
}
panel_info("mdnie probe success\n");
return 0;
err:
mutex_unlock(&mdnie->lock);
panel_err("failed to probe mdnie\n");
return ret;
}
int mdnie_remove(struct mdnie_info *mdnie)
{
if (!mdnie)
return -EINVAL;
mdnie_disable(mdnie);
mutex_lock(&mdnie->lock);
#ifdef CONFIG_DISPLAY_USE_INFO
mdnie_unregister_dpui(mdnie);
#endif
mdnie_unregister_fb(mdnie);
mutex_unlock(&mdnie->lock);
return 0;
}
Reference in a new issue Copy permalink