kernel_samsung_a53x/drivers/gpu/drm/samsung/panel/panel.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (c) Samsung Electronics Co., Ltd.
 * Gwanghui Lee <gwanghui.lee@samsung.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 __PANEL_H__
#define __PANEL_H__

#include <linux/lcd.h>
#include <linux/backlight.h>
#include <linux/spi/spi.h>
#include <linux/sysfs.h>
#include "panel_kunit.h"
#include "maptbl.h"
#include "util.h"

#include "panel_bl.h"

#ifdef CONFIG_PANEL_AID_DIMMING
#include "dimming.h"
#include "panel_dimming.h"
#endif

#ifdef CONFIG_EXYNOS_DECON_MDNIE_LITE
#include "mdnie.h"
#endif

#ifdef CONFIG_EXYNOS_DECON_LCD_COPR
#include "copr.h"
#endif

#include "panel_vrr.h"

#include "panel_modes.h"
#ifdef CONFIG_PANEL_NOTIFY
#include <linux/panel_notify.h>
#endif

#ifdef CONFIG_EXTEND_LIVE_CLOCK
#include "./aod/aod_drv.h"
#endif

#include "panel_obj.h"

enum {
	MIPI_DSI_WR_UNKNOWN = 0,
	MIPI_DSI_WR_GEN_CMD,
	MIPI_DSI_WR_CMD_NO_WAKE,
	MIPI_DSI_WR_DSC_CMD,
	MIPI_DSI_WR_PPS_CMD,
	MIPI_DSI_WR_GRAM_CMD,
	MIPI_DSI_WR_SRAM_CMD,
	MIPI_DSI_WR_SR_FAST_CMD,
	MAX_MIPI_DSI_CMD_TYPE,
};

#define CONFIG_LCD_HBM_60_STEP
#define MIPI_DCS_WRITE_GRAM_START			(0x2C)
#define MIPI_DCS_WRITE_GRAM_CONTINUE		(0x3C)
#define MIPI_DCS_WRITE_SIDE_RAM_START		(0x4C)
#define MIPI_DCS_WRITE_SIDE_RAM_CONTINUE	(0x5C)
#define MIPI_DCS_WRITE_SPSRAM				(0x6C)

#ifdef CONFIG_MCD_PANEL_FACTORY
#define CONFIG_SUPPORT_PANEL_SWAP
#define CONFIG_SUPPORT_XTALK_MODE
#define CONFIG_SUPPORT_ISC_DEFECT
//#define CONFIG_SUPPORT_BRIGHTDOT_TEST
#define CONFIG_SELFMASK_FACTORY
#endif

#define CONFIG_SUPPORT_GRAYSPOT_TEST

#define CONFIG_SUPPORT_SPI_IF_SEL

#define to_panel_device(_m_)	container_of(_m_, struct panel_device, _m_)

/* DUMMY PANEL NAME */
#define __pn_name__	xx_xx
#define __PN_NAME__	XX_XX

#define PN_CONCAT(a, b)  _PN_CONCAT(a, b)
#define _PN_CONCAT(a, b) a ## _ ## b

#if IS_ENABLED(CONFIG_PANEL_ID_READ_REG_ADAEAF)
#define PANEL_ID_REG		(0xAD)
#elif IS_ENABLED(CONFIG_PANEL_ID_READ_REG_DADBDC) || \
	(!IS_ENABLED(CONFIG_PANEL_ID_READ_REG_04) && IS_ENABLED(CONFIG_EXYNOS_DECON_LCD_TFT_COMMON))
#define PANEL_ID_REG		(0xDA)
#else
#define PANEL_ID_REG		(0x04)
#endif
#define PANEL_ID_LEN		(3)
#define PANEL_OCTA_ID_LEN	(20)
#define PANEL_POC_CHKSUM_LEN	(5)
#define PANEL_POC_CTRL_LEN	(4)
#define PANEL_CODE_LEN		(5)
#define PANEL_COORD_LEN		(4)
#define PANEL_DATE_LEN		(7)
#define PANEL_RDDPM_LEN		(3)
#define PANEL_RDDSM_LEN		(3)
#define PANEL_VENDOR_LEN	(3)

#define NORMAL_TEMPERATURE			(25)
#define POWER_IS_ON(pwr)		(pwr <= FB_BLANK_NORMAL)
#define UNDER_MINUS_15(temperature)	(temperature <= -15)
#define UNDER_0(temperature)	(temperature <= 0)
#define CAPS_IS_ON(level)	(level >= 41)
#define PANEL_WAIT_VSYNC_TIMEOUT_MSEC	(110)

struct mdnie_info;

/*
 * [command types]
 * 1. delay
 * 2. external pin control
 * 3. packet write
 */

/* common cmdinfo */
struct cmdinfo {
	u32 type;
	char *name;
};

/* delay command */
struct delayinfo {
	u32 type;
	char *name;
	u32 usec;
	u32 nframe;
	ktime_t s_time;
};

/* variable delay command */
struct variable_delayinfo {
	u32 type;
	char *name;
	u32 usec;
	ktime_t mark_time;
	int (*func_delay)(struct panel_device *panel, ktime_t s_time, ktime_t mark_time);
	int (*func_mark)(struct panel_device *panel, ktime_t s_time, ktime_t *mark_time);
	struct cmdinfo mark;
};

struct timer_delay_begin_info {
	u32 type;
	char *name;
	struct delayinfo *delay;
};

#define DLYINFO(_name_) (_name_)

#define TIMER_DLYINFO_BEGIN(_name_) PN_CONCAT(begin, _name_)
#define TIMER_DLYINFO(_name_) (_name_)

#define VARIABLE_DLYINFO(_name_) (_name_)
#define VARIABLE_DLYINFO_MARK(_name_) ((_name_).mark)

#define DEFINE_PANEL_UDELAY_NO_SLEEP(_name_, _usec_)	\
struct delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_DELAY_NO_SLEEP,	\
	.usec = (_usec_),					\
}

#define DEFINE_PANEL_MDELAY_NO_SLEEP(_name_, _msec_)	\
struct delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_DELAY_NO_SLEEP,	\
	.usec = (_msec_) * 1000,			\
}

#define DEFINE_PANEL_UDELAY(_name_, _usec_)	\
struct delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_DELAY,				\
	.usec = (_usec_),					\
}

#define DEFINE_PANEL_MDELAY(_name_, _msec_)	\
struct delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_DELAY,				\
	.usec = (_msec_) * 1000,			\
}

#define DEFINE_PANEL_FRAME_DELAY(_name_, _nframe_)	\
struct delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_FRAME_DELAY,		\
	.nframe = (_nframe_),				\
}

#define DEFINE_PANEL_VSYNC_DELAY(_name_, _nvsync_)	\
struct delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_VSYNC_DELAY,		\
	.nframe = (_nvsync_),				\
}

#define DEFINE_PANEL_VARIABLE_DELAY_MARK(_name_, _func_delay_, _func_mark_)	\
struct variable_delayinfo DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_VARIABLE_DELAY,	\
	.usec = 0,							\
	.mark_time = (0ULL),				\
	.func_delay = (_func_delay_),		\
	.func_mark = (_func_mark_),			\
	.mark = {							\
		.type = CMD_TYPE_VARIABLE_DELAY_MARK,		\
		.name = #_name_,							\
	},									\
}

#define DEFINE_PANEL_VARIABLE_DELAY(_name_, _func_delay_)	\
	DEFINE_PANEL_VARIABLE_DELAY_MARK(_name_, _func_delay_, NULL)

#define DEFINE_PANEL_TIMER_BEGIN(_name_, _timer_delay_)		\
struct timer_delay_begin_info TIMER_DLYINFO_BEGIN(_name_) =	\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_TIMER_DELAY_BEGIN,	\
	.delay = (_timer_delay_),			\
}

#define DEFINE_PANEL_TIMER_UDELAY(_name_, _usec_)	\
struct delayinfo TIMER_DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_TIMER_DELAY,		\
	.usec = (_msec_),					\
	.s_time = (0ULL),					\
}

#define DEFINE_PANEL_TIMER_MDELAY(_name_, _msec_)	\
struct delayinfo TIMER_DLYINFO(_name_) =		\
{										\
	.name = #_name_,					\
	.type = CMD_TYPE_TIMER_DELAY,		\
	.usec = (_msec_) * 1000,			\
	.s_time = (0ULL),					\
}

/* external pin control command */
struct pininfo {
	u32 type;
	char *name;
	int pin;
	int onoff;
};

/* packet command */
enum {
	CMD_TYPE_NONE,
	CMD_TYPE_DELAY,
	CMD_TYPE_DELAY_NO_SLEEP,
	CMD_TYPE_FRAME_DELAY,
	CMD_TYPE_VSYNC_DELAY,
	CMD_TYPE_TIMER_DELAY_BEGIN,
	CMD_TYPE_TIMER_DELAY,
	CMD_TYPE_VARIABLE_DELAY,
	CMD_TYPE_VARIABLE_DELAY_MARK,
	CMD_TYPE_PINCTL,
	CMD_TYPE_TX_PKT_START,
	CMD_PKT_TYPE_NONE = CMD_TYPE_TX_PKT_START,
	DSI_PKT_TYPE_WR,
	DSI_PKT_TYPE_WR_NO_WAKE,
	DSI_PKT_TYPE_COMP,
	DSI_PKT_TYPE_PPS,
	/* Command to write ddi side ram */
	DSI_PKT_TYPE_WR_SR,
	/*write command to side ram with busy wait*/
	DSI_PKT_TYPE_SR_FAST,
	DSI_PKT_TYPE_WR_MEM,
	CMD_TYPE_TX_PKT_END = DSI_PKT_TYPE_WR_MEM,
	CMD_TYPE_RX_PKT_START,
	SPI_PKT_TYPE_RD = CMD_TYPE_RX_PKT_START,
	DSI_PKT_TYPE_RD_POC,
	DSI_PKT_TYPE_RD,
	CMD_TYPE_RX_PKT_END = DSI_PKT_TYPE_RD,
	SPI_PKT_TYPE_WR,
	SPI_PKT_TYPE_SETPARAM,
	CMD_TYPE_I2C_START,
	I2C_PKT_TYPE_WR = CMD_TYPE_I2C_START,
	I2C_PKT_TYPE_RD,
	CMD_TYPE_I2C_END = I2C_PKT_TYPE_RD,
	CMD_TYPE_RES,
	CMD_TYPE_SEQ,
	CMD_TYPE_KEY,
	CMD_TYPE_MAP,
	CMD_TYPE_DMP,
	CMD_TYPE_COND_IF,
	CMD_TYPE_COND_EL,
	CMD_TYPE_COND_FI,
	CMD_TYPE_PCTRL,
	CMD_TYPE_PROP,
	MAX_CMD_TYPE,
};

#define IS_CMD_TYPE_TX_MEM_PKT(_type_) \
	(DSI_PKT_TYPE_WR_SR <= (_type_) && (_type_) <= DSI_PKT_TYPE_WR_MEM)

#define IS_CMD_TYPE_TX_PKT(_type_) \
	((CMD_TYPE_TX_PKT_START <= (_type_) && (_type_) <= CMD_TYPE_TX_PKT_END) ||\
	 (_type_) == CMD_TYPE_KEY)

#define IS_CMD_TYPE_RX_PKT(_type_) \
	(CMD_TYPE_RX_PKT_START <= (_type_) && (_type_) <= CMD_TYPE_RX_PKT_END)

#define IS_CMD_TYPE_DELAY(_type_) \
	((_type_) >= CMD_TYPE_DELAY && (_type_) <= CMD_TYPE_FRAME_DELAY)

#define IS_CMD_TYPE_TIMER_DELAY(_type_) \
	((_type_) == CMD_TYPE_TIMER_DELAY_BEGIN || \
	 (_type_) == CMD_TYPE_TIMER_DELAY)

#define IS_CMD_TYPE_COND(_type_) \
	((_type_) >= CMD_TYPE_COND_IF && (_type_) <= CMD_TYPE_COND_FI)

#define IS_CMD_TYPE_VARIABLE_DELAY(_type_) \
	((_type_) == CMD_TYPE_VARIABLE_DELAY || (_type_) == CMD_TYPE_VARIABLE_DELAY_MARK)

enum {
	RES_UNINITIALIZED,
	RES_INITIALIZED,
	MAX_RES_INIT_STATE
};

enum {
	KEY_NONE,
	KEY_DISABLE,
	KEY_ENABLE,
};

enum cmd_level {
	CMD_LEVEL_NONE,
	CMD_LEVEL_1,
	CMD_LEVEL_2,
	CMD_LEVEL_3,
	MAX_CMD_LEVEL,
};

/* key level command */
struct keyinfo {
	u32 type;
	char *name;
	enum cmd_level level;
	u32 en;
	struct pktinfo *packet;
};

#define KEYINFO(_name_) PN_CONCAT(key, _name_)
#define KEYINFO_INIT(_name_, _lv_, _en_, _pkt_)	\
{									\
	.name = #_name_,				\
	.type = (CMD_TYPE_KEY),			\
	.level = (_lv_),				\
	.en = (_en_),				\
	.packet = (_pkt_),				\
}

#define DEFINE_PANEL_KEY(_name_, _lv_, _en_, _pkt_)	\
struct keyinfo KEYINFO(_name_) = KEYINFO_INIT(_name_, _lv_, _en_, _pkt_)

enum cmd_mode {
	CMD_MODE_NONE,
	CMD_MODE_RO,
	CMD_MODE_WO,
	CMD_MODE_RW,
	MAX_CMD_MODE,
};

struct ldi_reg_desc {
	u8 addr;
	char *name;
	enum cmd_mode mode;
	enum cmd_level level;
	bool dirty;
};

struct freq_hop_param {
	u32 dsi_freq;
	u32 osc_freq;
};

#define MAX_LDI_REG		(0x100)
#define LDI_REG_DESC(_addr_, _name_, _mode_, _level_)	\
[(_addr_)] = {											\
	.addr = (_addr_),									\
	.name = (_name_),									\
	.mode = (_mode_),									\
	.level = (_level_),									\
	.dirty = (0),										\
}

struct pkt_update_info {
	u32 offset;
	struct maptbl *maptbl;
	u32 nr_maptbl;
	int (*getidx)(struct pkt_update_info *pktui);
	void *pdata;
};

enum {
	PKT_OPTION_NONE = 0,
	PKT_OPTION_CHECK_TX_DONE = (1 << 0),
	PKT_OPTION_SR_ALIGN_4 = (1 << 1),
	PKT_OPTION_SR_ALIGN_12 = (1 << 2),
	PKT_OPTION_SR_ALIGN_16 = (1 << 3),
	PKT_OPTION_SR_REG_6C = (1 << 4),
	PKT_OPTION_SR_MAX_512 = (1 << 5),
	PKT_OPTION_SR_MAX_1024 = (1 << 6),
	PKT_OPTION_SR_MAX_2048 = (1 << 7),
};

struct pktinfo {
	u32 type;
	char *name;
	u32 addr;
	u8 *data;
	u32 offset;
	u32 dlen;
	struct pkt_update_info *pktui;
	u32 nr_pktui;
	u32 option;
};

struct rdinfo {
	u32 type;
	char *name;
	u32 addr;
	u32 offset;
	u32 len;
	u8 *data;
};

struct res_update_info {
	u32 offset;
	struct rdinfo *rditbl;
};

struct resinfo {
	u32 type;
	char *name;
	int state;
	u8 *data;
	u32 dlen;
	struct res_update_info *resui;
	u32 nr_resui;
};

struct dumpinfo {
	u32 type;
	char *name;
	struct resinfo *res;
	int (*callback)(struct dumpinfo *info);
};

struct condinfo {
	u32 type;
	char *name;
	bool (*cond)(struct panel_device *panel);
};

struct condinfo_cont {
	struct condinfo cond_if;
	struct condinfo cond_el;
	struct condinfo cond_fi;
};

struct pctrlinfo {
	u32 type;
	char *name;
	char *pctrl_name;
};

struct propinfo {
	u32 type;
	char *name;
	char *prop_name;
	enum PANEL_OBJ_PROP_TYPE prop_type;
	union {
		unsigned int value;
		char *str;
	};
};

#define DUMPINFO_INIT(_name_, _res_, _callback_)	\
{											\
	.name = #_name_,						\
	.type = (CMD_TYPE_DMP),					\
	.res = (_res_),							\
	.callback = (_callback_),				\
}

#define RESUI(_name_) PN_CONCAT(resui, _name_)
#define RESINFO(_name_) PN_CONCAT(res, _name_)
#define RESNAME(_name_) (_name_)
#define RDINFO(_name_) PN_CONCAT(rd, _name_)

#define RDINFO_INIT(_name_, _type_, _addr_, _offset_, _len_)	\
{											\
	.name = #_name_,						\
	.type = (_type_),						\
	.addr = (_addr_),						\
	.offset = (_offset_),					\
	.len = (_len_),							\
}

#define DEFINE_RDINFO(_name_, _type_, _addr_, _offset_, _len_)	\
struct rdinfo RDINFO(_name_) = RDINFO_INIT(_name_, _type_, _addr_, _offset_, _len_)

#define RESUI_INIT(_rditbl_, _offset_)\
{												\
	.offset = (_offset_),						\
	.rditbl = (_rditbl_),						\
}

#define DECLARE_RESUI(_name_) \
struct res_update_info RESUI(_name_)[]

#define DEFINE_RESUI(_name_, _rditbl_, _offset_)	\
struct res_update_info RESUI(_name_)[] =			\
{													\
	RESUI_INIT(_rditbl_, _offset_),		\
}

#define RESINFO_INIT(_name_, _arr_, _resui_)	\
{												\
	.name = #_name_,							\
	.type = (CMD_TYPE_RES),						\
	.state = (RES_UNINITIALIZED),				\
	.data = (_arr_),							\
	.dlen = ARRAY_SIZE((_arr_)),				\
	.resui = (_resui_),							\
	.nr_resui = (ARRAY_SIZE(_resui_)),			\
}

#define DEFINE_RESOURCE(_name_, _arr_, _resui_)	\
struct resinfo RESINFO(_name_) = RESINFO_INIT(_name_, _arr_, _resui_)

#define PKTUI(_name_) PN_CONCAT(pktui, _name_)
#define PKTINFO(_name_) PN_CONCAT(pkt, _name_)

#define DECLARE_PKTUI(_name_) \
struct pkt_update_info PKTUI(_name_)[]

#define DEFINE_PKTUI(_name_, _maptbl_, _update_offset_)	\
struct pkt_update_info PKTUI(_name_)[] =			\
{													\
	{												\
		.offset = (_update_offset_),				\
		.maptbl = (_maptbl_),						\
		.nr_maptbl = (1),							\
		.getidx = (NULL),							\
	},												\
}

#define PKTINFO_INIT(_name_, _type_, _arr_, _ofs_, _option_, _pktui_, _nr_pktui_)	\
{												\
	.name = (#_name_),							\
	.type = (_type_),							\
	.data = (_arr_),							\
	.offset = (_ofs_),							\
	.dlen = ARRAY_SIZE((_arr_)),				\
	.pktui = (_pktui_),							\
	.nr_pktui = (_nr_pktui_),					\
	.option = (_option_),							\
}

#define DEFINE_PACKET(_name_, _type_, _arr_, _ofs_, _option_, _pktui_, _nr_pktui_)	\
struct pktinfo PKTINFO(_name_) = PKTINFO_INIT(_name_, _type_, _arr_, _ofs_, _option_, _pktui_, _nr_pktui_)

#define DEFINE_VARIABLE_PACKET(_name_, _type_, _arr_, _ofs_)				\
DEFINE_PACKET(_name_, _type_, _arr_, _ofs_, 0, PKTUI(_name_), ARRAY_SIZE(PKTUI(_name_)))

#define DEFINE_VARIABLE_PACKET_WITH_OPTION(_name_, _type_, _arr_, _ofs_, _option_)				\
DEFINE_PACKET(_name_, _type_, _arr_, _ofs_, _option_, PKTUI(_name_), ARRAY_SIZE(PKTUI(_name_)))

#define DEFINE_STATIC_PACKET(_name_, _type_, _arr_, _ofs_)		\
DEFINE_PACKET(_name_, _type_, _arr_, _ofs_, 0, (NULL), (0))

#define DEFINE_STATIC_PACKET_WITH_OPTION(_name_, _type_, _arr_, _ofs_, _option_)		\
DEFINE_PACKET(_name_, _type_, _arr_, _ofs_, _option_, (NULL), (0))

#define PN_MAP_DATA_TABLE(_name_)	PN_CONCAT(PN_CONCAT(__pn_name__, _name_), table)
#define PN_CMD_DATA_TABLE(_name_)	PN_CONCAT(__PN_NAME__, _name_)

#define DEFINE_PN_STATIC_PACKET(_name_, _type_, _arr_)			\
DEFINE_PACKET(PN_CONCAT(__pn_name__, _name_), _type_,	\
		PN_CONCAT(__PN_NAME__, _arr_), _ofs_, 0, NULL, 0)

#define CONDINFO_IF(_name_) ((PN_CONCAT(cond_info, _name_)).cond_if)
#define CONDINFO_EL(_name_) ((PN_CONCAT(cond_info, _name_)).cond_el)
#define CONDINFO_FI(_name_) ((PN_CONCAT(cond_info, _name_)).cond_fi)

#define DEFINE_COND(_name_, _func_)						\
struct condinfo_cont PN_CONCAT(cond_info, _name_) = {	\
	.cond_if = {											\
		.name = (#_name_),								\
		.type = (CMD_TYPE_COND_IF),					\
		.cond = (void *) _func_,						\
	},													\
	.cond_el = {											\
		.name = (#_name_),								\
		.type = (CMD_TYPE_COND_EL),					\
		.cond = NULL,									\
	},													\
	.cond_fi = {											\
		.name = (#_name_),								\
		.type = (CMD_TYPE_COND_FI),					\
		.cond = NULL,									\
	},													\
}

#define DEFINE_PCTRL(_name_, _pctrl_name_)				\
struct pctrlinfo PN_CONCAT(pctrl_info_, _name_) = {		\
	.type = (CMD_TYPE_PCTRL),							\
	.name = (#_name_),									\
	.pctrl_name = (_pctrl_name_),						\
}

#define PCTRLINFO(_name_) PN_CONCAT(pctrl_info_, _name_)

#define DEFINE_SETPROP_VALUE(_name_, _prop_name_, _value_)			\
struct propinfo PN_CONCAT(propinfo_, _name_) = {		\
	.type = (CMD_TYPE_PROP),				\
	.name = (#_name_),					\
	.prop_name = (_prop_name_),					\
	.prop_type = PANEL_OBJ_PROP_TYPE_VALUE,		\
	.value = (_value_),				\
}
#define SETPROP(_name_) PN_CONCAT(propinfo_, _name_)

enum PANEL_SEQ {
	PANEL_INIT_SEQ,
	PANEL_EXIT_SEQ,
	PANEL_BOOT_SEQ,
	PANEL_RES_INIT_SEQ,
#ifdef CONFIG_SUPPORT_DIM_FLASH
	PANEL_DIM_FLASH_RES_INIT_SEQ,
#endif
#ifdef CONFIG_SUPPORT_GM2_FLASH
	PANEL_GM2_FLASH_RES_INIT_SEQ,
#endif
	PANEL_MAP_INIT_SEQ,
	PANEL_DISPLAY_ON_SEQ,
	PANEL_DISPLAY_OFF_SEQ,
	PANEL_ALPM_INIT_SEQ,
	PANEL_ALPM_ENTER_SEQ,
	PANEL_ALPM_SET_BL_SEQ = PANEL_ALPM_ENTER_SEQ,
	PANEL_ALPM_DELAY_SEQ,
	PANEL_ALPM_EXIT_SEQ,
	PANEL_ALPM_EXIT_AFTER_SEQ,
	PANEL_SET_BL_SEQ,
#ifdef CONFIG_SUPPORT_HMD
	PANEL_HMD_ON_SEQ,
	PANEL_HMD_OFF_SEQ,
	PANEL_HMD_BL_SEQ,
#endif
	PANEL_HBM_ON_SEQ,
	PANEL_HBM_OFF_SEQ,
#if defined(CONFIG_PANEL_DISPLAY_MODE)
	PANEL_DISPLAY_MODE_SEQ,
#endif
#ifdef CONFIG_SUPPORT_DSU
	PANEL_DSU_SEQ,
#endif
	PANEL_FPS_SEQ,
	PANEL_BLACK_AND_FPS_SEQ,
	PANEL_MCD_ON_SEQ,
	PANEL_MCD_OFF_SEQ,
	PANEL_MCD_RS_ON_SEQ,
	PANEL_MCD_RS_OFF_SEQ,
	PANEL_MCD_RS_READ_SEQ,
#ifdef CONFIG_SUPPORT_MST
	PANEL_MST_ON_SEQ,
	PANEL_MST_OFF_SEQ,
#endif
#ifdef CONFIG_SUPPORT_GRAM_CHECKSUM
	PANEL_GCT_ENTER_SEQ,
	PANEL_GCT_VDDM_SEQ,
	PANEL_GCT_IMG_UPDATE_SEQ,
	PANEL_GCT_IMG_0_UPDATE_SEQ,
	PANEL_GCT_IMG_1_UPDATE_SEQ,
	PANEL_GCT_EXIT_SEQ,
#endif
#if defined(CONFIG_SUPPORT_FAST_DISCHARGE)
	PANEL_FD_SEQ,
#endif
#ifdef CONFIG_SUPPORT_GRAYSPOT_TEST
	PANEL_GRAYSPOT_ON_SEQ,
	PANEL_GRAYSPOT_OFF_SEQ,
#endif
#ifdef CONFIG_SUPPORT_TDMB_TUNE
	PANEL_TDMB_TUNE_SEQ,
#endif
#ifdef CONFIG_SUPPORT_ISC_DEFECT
	PANEL_CHECK_ISC_DEFECT_SEQ,
#endif
#ifdef CONFIG_SUPPORT_SPI_IF_SEL
	PANEL_SPI_IF_ON_SEQ,
	PANEL_SPI_IF_OFF_SEQ,
#endif
#ifdef CONFIG_SUPPORT_CCD_TEST
	PANEL_CCD_TEST_SEQ,
#endif
#ifdef CONFIG_SUPPORT_DYNAMIC_HLPM
	PANEL_DYNAMIC_HLPM_ON_SEQ,
	PANEL_DYNAMIC_HLPM_OFF_SEQ,
#endif
#ifdef CONFIG_SUPPORT_ISC_TUNE_TEST
	PANEL_ISC_THRESHOLD_SEQ,
	PANEL_STM_TUNE_SEQ,
#endif
#ifdef CONFIG_SUPPORT_MAFPC
	PANEL_MAFPC_ON_SEQ,
	PANEL_MAFPC_OFF_SEQ,
	PANEL_MAFPC_SCALE_FACTOR_SEQ,
	PANEL_MAFPC_IMG_SEQ,
	PANEL_MAFPC_CHECKSUM_SEQ,
#endif
	PANEL_PARTIAL_DISP_ON_SEQ,
	PANEL_PARTIAL_DISP_OFF_SEQ,
	PANEL_DUMP_SEQ,
#ifdef CONFIG_SUPPORT_DDI_CMDLOG
	PANEL_CMDLOG_DUMP_SEQ,
#endif
	PANEL_CHECK_CONDITION_SEQ,
	PANEL_DIA_ONOFF_SEQ,
#ifdef CONFIG_SUPPORT_MASK_LAYER
	PANEL_MASK_LAYER_STOP_DIMMING_SEQ,
	PANEL_MASK_LAYER_BEFORE_SEQ,
	PANEL_MASK_LAYER_AFTER_SEQ,
	PANEL_MASK_LAYER_ENTER_BR_SEQ,
	PANEL_MASK_LAYER_EXIT_BR_SEQ,
	PANEL_MASK_LAYER_EXIT_AFTER_SEQ,
#endif
#ifdef CONFIG_SUPPORT_BRIGHTDOT_TEST
	PANEL_BRIGHTDOT_TEST_SEQ,
#endif
	PANEL_FFC_SEQ, //sequence to set ddi's ffc operation
	PANEL_OSC_SEQ, //sequence to chagne ddi's oscillator clock
#ifdef CONFIG_SUPPORT_SSR_TEST
	PANEL_SSR_TEST_SEQ,
#endif
#ifdef CONFIG_SUPPORT_ECC_TEST
	PANEL_ECC_TEST_SEQ,
#endif
	PANEL_DECODER_TEST_SEQ,
#ifdef CONFIG_SUPPORT_PANEL_VCOM_TRIM_TEST
	PANEL_VCOM_TRIM_TEST_SEQ,
#endif
	PANEL_DUMMY_SEQ,
	MAX_PANEL_SEQ,
};

/* structure of sequence table */
struct seqinfo {
	u32 type;
	char *name;
	void **cmdtbl;
	u32 size;
};

#define SEQINFO(_name_)	(_name_)
#define SEQINFO_INIT(_name_, _cmdtbl_)	\
{										\
	.type = (CMD_TYPE_SEQ),				\
	.name = (_name_),					\
	.cmdtbl = (_cmdtbl_),				\
	.size = ARRAY_SIZE((_cmdtbl_)),		\
}

#define DEFINE_SEQINFO(_name_, _cmdtbl_) \
struct seqinfo SEQINFO(_name_) = SEQINFO_INIT((#_name_), (_cmdtbl_))

struct brt_map {
	int brt;
	int lum;
};

#define DDI_SUPPORT_WRITE_GPARA	(1U << 0)
#define DDI_SUPPORT_READ_GPARA	(1U << 1)
#define DDI_SUPPORT_POINT_GPARA	(1U << 2)
#define DDI_SUPPORT_2BYTE_GPARA	(1U << 3)

enum {
	PN_COMP_TYPE_NONE,
	PN_COMP_TYPE_MIC,
	PN_COMP_TYPE_DSC,
	MAX_PN_COMP_TYPE,
};

struct panel_dsc {
	u32 slice_w;
	u32 slice_h;
};

enum vrr_mode {
	VRR_NORMAL_MODE,
	VRR_HS_MODE,
	MAX_VRR_MODE,
};

enum {
	VRR_AID_2_CYCLE,
	VRR_AID_4_CYCLE,
};

#define TE_SKIP_TO_DIV(_sw_skip, _hw_skip) \
	((_sw_skip + 1) * (_hw_skip + 1))

struct panel_vrr {
	u32 fps;
	u32 base_fps;
	u32 base_vactive;
	u32 base_vfp;
	u32 base_vbp;
	int te_sel;
	int te_v_st;
	int te_v_ed;
	u32 te_sw_skip_count;
	u32 te_hw_skip_count;
	u32 mode;
	int aid_cycle;
};

struct panel_resol {
	unsigned int w;
	unsigned int h;
	unsigned int comp_type;
	union {
		struct panel_dsc dsc;
	} comp_param;
	struct panel_vrr **available_vrr;
	unsigned int nr_available_vrr;
};

struct panel_mres {
	u32 nr_resol;
	struct panel_resol *resol;
};

#ifdef CONFIG_SUPPORT_MASK_LAYER
enum {
	MASK_LAYER_TRIGGER_BEFORE,
	MASK_LAYER_TRIGGER_AFTER,
	MASK_LAYER_TRIGGER_MAX,
};

enum {
	MASK_LAYER_OFF,
	MASK_LAYER_ON,
	MASK_LAYER_MAX,
};

enum {
	MASK_LAYER_HOOK_OFF,
	MASK_LAYER_HOOK_ON,
	MASK_LAYER_HOOK_MAX,
};

struct mask_layer_data {
	u32 trigger_time;
	u32 req_mask_layer;
};
#endif

#if defined(CONFIG_PANEL_DISPLAY_MODE)
struct common_panel_display_mode_bridge_ops {
	/*
	 * check if to change bridge refresh rate is permitted.
	 * (e.g. actual brightness 98nit ~ 420nit)
	 */
	bool (*check_changeable)(struct panel_device *panel);

	/*
	 * check if to jump to target refresh rate is permitted directly.
	 * (e.g. brightness, outdoor light level, copr or image updated)
	 */
	bool (*check_jumpmode)(struct panel_device *panel);
};

struct common_panel_display_mode_bridge {
	struct common_panel_display_mode *mode;
	int nframe_duration;
};

struct common_panel_display_mode {
	char name[PANEL_DISPLAY_MODE_NAME_LEN];
	struct panel_resol *resol;
	struct panel_vrr *vrr;
};

struct common_panel_display_modes {
	unsigned int num_modes;
	struct common_panel_display_mode **modes;
	struct common_panel_display_mode_bridge	*bridges;
	struct common_panel_display_mode_bridge_ops *bridge_ops;
};
#endif

struct ddi_properties {
	u32 gpara;
	bool support_partial_disp;
	//D2: avoid abnormal screen issue
	bool ssd_off_lpm_to_normal;
	u32 cmd_fifo_size;
	u32 img_fifo_size;
	bool err_fg_recovery;
	bool err_fg_powerdown;
	bool support_vrr;
	bool support_vrr_lfd;
	u32 dft_dsi_freq; //hs clock speen interface to AP, unit: khz
	u32 dft_osc_freq; //ddi's oscillator clock rate, unit: khz
	bool init_seq_by_lpdt;
	bool support_avoid_sandstorm;
};

struct ddi_ops {
	int (*ddi_init)(struct panel_device *panel, void *data, u32 size);
	int (*gamma_flash_checksum)(struct panel_device *panel, void *data, u32 size);
	int (*mtp_gamma_check)(struct panel_device *panel, void *data, u32 size);
#ifdef CONFIG_SUPPORT_SSR_TEST
	int (*ssr_test)(struct panel_device *panel, void *data, u32 size);
#endif
#ifdef CONFIG_SUPPORT_ECC_TEST
	int (*ecc_test)(struct panel_device *panel, void *data, u32 size);
#endif
	int (*decoder_test)(struct panel_device *panel, void *data, u32 size);
#ifdef CONFIG_SUPPORT_PANEL_VCOM_TRIM_TEST
	int (*vcom_trim_test)(struct panel_device *panel, void *data, u32 size);
#endif
};

struct rcd_region {
	int x;
	int y;
	int w;
	int h;
};

struct rcd_image {
	char *name;
	struct rcd_region image_rect;
	u8 *image_data;
	u32 image_data_len;
};

struct rcd_resol {
	char *name;
	int resol_x;
	int resol_y;
	struct rcd_image **images;
	int nr_images;
	struct rcd_region block_rect;
};

struct panel_rcd_data {
	u32 version;
	char *name;
	struct rcd_resol **rcd_resol;
	int nr_rcd_resol;
};

struct common_panel_info {
	char *ldi_name;
	char *name;
	char *model;
	char *vendor;
	u32 id;
	u32 rev;
	struct ddi_properties ddi_props;
	struct ddi_ops ddi_ops;
	struct panel_mres mres;
	struct panel_vrr **vrrtbl;
	int nr_vrrtbl;
	struct maptbl *maptbl;
	int nr_maptbl;
	struct seqinfo *seqtbl;
	int nr_seqtbl;
	struct rdinfo *rditbl;
	int nr_rditbl;
	struct resinfo *restbl;
	int nr_restbl;
	struct dumpinfo *dumpinfo;
	int nr_dumpinfo;
	struct mdnie_tune *mdnie_tune;
	struct panel_dimming_info *panel_dim_info[MAX_PANEL_BL_SUBDEV];
#ifdef CONFIG_EXYNOS_DECON_LCD_COPR
	struct panel_copr_data *copr_data;
#endif
#ifdef CONFIG_EXTEND_LIVE_CLOCK
	struct aod_tune *aod_tune;
#endif
#ifdef CONFIG_SUPPORT_DDI_FLASH
	struct panel_poc_data *poc_data;
#endif
#ifdef CONFIG_SUPPORT_POC_SPI
	struct spi_data *spi_data;
	struct spi_data **spi_data_tbl;
	int nr_spi_data_tbl;
#endif
#ifdef CONFIG_MCD_PANEL_BLIC
	struct blic_data **blic_data_tbl;
	int nr_blic_data_tbl;
#endif
#ifdef CONFIG_PANEL_FREQ_HOP
	struct freq_hop_elem *freq_hop_elems;
	int nr_freq_hop_elems;
#endif
#ifdef CONFIG_SUPPORT_MAFPC
	struct mafpc_info *mafpc_info;
#endif

#if defined(CONFIG_PANEL_DISPLAY_MODE)
	struct common_panel_display_modes *common_panel_modes;
#endif
#ifdef CONFIG_MCD_PANEL_RCD
	struct panel_rcd_data *rcd_data;
#endif
};

enum {
	OVER_ZERO,
	UNDER_ZERO,
	UNDER_MINUS_FIFTEEN,
	DIM_OVER_ZERO,
	DIM_UNDER_ZERO,
	DIM_UNDER_MINUS_FIFTEEN,
	TEMP_MAX,
};

enum {
	POC_ONOFF_OFF,
	POC_ONOFF_ON,
	POC_ONOFF_MAX
};

enum {
	ACL_PWRSAVE_OFF,
	ACL_PWRSAVE_ON,
	MAX_ACL_PWRSAVE,
};

enum {
	SMOOTH_TRANS_OFF,
	SMOOTH_TRANS_ON,
	SMOOTH_TRANS_MAX,
};

enum {
	ACL_OPR_OFF,
	ACL_OPR_03P,
	ACL_OPR_06P,
	ACL_OPR_08P,
	ACL_OPR_12P,
	ACL_OPR_15P,
	ACL_OPR_MAX
};

enum {
	ALPM_OFF = 0,
	ALPM_LOW_BR,
	HLPM_LOW_BR,
	ALPM_HIGH_BR,
	HLPM_HIGH_BR,
};

enum {
	PANEL_HBM_OFF,
	PANEL_HBM_ON,
	MAX_PANEL_HBM,
};

#ifdef CONFIG_SUPPORT_XTALK_MODE
enum {
	XTALK_OFF,
	XTALK_ON,
};
#endif

#ifdef CONFIG_SUPPORT_GRAM_CHECKSUM
enum {
	GRAM_CHKSUM_OFF,
	GRAM_CHKSUM_LV_TEST_1,
	GRAM_CHKSUM_LV_TEST_2,
	GRAM_CHKSUM_HV_TEST_1,
	GRAM_CHKSUM_HV_TEST_2,
	MAX_GRAM_CHKSUM,
};

enum {
	GCT_PATTERN_NONE,
	GCT_PATTERN_1,
	GCT_PATTERN_2,
	MAX_GCT_PATTERN,
};

enum {
	VDDM_ORIG,
	VDDM_LV,
	VDDM_HV,
	MAX_VDDM,
};

enum {
	GRAM_TEST_OFF,
	GRAM_TEST_ON,
	GRAM_TEST_SKIPPED,
};
#endif

enum {
	DECODER_TEST_OFF,
	DECODER_TEST_ON,
	DECODER_TEST_SKIPPED,
};

#ifdef CONFIG_SUPPORT_ISC_TUNE_TEST
enum stm_field_num {
	STM_CTRL_EN = 0,
	STM_MAX_OPT,
	STM_DEFAULT_OPT,
	STM_DIM_STEP,
	STM_FRAME_PERIOD,
	STM_MIN_SECT,
	STM_PIXEL_PERIOD,
	STM_LINE_PERIOD,
	STM_MIN_MOVE,
	STM_M_THRES,
	STM_V_THRES,
	STM_FIELD_MAX
};
#endif

enum {
	MCD_RS_1_RIGHT,
	MCD_RS_1_LEFT,
	MCD_RS_2_RIGHT,
	MCD_RS_2_LEFT,
	MAX_MCD_RS,
};

enum {
	DIM_TYPE_AID_DIMMING,
	DIM_TYPE_DIM_FLASH,
	MAX_DIM_TYPE,
};

#if defined(CONFIG_UML)
#define MAX_PANEL (128)
#else
#define MAX_PANEL (32)
#endif
#define MAX_PANEL_DDI (8)
#define MAX_PANEL_LUT (128)

enum {
	PANEL_ID,
	PANEL_MASK,
	PANEL_INDEX,
	PANEL_DDI_INDEX,
};

struct panel_id_mask {
	int id;
	int mask;
	struct list_head head;
};

struct panel_dt_lut {
	const char *name;
	struct device_node *ap_vendor_setting_node;
	struct device_node *panel_modes_node;
	struct device_node *power_ctrl_node;
#ifdef CONFIG_PANEL_FREQ_HOP
	struct device_node *freq_hop_node;
#endif
	struct list_head head;
	struct list_head id_mask_list;
	const char *dqe_suffix;
};

struct panel_lut {
	u32 id;
	u32 mask;
	u32 index;
	u32 ddi_index;
};

struct panel_lut_info {
	const char *names[MAX_PANEL];
	int nr_panel;
	struct device_node *ap_vendor_setting_node[MAX_PANEL_DDI];
	int nr_panel_ddi;
	struct device_node *panel_modes_node[MAX_PANEL_DDI];
	int nr_panel_modes;
	struct device_node *panel_power_ctrl[MAX_PANEL_DDI];
	int nr_panel_power_ctrl;
	struct panel_lut lut[MAX_PANEL_LUT];
	int nr_lut;
};

struct panel_properties {
	s32 temperature;
	u32 siop_enable;
	u32 adaptive_control;
	u32 alpm_mode;
	u32 cur_alpm_mode;
	s32 lpm_brightness;
	u32 lpm_opr;
	u32 lpm_fps;
	u32 cur_lpm_opr;
	u32 mcd_on;
	u32 mcd_resistance;
	int mcd_rs_range[MAX_MCD_RS][2];
	int mcd_rs_flash_range[MAX_MCD_RS][2];
#ifdef CONFIG_SUPPORT_MST
	u32 mst_on;
#endif
	u32 hmd_on;
	u32 hmd_brightness;
	u32 lux;
#ifdef CONFIG_SUPPORT_XTALK_MODE
	u32 xtalk_mode;
#endif
#ifdef CONFIG_SUPPORT_DDI_FLASH
	u32 poc_op;
#endif
#ifdef CONFIG_SUPPORT_GRAM_CHECKSUM
	u32 gct_on;
	u32 gct_vddm;
	u32 gct_pattern;
	u8 gct_valid_chksum[4];
#endif
#ifdef CONFIG_SUPPORT_GRAYSPOT_TEST
	u32 grayspot;
#endif
	u32 poc_onoff;
#ifdef CONFIG_SUPPORT_TDMB_TUNE
	u32 tdmb_on;
	u32 cur_tdmb_on;
#endif
	u32 key[MAX_CMD_LEVEL];
	u32 irc_mode;
#ifdef CONFIG_SUPPORT_DIM_FLASH
	bool dim_flash_on;
	u32 dim_flash_state;	/* success or fail */
	u32 cur_dim_type;	/* AID DIMMING or DIM FLASH */
#endif
#ifdef CONFIG_SUPPORT_DYNAMIC_HLPM
	u32 dynamic_hlpm;
#endif
#ifdef CONFIG_SUPPORT_ISC_TUNE_TEST
	u8 isc_threshold;
	u8 stm_field_info[STM_FIELD_MAX];
#endif
	u32 panel_partial_disp;
	u32 panel_mode;
#ifdef CONFIG_PANEL_VRR_BRIDGE
	u32 target_panel_mode;
#endif
	/* resolution */
	bool mres_updated;
	u32 old_mres_mode;
	u32 mres_mode;
	u32 xres;
	u32 yres;
	/* variable refresh rate */
	u32 vrr_fps;
	u32 vrr_mode;
	u32 vrr_idx;
	/* original variable refresh rate */
	u32 vrr_origin_fps;
	u32 vrr_origin_mode;
	u32 vrr_origin_idx;
#ifdef CONFIG_PANEL_VRR_BRIDGE
	bool vrr_bridge_enable;
#endif
	bool vrr_updated;
	struct vrr_lfd_info vrr_lfd_info;
	u32 dia_mode;
	u32 ub_con_cnt;
	u32 conn_det_enable;
#if defined(CONFIG_SUPPORT_FAST_DISCHARGE)
	u32 enable_fd;
#endif
#ifdef CONFIG_SUPPORT_BRIGHTDOT_TEST
	u32 brightdot_test_enable;
#endif
	u32 dsi_freq;
	u32 osc_freq;
};

struct panel_info {
	const char *ldi_name;
	unsigned char id[PANEL_ID_LEN];
	unsigned char vendor[PANEL_ID_LEN];
	struct panel_properties props;
	struct ddi_properties ddi_props;
	struct ddi_ops ddi_ops;
	struct panel_mres mres;

	/* platform dependent data - ex> exynos : dsim_device */
	void *pdata;
	void *dim_info[MAX_PANEL_BL_SUBDEV];
	void *dim_flash_info[MAX_PANEL_BL_SUBDEV];
	struct panel_vrr **vrrtbl;
	int nr_vrrtbl;
	struct maptbl *maptbl;
	int nr_maptbl;
	struct seqinfo *seqtbl;
	int nr_seqtbl;
	struct rdinfo *rditbl;
	int nr_rditbl;
	struct dumpinfo *dumpinfo;
	int nr_dumpinfo;
	struct resinfo *restbl;
	int nr_restbl;
	struct panel_dimming_info *panel_dim_info[MAX_PANEL_BL_SUBDEV];
	int nr_panel_dim_info;
	struct list_head panel_lut_info;
#ifdef CONFIG_MCD_PANEL_BLIC
	struct blic_data **blic_data_tbl;
	int nr_blic_data_tbl;
#endif
#if defined(CONFIG_PANEL_DISPLAY_MODE)
	struct common_panel_display_modes *common_panel_modes;
#endif
#ifdef CONFIG_MCD_PANEL_RCD
	struct panel_rcd_data *rcd_data;
#endif
	const char *dqe_suffix;
};

struct attr_show_args {
	const char *name;
	char *buf;
	size_t size;
};

struct attr_store_args {
	const char *name;
	const char *buf;
	size_t size;
};

struct attr_exist_args {
	const char *name;
};

#define __PANEL_ATTR_RO(_name, _mode) __ATTR(_name, _mode,		\
			 PN_CONCAT(_name, show), NULL)

#define __PANEL_ATTR_WO(_name, _mode) __ATTR(_name, _mode,		\
			 NULL, PN_CONCAT(_name, store))

#define __PANEL_ATTR_RW(_name, _mode) __ATTR(_name, _mode,		\
			 PN_CONCAT(_name, show), PN_CONCAT(_name, store))

enum sysfs_arg_type {
	SYSFS_ARG_TYPE_NONE,
	SYSFS_ARG_TYPE_S32,
	SYSFS_ARG_TYPE_U32,
	SYSFS_ARG_TYPE_STR,
	MAX_SYSFS_ARG_TYPE,
};

#define MAX_SYSFS_ARG_NUM		(6)
#define MAX_SYSFS_ARG_STR_LEN	(32)

struct sysfs_arg {
	const char *name;
	unsigned int nargs;
	enum sysfs_arg_type type;
};

struct sysfs_arg_out {
	union {
		s32 val_s32;
		u32 val_u32;
		char val_str[MAX_SYSFS_ARG_STR_LEN];
	} d[MAX_SYSFS_ARG_NUM];
	unsigned int nargs;
};

#ifdef CONFIG_SUPPORT_SSR_TEST
enum ssr_test_result {
	PANEL_SSR_TEST_FAIL = 0,
	PANEL_SSR_TEST_PASS = 1,
	MAX_PANEL_SSR_TEST
};
#endif

#ifdef CONFIG_SUPPORT_ECC_TEST
enum ecc_test_result {
	PANEL_ECC_TEST_FAIL = 0,
	PANEL_ECC_TEST_PASS = 1,
	MAX_PANEL_ECC_TEST
};
#endif

enum decoder_test_result {
	PANEL_DECODER_TEST_FAIL = -1,
	PANEL_DECODER_TEST_PASS = 1,
	MAX_PANEL_DECODER_TEST
};

#ifdef CONFIG_SUPPORT_PANEL_VCOM_TRIM_TEST
enum vcom_trim_test_result {
	PANEL_VCOM_TRIM_TEST_FAIL = 0,
	PANEL_VCOM_TRIM_TEST_PASS = 1,
	MAX_PANEL_VCOM_TRIM_TEST
};
#endif

static inline int search_table_u32(u32 *tbl, u32 sz_tbl, u32 value)
{
	int i;

	if (!tbl)
		return -EINVAL;

	for (i = 0; i < sz_tbl; i++)
		if (tbl[i] == value)
			return i;

	return -1;
}

static inline int search_table(void *tbl, int itemsize, u32 sz_tbl, void *value)
{
	int i;

	if (!tbl)
		return -EINVAL;

	for (i = 0; i < sz_tbl; i++)
		if (!memcmp(tbl + (i * itemsize),
					value, itemsize))
			return i;

	return -1;
}

#define disp_div_round(n, m) ((((n) * 10 / (m)) + 5) / 10)

const char *pnobj_type_to_string(u32 type);
void print_data(char *data, int size);
int register_common_panel(struct common_panel_info *info);
int deregister_common_panel(struct common_panel_info *info);
struct maptbl *find_panel_maptbl_by_index(struct panel_info *panel, int index);
struct maptbl *find_panel_maptbl_by_name(struct panel_info *panel_data, char *name);
struct common_panel_info *find_panel(struct panel_device *panel, u32 id);
struct device_node *find_panel_ddi_node(struct panel_device *panel, u32 id);
struct device_node *find_panel_modes_node(struct panel_device *panel, u32 id);
const char *get_panel_lut_dqe_suffix(struct panel_device *panel, u32 id);
#ifdef CONFIG_PANEL_FREQ_HOP
struct device_node *get_panel_lut_freq_hop_node(struct panel_device *panel, u32 id);
#endif
struct device_node *find_panel_power_ctrl_node(struct panel_device *panel, u32 id);
void print_panel_lut(struct panel_dt_lut *lut_info);
bool check_seqtbl_exist(struct panel_info *panel_data, u32 index);
struct seqinfo *find_panel_seqtbl(struct panel_info *panel_data, char *name);
struct seqinfo *find_index_seqtbl(struct panel_info *panel_data, u32 index);
struct pktinfo *find_packet(struct seqinfo *seqtbl, char *name);
struct pktinfo *find_packet_suffix(struct seqinfo *seqtbl, char *name);
struct panel_dimming_info *find_panel_dimming(struct panel_info *panel_data, char *name);
int excute_seqtbl_nolock(struct panel_device *panel, struct seqinfo *seqtbl, int index);
int panel_do_seqtbl(struct panel_device *panel, struct seqinfo *seqtbl);
int panel_do_seqtbl_by_index_nolock(struct panel_device *panel, int index);
int panel_do_seqtbl_by_index(struct panel_device *panel, int index);
struct resinfo *find_panel_resource(struct panel_info *panel, char *name);
bool panel_resource_initialized(struct panel_info *panel_data, char *name);
int rescpy(u8 *dst, struct resinfo *res, u32 offset, u32 len);
int rescpy_by_name(struct panel_info *panel, u8 *dst, char *name, u32 offset, u32 len);
int resource_clear(struct resinfo *res);
int resource_clear_by_name(struct panel_info *panel_data, char *name);
int resource_copy(u8 *dst, struct resinfo *res);
int resource_copy_by_name(struct panel_info *panel_data, u8 *dst, char *name);
int resource_copy_n_clear_by_name(struct panel_info *panel_data, u8 *dst, char *name);
int get_resource_size_by_name(struct panel_info *panel_data, char *name);
int get_panel_resource_size(struct resinfo *res);
int panel_resource_update(struct panel_device *panel, struct resinfo *res);
int panel_resource_update_by_name(struct panel_device *panel, char *name);
int panel_dumpinfo_update(struct panel_device *panel, struct dumpinfo *info);
int panel_rx_nbytes(struct panel_device *panel, u32 type, u8 *buf, u8 addr, u32 pos, u32 len);
int panel_tx_nbytes(struct panel_device *panel,	u32 type, u8 *buf, u8 addr, u32 pos, u32 len);
u16 calc_checksum_16bit(u8 *arr, int size);
void panel_update_packet_data(struct panel_device *panel, struct pktinfo *info);
int panel_verify_tx_packet(struct panel_device *panel, u8 *src, u32 ofs, u8 len);
int panel_set_key(struct panel_device *panel, int level, bool on);
struct pktinfo *alloc_static_packet(char *name, u32 type, u8 *data, u32 dlen);
int check_panel_active(struct panel_device *panel, const char *caller);
int panel_dsi_wait_for_vsync(struct panel_device *panel, u32 timeout);
int panel_dsi_set_bypass(struct panel_device *panel, bool on);
int panel_dsi_get_bypass(struct panel_device *panel);
int panel_dsi_set_commit_retry(struct panel_device *panel, bool on);
int panel_dsi_print_dpu_event_log(struct panel_device *panel);
int panel_dsi_dump_dpu_register(struct panel_device *panel);
int panel_dsi_set_lpdt(struct panel_device *panel, bool on);
int panel_wake_lock(struct panel_device *panel, unsigned long timeout);
int panel_wake_unlock(struct panel_device *panel);
int panel_emergency_off(struct panel_device *panel);
#if defined(CONFIG_PANEL_FREQ_HOP)
int panel_set_freq_hop(struct panel_device *panel, struct freq_hop_param *param);
#endif
int panel_parse_ap_vendor_node(struct panel_device *panel, struct device_node *node);
int panel_flush_image(struct panel_device *panel);
int read_panel_id(struct panel_device *panel, u8 *buf);
int panel_resource_prepare(struct panel_device *panel);
void print_panel_resource(struct panel_device *panel);
int find_sysfs_arg_by_name(struct sysfs_arg *arglist, int nr_arglist, char *s);
int parse_sysfs_arg(int nargs, enum sysfs_arg_type type,
		char *s, struct sysfs_arg_out *out);
int panel_cmdq_get_size(struct panel_device *panel);
DECLARE_REDIRECT_MOCKABLE(panel_cmdq_flush, RETURNS(int), PARAMS(struct panel_device *));
struct panel_dt_lut *find_panel_lut(struct panel_device *panel, u32 id);
#ifdef CONFIG_EXYNOS_DECON_LCD_SYSFS
int panel_sysfs_probe(struct panel_device *panel);
int panel_sysfs_remove(struct panel_device *panel);
ssize_t attr_store_for_each(struct class *cls, const char *name, const char *buf, size_t size);
ssize_t attr_show_for_each(struct class *cls, const char *name, char *buf);
ssize_t attr_exist_for_each(struct class *cls, const char *name);
#else
static inline int panel_sysfs_probe(struct panel_device *panel) { return 0; }
static inline int panel_sysfs_remove(struct panel_device *panel) { return 0; }
static inline ssize_t attr_store_for_each(struct class *cls, const char *name, const char *buf, size_t size) { return 0; }
static inline ssize_t attr_show_for_each(struct class *cls, const char *name, char *buf) { return 0; }
static inline ssize_t attr_exist_for_each(struct class *cls, const char *name) { return 0; }
#endif
#define IS_PANEL_ACTIVE(_panel) check_panel_active(_panel, __func__)
#endif /* __PANEL_H__ */