// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 Amlogic, Inc. All rights reserved.
 */

#include <drm/drm_modeset_helper.h>
#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_panel.h>
#include <drm/drm_mipi_dsi.h>
#include <video/display_timing.h>
#include <linux/component.h>
#include <linux/amlogic/media/vout/lcd/lcd_vout.h>
#include <linux/amlogic/media/vout/lcd/lcd_notify.h>

#include "meson_crtc.h"
#include "meson_lcd.h"


static struct am_drm_lcd_s *am_drm_lcd;

static struct drm_display_mode tablet_lcd_mode = {
	.name = "panel",
	.status = 0,
	.clock = 74250,
	.hdisplay = 1280,
	.hsync_start = 1390,
	.hsync_end = 1430,
	.htotal = 1650,
	.hskew = 0,
	.vdisplay = 720,
	.vsync_start = 725,
	.vsync_end = 730,
	.vtotal = 750,
	.vscan = 0,
	.vrefresh = 60,
};

static struct drm_display_mode tv_lcd_mode_ref[] = {
	{ /* 600p */
		.name = "600p",
		.status = 0,
		.clock = 40234,
		.hdisplay = 1024,
		.hsync_start = 1026,
		.hsync_end = 1034,
		.htotal = 1056,
		.hskew = 0,
		.vdisplay = 600,
		.vsync_start = 624,
		.vsync_end = 630,
		.vtotal = 635,
		.vscan = 0,
		.vrefresh = 60,
	},
	{ /* 768p */
		.name = "768p",
		.status = 0,
		.clock = 75442,
		.hdisplay = 1366,
		.hsync_start = 1390,
		.hsync_end = 1430,
		.htotal = 1560,
		.hskew = 0,
		.vdisplay = 768,
		.vsync_start = 773,
		.vsync_end = 788,
		.vtotal = 806,
		.vscan = 0,
		.vrefresh = 60,
	},
	{ /* 1080p */
		.name = "1080p",
		.status = 0,
		.clock = 148500,
		.hdisplay = 1920,
		.hsync_start = 1930,
		.hsync_end = 1970,
		.htotal = 2200,
		.hskew = 0,
		.vdisplay = 1080,
		.vsync_start = 1090,
		.vsync_end = 1100,
		.vtotal = 1125,
		.vscan = 0,
		.vrefresh = 60,
	},
	{ /* 2160p */
		.name = "2160p",
		.status = 0,
		.clock = 594000,
		.hdisplay = 3840,
		.hsync_start = 4000,
		.hsync_end = 4060,
		.htotal = 4400,
		.hskew = 0,
		.vdisplay = 2160,
		.vsync_start = 2200,
		.vsync_end = 2210,
		.vtotal = 2250,
		.vscan = 0,
		.vrefresh = 60,
	},
	{ /* invalid */
		.name = "invalid",
		.status = 0,
		.clock = 148500,
		.hdisplay = 1920,
		.hsync_start = 1930,
		.hsync_end = 1970,
		.htotal = 2200,
		.hskew = 0,
		.vdisplay = 1080,
		.vsync_start = 1090,
		.vsync_end = 1100,
		.vtotal = 1125,
		.vscan = 0,
		.vrefresh = 60,
	},
};

static unsigned int lcd_std_frame_rate[] = {
	60,
	59,
	50,
	48,
	47
};

#define DRM_LCD_TV_MODE_CNT_MAX    5
static struct drm_display_mode tv_lcd_mode[DRM_LCD_TV_MODE_CNT_MAX];
static int lcd_tv_mode_cnt;

static struct display_timing am_lcd_timing = {
	.pixelclock = { 55000000, 65000000, 75000000 },
	.hactive = { 1024, 1024, 1024 },
	.hfront_porch = { 40, 40, 40 },
	.hback_porch = { 220, 220, 220 },
	.hsync_len = { 20, 60, 100 },
	.vactive = { 768, 768, 768 },
	.vfront_porch = { 7, 7, 7 },
	.vback_porch = { 21, 21, 21 },
	.vsync_len = { 10, 10, 10 },
	.flags = DISPLAY_FLAGS_DE_HIGH,
};

/* ***************************************************************** */
/*     drm driver function                                           */
/* ***************************************************************** */

char *am_lcd_get_voutmode(struct drm_connector *connector,
		struct drm_display_mode *mode)
{
	int i;
	struct am_drm_lcd_s *lcd;
	struct lcd_config_s *pconf;
	struct drm_display_mode *native_mode;

	lcd = connector_to_am_lcd(connector);
	if (!lcd)
		return NULL;
	if (!lcd->lcd_drv)
		return NULL;

	pconf = &lcd->lcd_drv->config;
	switch (lcd->lcd_drv->mode) {
	case LCD_MODE_TV:
		for (i = 0; i < lcd_tv_mode_cnt; i++) {
			native_mode = &tv_lcd_mode[i];
			if (native_mode->hdisplay == mode->hdisplay &&
			    native_mode->vdisplay == mode->vdisplay &&
			    native_mode->vrefresh == mode->vrefresh)
				return native_mode->name;
		}
		break;
	case LCD_MODE_TABLET:
		native_mode = &tablet_lcd_mode;
		if (native_mode->hdisplay == mode->hdisplay &&
			native_mode->vdisplay == mode->vdisplay &&
			native_mode->vrefresh == mode->vrefresh)
			return native_mode->name;
		break;
	default:
		break;
	}
	return NULL;
}

static int am_lcd_connector_get_modes(struct drm_connector *connector)
{
	struct drm_display_mode *mode, *native_mode;
	struct am_drm_lcd_s *lcd;
	int i;

	lcd = connector_to_am_lcd(connector);

	DRM_DEBUG("***************************************************\n");
	DRM_DEBUG("am_drm_lcd: %s: lcd mode [%s] display size: %d x %d\n",
		__func__, lcd->mode->name,
		lcd->mode->hdisplay, lcd->mode->vdisplay);

	switch (lcd->lcd_drv->mode) {
	case LCD_MODE_TV:
		for (i = 0; i < lcd_tv_mode_cnt; i++) {
			native_mode = &tv_lcd_mode[i];
			if (strstr(native_mode->name, "invalid"))
				continue;

			mode = drm_mode_duplicate(connector->dev, native_mode);
			if (!mode) {
				DRM_INFO("[%s:%d]duplicate failed\n", __func__,
					 __LINE__);
				return 0;
			}

			drm_mode_probed_add(connector, mode);
		}
		break;
	case LCD_MODE_TABLET:
		native_mode = &tablet_lcd_mode;
		mode = drm_mode_duplicate(connector->dev, native_mode);
		if (!mode) {
			DRM_INFO("[%s:%d]duplicate failed\n", __func__,
				 __LINE__);
			return 0;
		}
		drm_mode_probed_add(connector, mode);
		break;
	default:
		break;
	}

	return 0;
}

enum drm_mode_status
am_lcd_connector_mode_valid(struct drm_connector *connector,
		struct drm_display_mode *mode)
{
	int i;
	struct am_drm_lcd_s *lcd;
	struct drm_display_mode *native_mode;

	lcd = connector_to_am_lcd(connector);
	if (!lcd)
		return MODE_ERROR;
	if (!lcd->lcd_drv)
		return MODE_ERROR;

	DRM_DEBUG("am_drm_lcd: %s: mode [%s] display size: %d x %d\n",
		__func__, mode->name, mode->hdisplay, mode->vdisplay);
	DRM_DEBUG("am_drm_lcd: %s: lcd config size: %d x %d\n",
		__func__, lcd->lcd_drv->config.basic.h_active,
		lcd->lcd_drv->config.basic.v_active);

	switch (lcd->lcd_drv->mode) {
	case LCD_MODE_TV:
		for (i = 0; i < lcd_tv_mode_cnt; i++) {
			native_mode = &tv_lcd_mode[i];
			if (strstr(native_mode->name, "invalid"))
				continue;
			if (native_mode->hdisplay == mode->hdisplay &&
				native_mode->vdisplay == mode->vdisplay &&
				native_mode->vrefresh == mode->vrefresh)
				return MODE_OK;
		}
		break;
	case LCD_MODE_TABLET:
		native_mode = &tablet_lcd_mode;
		if (native_mode->hdisplay == mode->hdisplay &&
			native_mode->vdisplay == mode->vdisplay &&
			native_mode->vrefresh == mode->vrefresh)
			return MODE_OK;
		break;
	default:
		break;
	}

	DRM_DEBUG("hdisplay = %d\nvdisplay = %d\n"
		  "vrefresh = %d\n", mode->hdisplay,
		  mode->vdisplay, mode->vrefresh);

	return MODE_NOMODE;
}

static const struct drm_connector_helper_funcs am_lcd_connector_helper_funcs = {
	.get_modes = am_lcd_connector_get_modes,
	.mode_valid = am_lcd_connector_mode_valid,
	//.best_encoder
	//.atomic_best_encoder
};

static enum drm_connector_status
am_lcd_connector_detect(struct drm_connector *connector, bool force)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
	return connector_status_connected;
}

static int am_lcd_connector_dpms(struct drm_connector *connector, int mode)
{
	int ret = 0;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	ret = drm_helper_connector_dpms(connector, mode);
	return ret;
}

static int am_lcd_connector_fill_modes(struct drm_connector *connector,
				       u32 maxX, uint32_t maxY)
{
	int count = 0;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
	count = drm_helper_probe_single_connector_modes(connector, maxX, maxY);
	DRM_DEBUG("am_drm_lcd: %s %d: count=%d\n", __func__, __LINE__, count);
	return count;
}

static void am_lcd_connector_destroy(struct drm_connector *connector)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	drm_connector_cleanup(connector);
}

static void am_lcd_connector_reset(struct drm_connector *connector)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	drm_atomic_helper_connector_reset(connector);
}

static struct drm_connector_state *
am_lcd_connector_duplicate_state(struct drm_connector *connector)
{
	struct drm_connector_state *state;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	state = drm_atomic_helper_connector_duplicate_state(connector);
	return state;
}

static void am_lcd_connector_destroy_state(struct drm_connector *connector,
					   struct drm_connector_state *state)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	drm_atomic_helper_connector_destroy_state(connector, state);
}

static const struct drm_connector_funcs am_lcd_connector_funcs = {
	.dpms			= am_lcd_connector_dpms,
	.detect			= am_lcd_connector_detect,
	.fill_modes		= am_lcd_connector_fill_modes,
	.destroy		= am_lcd_connector_destroy,
	.reset			= am_lcd_connector_reset,
	.atomic_duplicate_state	= am_lcd_connector_duplicate_state,
	.atomic_destroy_state	= am_lcd_connector_destroy_state,
};

static void am_lcd_encoder_mode_set(struct drm_encoder *encoder,
			struct drm_crtc_state *crtc_state,
			struct drm_connector_state *conn_state)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

static void am_lcd_encoder_enable(struct drm_encoder *encoder,
	struct drm_atomic_state *state)
{
	enum vmode_e vmode = get_current_vmode();
	struct am_drm_lcd_s *lcd = encoder_to_am_lcd(encoder);
	struct drm_display_mode *mode = &encoder->crtc->mode;
	struct am_meson_crtc_state *meson_crtc_state =
				to_am_meson_crtc_state(encoder->crtc->state);
	struct drm_crtc *crtc = encoder->crtc;

	if (!lcd || !lcd->lcd_drv)
		return;

	if (vmode == VMODE_LCD)
		DRM_DEBUG("enable\n");
	else
		DRM_DEBUG("enable fail! vmode:%d\n", vmode);

	if (meson_crtc_state->uboot_mode_init == 1)
		vmode |= VMODE_INIT_BIT_MASK;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	if (lcd->lcd_drv->mode == LCD_MODE_TV &&
		crtc->enabled && !crtc->state->active_changed &&
		lcd->prev_vrefresh != mode->vrefresh) {
		DRM_DEBUG("am_drm_lcd: %s pre_active:%d, pre_vrefresh:%u\n",
			__func__, crtc->enabled, mode->vrefresh);
		lcd->prev_vrefresh = mode->vrefresh;
		return;
	}

	lcd->prev_vrefresh = mode->vrefresh;

	vout_notifier_call_chain(VOUT_EVENT_MODE_CHANGE_PRE, &vmode);
	mutex_lock(&lcd_power_mutex);
	aml_lcd_notifier_call_chain(LCD_EVENT_PREPARE, (void *)lcd->lcd_drv);
	if (lcd->lcd_drv->boot_ctrl->init_level !=
	    LCD_INIT_LEVEL_KERNEL_OFF) {
		aml_lcd_notifier_call_chain(LCD_EVENT_ENABLE,
							(void *)lcd->lcd_drv);
		lcd->lcd_drv->config.retry_enable_cnt = 0;
		while (lcd->lcd_drv->config.retry_enable_flag) {
			if (lcd->lcd_drv->config.retry_enable_cnt++ >=
				LCD_ENABLE_RETRY_MAX)
				break;
			DRM_DEBUG("am_drm_lcd: retry enable...%d\n",
				lcd->lcd_drv->config.retry_enable_cnt);
			aml_lcd_notifier_call_chain(LCD_EVENT_IF_POWER_OFF,
						    (void *)lcd->lcd_drv);
			msleep(1000);
			aml_lcd_notifier_call_chain(LCD_EVENT_IF_POWER_ON,
						    (void *)lcd->lcd_drv);
		}
		lcd->lcd_drv->config.retry_enable_cnt = 0;
	}
	mutex_unlock(&lcd_power_mutex);
	vout_notifier_call_chain(VOUT_EVENT_MODE_CHANGE, &vmode);
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

static void am_lcd_encoder_disable(struct drm_encoder *encoder,
	struct drm_atomic_state *state)
{
	struct am_drm_lcd_s *lcd = encoder_to_am_lcd(encoder);
	struct drm_crtc *crtc = encoder->crtc;

	if (!lcd || !lcd->lcd_drv)
		return;

	DRM_DEBUG("am_drm_lcd:%s, active:%d, vrefresh:%u, %u\n", __func__,
		crtc->state->enable, lcd->prev_vrefresh,
			crtc->state->mode.vrefresh);
	if (lcd->lcd_drv->mode == LCD_MODE_TV && crtc->state->enable) {
		pr_info("am_drm_lcd: %s, skip lcd disable.\n", __func__);
		return;
	}

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
	mutex_lock(&lcd_power_mutex);
	aml_lcd_notifier_call_chain(LCD_EVENT_DISABLE, (void *)lcd->lcd_drv);
	aml_lcd_notifier_call_chain(LCD_EVENT_UNPREPARE, (void *)lcd->lcd_drv);
	mutex_unlock(&lcd_power_mutex);

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

static void am_lcd_encoder_commit(struct drm_encoder *encoder)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

static int am_lcd_encoder_atomic_check(struct drm_encoder *encoder,
				       struct drm_crtc_state *crtc_state,
				struct drm_connector_state *conn_state)
{
	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
	return 0;
}

static const struct drm_encoder_helper_funcs am_lcd_encoder_helper_funcs = {
	.commit = am_lcd_encoder_commit,
	.atomic_mode_set = am_lcd_encoder_mode_set,
	.atomic_enable = am_lcd_encoder_enable,
	.atomic_disable = am_lcd_encoder_disable,
	.atomic_check = am_lcd_encoder_atomic_check,
};

static const struct drm_encoder_funcs am_lcd_encoder_funcs = {
	.destroy        = drm_encoder_cleanup,
};

static int am_lcd_disable(struct drm_panel *panel)
{
	struct am_drm_lcd_s *lcd = drm_plane_to_am_hdmi(panel);

	if (!lcd || !lcd->lcd_drv)
		return -ENODEV;

	mutex_lock(&lcd_power_mutex);
	aml_lcd_notifier_call_chain(LCD_EVENT_DISABLE, (void *)lcd->lcd_drv);
	mutex_unlock(&lcd_power_mutex);

	return 0;
}

static int am_lcd_unprepare(struct drm_panel *panel)
{
	struct am_drm_lcd_s *lcd = drm_plane_to_am_hdmi(panel);

	if (!lcd || !lcd->lcd_drv)
		return -ENODEV;

	mutex_lock(&lcd_power_mutex);
	aml_lcd_notifier_call_chain(LCD_EVENT_UNPREPARE, (void *)lcd->lcd_drv);
	mutex_unlock(&lcd_power_mutex);

	return 0;
}

static int am_lcd_prepare(struct drm_panel *panel)
{
	struct am_drm_lcd_s *lcd = drm_plane_to_am_hdmi(panel);

	if (!lcd || !lcd->lcd_drv)
		return -ENODEV;

	mutex_lock(&lcd_power_mutex);
	aml_lcd_notifier_call_chain(LCD_EVENT_PREPARE, (void *)lcd->lcd_drv);
	mutex_unlock(&lcd_power_mutex);

	return 0;
}

static int am_lcd_enable(struct drm_panel *panel)
{
	struct am_drm_lcd_s *lcd = drm_plane_to_am_hdmi(panel);

	if (!lcd || !lcd->lcd_drv)
		return -ENODEV;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	mutex_lock(&lcd_power_mutex);
	aml_lcd_notifier_call_chain(LCD_EVENT_ENABLE, (void *)lcd->lcd_drv);
	mutex_unlock(&lcd_power_mutex);

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	return 0;
}

static int am_lcd_get_modes(struct drm_panel *panel)
{
	struct am_drm_lcd_s *lcd = drm_plane_to_am_hdmi(panel);
	struct drm_connector *connector = panel->connector;
	struct drm_device *drm = panel->drm;
	struct drm_display_mode *mode;
	struct lcd_config_s *pconf;

	if (!lcd->mode)
		return 0;

	/*ToDo:the below is no use,may delete it!*/
	mode = drm_mode_duplicate(drm, lcd->mode);
	if (!mode)
		return 0;

	mode->type |= DRM_MODE_TYPE_DRIVER;
	mode->type |= DRM_MODE_TYPE_PREFERRED;

	drm_mode_set_name(mode);

	drm_mode_probed_add(connector, mode);

	pconf = &lcd->lcd_drv->config;
	connector->display_info.bpc = pconf->basic.lcd_bits * 3;
	connector->display_info.width_mm = pconf->basic.screen_width;
	connector->display_info.height_mm = pconf->basic.screen_height;

	connector->display_info.bus_flags = DRM_BUS_FLAG_DE_HIGH;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	return 1;
}

static int am_lcd_get_timings(struct drm_panel *panel,
			      unsigned int num_timings,
				    struct display_timing *timings)
{
	struct am_drm_lcd_s *lcd = drm_plane_to_am_hdmi(panel);

	if (!lcd || !lcd->timing)
		return 0;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	if (timings)
		memcpy(&timings[0], lcd->timing, sizeof(struct display_timing));

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	return 1;
}

static const struct drm_panel_funcs am_drm_lcd_funcs = {
	.disable = am_lcd_disable,
	.unprepare = am_lcd_unprepare,
	.prepare = am_lcd_prepare,
	.enable = am_lcd_enable,
	.get_modes = am_lcd_get_modes,
	.get_timings = am_lcd_get_timings,
};

static void am_drm_lcd_connector_tv_mode_init(struct am_drm_lcd_s *lcd)
{
	struct drm_display_mode *native_mode;
	int i;

	if (!lcd->lcd_drv) {
		DRM_DEBUG("invalid lcd driver\n");
		return;
	}

	if (lcd->lcd_drv->mode != LCD_MODE_TV)
		return;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	switch (lcd->lcd_drv->config.basic.v_active) {
	case 600:
		native_mode = &tv_lcd_mode_ref[0];
		break;
	case 768:
		native_mode = &tv_lcd_mode_ref[1];
		break;
	case 1080:
		native_mode = &tv_lcd_mode_ref[2];
		break;
	case 2160:
		native_mode = &tv_lcd_mode_ref[3];
		break;
	default:
		native_mode = &tv_lcd_mode_ref[4];
		DRM_DEBUG("invalid lcd mode\n");
		break;
	}

	lcd_tv_mode_cnt = 0;
	for (i = 0; i < DRM_LCD_TV_MODE_CNT_MAX; i++) {
		memset(&tv_lcd_mode[i], 0, sizeof(struct drm_display_mode));
		sprintf(tv_lcd_mode[i].name, "invalid");
	}
	for (i = 0; i < ARRAY_SIZE(lcd_std_frame_rate); i++) {
		if (strstr(native_mode->name, "invalid"))
			continue;
		if (i >= DRM_LCD_TV_MODE_CNT_MAX)
			break;

		memcpy(&tv_lcd_mode[i], native_mode,
		       sizeof(struct drm_display_mode));
		memset(tv_lcd_mode[i].name, 0, DRM_DISPLAY_MODE_LEN);
		sprintf(tv_lcd_mode[i].name, "%s%dhz",
			native_mode->name, lcd_std_frame_rate[i]);
		tv_lcd_mode[i].vrefresh = lcd_std_frame_rate[i];
		lcd_tv_mode_cnt++;
	}

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

static void am_drm_lcd_display_mode_timing_init(struct am_drm_lcd_s *lcd)
{
	struct lcd_config_s *pconf;
	unsigned int frame_rate;
	unsigned short tmp;
	char *vout_mode;
	int i;

	if (!lcd->lcd_drv) {
		DRM_DEBUG("invalid lcd driver\n");
		return;
	}

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	pconf = &lcd->lcd_drv->config;
	vout_mode = get_vout_mode_internal();

	if (lcd->lcd_drv->mode == LCD_MODE_TV) {
		lcd->mode = NULL;
		frame_rate = pconf->timing.sync_duration_num /
			pconf->timing.sync_duration_den;
		for (i = 0; i < ARRAY_SIZE(lcd_std_frame_rate); i++) {
			if (i >= DRM_LCD_TV_MODE_CNT_MAX)
				break;
			if (frame_rate == lcd_std_frame_rate[i]) {
				lcd->mode = &tv_lcd_mode[i];
				break;
			}
		}
		if (!lcd->mode) {
			lcd->mode = &tv_lcd_mode_ref[4];
			DRM_DEBUG("invalid lcd mode\n");
		}
	} else {
		lcd->mode = &tablet_lcd_mode;
	}
	lcd->timing = &am_lcd_timing;

	if (vout_mode) {
		strncpy(lcd->mode->name, vout_mode, DRM_DISPLAY_MODE_LEN);
		lcd->mode->name[DRM_DISPLAY_MODE_LEN - 1] = 0;
		/*ToDo:change it according to lcd drivers config*/
		if (!strcmp(vout_mode, "panel"))
			lcd->base.connector.connector_type = DRM_MODE_CONNECTOR_DSI;
		else
			lcd->base.connector.connector_type = DRM_MODE_CONNECTOR_LVDS;
	}
	lcd->mode->clock = pconf->timing.lcd_clk / 1000;
	lcd->mode->hdisplay = pconf->basic.h_active;
	tmp = pconf->basic.h_period - pconf->basic.h_active -
			pconf->timing.hsync_bp;
	lcd->mode->hsync_start = pconf->basic.h_active + tmp -
			pconf->timing.hsync_width;
	lcd->mode->hsync_end = pconf->basic.h_active + tmp;
	lcd->mode->htotal = pconf->basic.h_period;
	lcd->mode->vdisplay = pconf->basic.v_active;
	tmp = pconf->basic.v_period - pconf->basic.v_active -
			pconf->timing.vsync_bp;
	lcd->mode->vsync_start = pconf->basic.v_active + tmp -
			pconf->timing.vsync_width;
	lcd->mode->vsync_end = pconf->basic.v_active + tmp;
	lcd->mode->vtotal = pconf->basic.v_period;
	lcd->mode->width_mm = pconf->basic.screen_width;
	lcd->mode->height_mm = pconf->basic.screen_height;
	lcd->mode->vrefresh = pconf->timing.sync_duration_num /
				pconf->timing.sync_duration_den;

	lcd->timing->pixelclock.min = pconf->timing.lcd_clk;
	lcd->timing->pixelclock.typ = pconf->timing.lcd_clk;
	lcd->timing->pixelclock.max = pconf->timing.lcd_clk;
	lcd->timing->hactive.min = pconf->basic.h_active;
	lcd->timing->hactive.typ = pconf->basic.h_active;
	lcd->timing->hactive.max = pconf->basic.h_active;
	tmp = pconf->basic.h_period - pconf->basic.h_active -
		pconf->timing.hsync_bp - pconf->timing.hsync_width;
	lcd->timing->hfront_porch.min = tmp;
	lcd->timing->hfront_porch.typ = tmp;
	lcd->timing->hfront_porch.max = tmp;
	lcd->timing->hback_porch.min = pconf->timing.hsync_bp;
	lcd->timing->hback_porch.typ = pconf->timing.hsync_bp;
	lcd->timing->hback_porch.max = pconf->timing.hsync_bp;
	lcd->timing->hsync_len.min = pconf->timing.hsync_width;
	lcd->timing->hsync_len.typ = pconf->timing.hsync_width;
	lcd->timing->hsync_len.max = pconf->timing.hsync_width;
	lcd->timing->vactive.min = pconf->basic.v_active;
	lcd->timing->vactive.typ = pconf->basic.v_active;
	lcd->timing->vactive.max = pconf->basic.v_active;
	tmp = pconf->basic.v_period - pconf->basic.v_active -
		pconf->timing.vsync_bp - pconf->timing.vsync_width;
	lcd->timing->vfront_porch.min = tmp;
	lcd->timing->vfront_porch.typ = tmp;
	lcd->timing->vfront_porch.max = tmp;
	lcd->timing->vback_porch.min = pconf->timing.vsync_bp;
	lcd->timing->vback_porch.typ = pconf->timing.vsync_bp;
	lcd->timing->vback_porch.max = pconf->timing.vsync_bp;
	lcd->timing->vsync_len.min = pconf->timing.vsync_width;
	lcd->timing->vsync_len.typ = pconf->timing.vsync_width;
	lcd->timing->vsync_len.max = pconf->timing.vsync_width;

	DRM_DEBUG("am_drm_lcd: %s: lcd config:\n"
		"lcd_clk             %d\n"
		"h_active            %d\n"
		"v_active            %d\n"
		"screen_width        %d\n"
		"screen_height       %d\n"
		"sync_duration_den   %d\n"
		"sync_duration_num   %d\n",
		__func__,
		lcd->lcd_drv->config.timing.lcd_clk,
		lcd->lcd_drv->config.basic.h_active,
		lcd->lcd_drv->config.basic.v_active,
		lcd->lcd_drv->config.basic.screen_width,
		lcd->lcd_drv->config.basic.screen_height,
		lcd->lcd_drv->config.timing.sync_duration_den,
		lcd->lcd_drv->config.timing.sync_duration_num);
	DRM_DEBUG("am_drm_lcd: %s: display mode:\n"
		"clock       %d\n"
		"hdisplay    %d\n"
		"vdisplay    %d\n"
		"width_mm    %d\n"
		"height_mm   %d\n"
		"vrefresh    %d\n",
		__func__,
		lcd->mode->clock,
		lcd->mode->hdisplay,
		lcd->mode->vdisplay,
		lcd->mode->width_mm,
		lcd->mode->height_mm,
		lcd->mode->vrefresh);
	DRM_DEBUG("am_drm_lcd: %s: timing:\n"
		"pixelclock   %d\n"
		"hactive      %d\n"
		"vactive      %d\n",
		__func__,
		lcd->timing->pixelclock.typ,
		lcd->timing->hactive.typ,
		lcd->timing->vactive.typ);

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

int am_drm_lcd_notify_callback(struct notifier_block *block, unsigned long cmd,
			       void *para)
{
	am_drm_lcd->lcd_drv = aml_lcd_get_driver(0);
	if (!am_drm_lcd->lcd_drv) {
		DRM_ERROR("invalid lcd driver, exit\n");
		return -ENODEV;
	}

	switch (cmd) {
	case VOUT_EVENT_MODE_CHANGE:
		am_drm_lcd_display_mode_timing_init(am_drm_lcd);
		DRM_DEBUG("%s:event MODE_CHANGE\n", __func__);
		break;
	default:
		break;
	}
	return 0;
}

static struct notifier_block am_drm_lcd_notifier_nb = {
	.notifier_call	= am_drm_lcd_notify_callback,
};

static const struct of_device_id am_meson_lcd_dt_ids[] = {
	{ .compatible = "amlogic, drm-lcd", },
	{},
};

static int am_meson_lcd_bind(struct device *dev, struct device *master,
			     void *data)
{
	struct drm_device *drm = data;
	struct drm_connector *connector;
	struct drm_encoder *encoder;
	int encoder_type, connector_type;
	int ret = 0;

	am_drm_lcd = kzalloc(sizeof(*am_drm_lcd), GFP_KERNEL);
	if (!am_drm_lcd)
		return -ENOMEM;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	am_drm_lcd->lcd_drv = aml_lcd_get_driver(0);
	if (!am_drm_lcd->lcd_drv) {
		pr_err("invalid lcd driver, exit\n");
		return -ENODEV;
	}
	/*
	 * register vout client for timing init,
	 * avoid init with null info when lcd probe with unifykey case.
	 */
	vout_register_client(&am_drm_lcd_notifier_nb);
	am_drm_lcd_connector_tv_mode_init(am_drm_lcd);
	am_drm_lcd_display_mode_timing_init(am_drm_lcd);

	drm_panel_init(&am_drm_lcd->panel);
	am_drm_lcd->panel.dev = NULL;
	am_drm_lcd->panel.funcs = &am_drm_lcd_funcs;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	ret = drm_panel_add(&am_drm_lcd->panel);
	if (ret < 0)
		return ret;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	am_drm_lcd->drm = drm;

	encoder = &am_drm_lcd->encoder;
	connector = &am_drm_lcd->base.connector;
	encoder_type = DRM_MODE_ENCODER_LVDS;
	connector_type = DRM_MODE_CONNECTOR_LVDS;

	/* Encoder */
	drm_encoder_helper_add(encoder, &am_lcd_encoder_helper_funcs);
	ret = drm_encoder_init(drm, encoder, &am_lcd_encoder_funcs,
			       encoder_type, "am_lcd_encoder");
	if (ret) {
		pr_err("error: am_drm_lcd: Failed to init lcd encoder\n");
		return ret;
	}
	DRM_DEBUG("am_drm_lcd: %s %d: encoder possible_crtcs=%d\n",
		__func__, __LINE__, encoder->possible_crtcs);

	/* Connector */
	drm_connector_helper_add(connector, &am_lcd_connector_helper_funcs);
	ret = drm_connector_init(drm, connector, &am_lcd_connector_funcs,
				 connector_type);
	if (ret) {
		pr_err("error: am_drm_lcd: Failed to init lcd connector\n");
		return ret;
	}

	/* force possible_crtcs */
	encoder->possible_crtcs = BIT(0);

	drm_connector_attach_encoder(connector, encoder);

	DRM_DEBUG("am_drm_lcd: register ok\n");

	return ret;
}

static void am_meson_lcd_unbind(struct device *dev, struct device *master,
				void *data)
{
	if (!am_drm_lcd)
		return;

	if (!am_drm_lcd->lcd_drv)
		return;

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);

	drm_panel_detach(&am_drm_lcd->panel);
	drm_panel_remove(&am_drm_lcd->panel);

	DRM_DEBUG("am_drm_lcd: %s %d\n", __func__, __LINE__);
}

static const struct component_ops am_meson_lcd_ops = {
	.bind	= am_meson_lcd_bind,
	.unbind	= am_meson_lcd_unbind,
};

static int am_meson_lcd_probe(struct platform_device *pdev)
{
	return component_add(&pdev->dev, &am_meson_lcd_ops);
}

static int am_meson_lcd_remove(struct platform_device *pdev)
{
	component_del(&pdev->dev, &am_meson_lcd_ops);
	return 0;
}

static struct platform_driver am_meson_lcd_pltfm_driver = {
	.probe  = am_meson_lcd_probe,
	.remove = am_meson_lcd_remove,
	.driver = {
		.name = "meson-lcd",
		.of_match_table = am_meson_lcd_dt_ids,
	},
};

int __init am_meson_lcd_init(void)
{
	return platform_driver_register(&am_meson_lcd_pltfm_driver);
}

void __exit am_meson_lcd_exit(void)
{
	platform_driver_unregister(&am_meson_lcd_pltfm_driver);
}

#ifndef MODULE
module_init(am_meson_lcd_init);
module_exit(am_meson_lcd_exit);
#endif

MODULE_AUTHOR("MultiMedia Amlogic <multimedia-sh@amlogic.com>");
MODULE_DESCRIPTION("Amlogic Meson Drm LCD driver");
MODULE_LICENSE("GPL");