// SPDX-License-Identifier: GPL-2.0

#include <linux/delay.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>

#include <linux/gpio/consumer.h>
#include <linux/regulator/consumer.h>

#include <drm/drm_mipi_dsi.h>
#include <drm/drm_modes.h>
#include <drm/drm_of.h>
#include <drm/drm_panel.h>
#include <drm/drm_probe_helper.h>

#include <video/mipi_display.h>

struct ili9488_desc {
	const struct drm_display_mode *display_mode;
	unsigned long mode_flags;
	enum mipi_dsi_pixel_format format;
	unsigned int lanes;
	unsigned int bpc;
	void (*init_sequence)(struct mipi_dsi_multi_context *ctx);
};

struct ili9488 {
	struct drm_panel panel;
	struct mipi_dsi_device *dsi;
	struct gpio_desc *reset;
	struct regulator_bulk_data supplies[2];
	const struct ili9488_desc *desc;
	enum drm_panel_orientation orientation;
};

static const char * const regulator_names[] = {
	"vci",
	"iovcc",
};

static void e35gh_i_mw800cb_init(struct mipi_dsi_multi_context *ctx)
{
	/* Gamma control 1,2 */
	mipi_dsi_dcs_write_seq_multi(ctx, 0xE0, 0x00, 0x10, 0x14, 0x01, 0x0E, 0x04, 0x33,
				     0x56, 0x48, 0x03, 0x0C, 0x0B, 0x2B, 0x34, 0x0F);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xE1, 0x00, 0x12, 0x18, 0x05, 0x12, 0x06, 0x40,
				     0x34, 0x57, 0x06, 0x10, 0x0C, 0x3B, 0x3F, 0x0F);
	/* Power control 1,2 */
	mipi_dsi_dcs_write_seq_multi(ctx, 0xC0, 0x0F, 0x0C);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xC1, 0x41);
	/* VCOM Control */
	mipi_dsi_dcs_write_seq_multi(ctx, 0xC5, 0x00, 0x25, 0x80);
	mipi_dsi_dcs_write_seq_multi(ctx, 0x36, 0x48);
	/* Interface pixel format 18bpp */
	mipi_dsi_dcs_write_seq_multi(ctx, 0x3A, 0x66);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xB0, 0x00);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xB1, 0xA0);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xB4, 0x02);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xB6, 0x02, 0x02, 0x3B);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xE9, 0x00);
	mipi_dsi_dcs_write_seq_multi(ctx, 0xF7, 0xA9, 0x51, 0x2C, 0x82);
	mipi_dsi_dcs_write_seq_multi(ctx, 0x21);
}

static const struct drm_display_mode e35gh_i_mw800cb_display_mode = {
	.clock = 14400,

	.hdisplay = 320,
	.hsync_start = 320 + 60,
	.hsync_end = 320 + 60 + 20,
	.htotal = 320 + 60 + 20 + 42,

	.vdisplay = 480,
	.vsync_start = 480 + 20,
	.vsync_end = 480 + 20 + 10,
	.vtotal = 480 + 20 + 10 + 33,

	.width_mm = 48,
	.height_mm = 73,

	.flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
	.type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
};

static inline struct ili9488 *panel_to_ili9488(struct drm_panel *panel)
{
	return container_of(panel, struct ili9488, panel);
}

static int ili9488_power_on(struct ili9488 *ili)
{
	struct mipi_dsi_device *dsi = ili->dsi;
	int ret;

	ret = regulator_bulk_enable(ARRAY_SIZE(ili->supplies), ili->supplies);
	if (ret < 0) {
		dev_err(&dsi->dev, "regulator bulk enable failed: %d\n", ret);
		return ret;
	}

	gpiod_set_value_cansleep(ili->reset, 0);
	usleep_range(1000, 5000);
	gpiod_set_value_cansleep(ili->reset, 1);
	usleep_range(1000, 5000);
	gpiod_set_value_cansleep(ili->reset, 0);
	usleep_range(5000, 10000);

	return 0;
}

static int ili9488_power_off(struct ili9488 *ili)
{
	struct mipi_dsi_device *dsi = ili->dsi;
	int ret;

	gpiod_set_value_cansleep(ili->reset, 1);

	ret = regulator_bulk_disable(ARRAY_SIZE(ili->supplies), ili->supplies);
	if (ret)
		dev_err(&dsi->dev, "regulator bulk disable failed: %d\n", ret);

	return ret;
}

static int ili9488_activate(struct ili9488 *ili)
{
	struct mipi_dsi_multi_context ctx = { .dsi = ili->dsi };

	if (ili->desc->init_sequence)
		ili->desc->init_sequence(&ctx);

	mipi_dsi_dcs_exit_sleep_mode_multi(&ctx);
	mipi_dsi_msleep(&ctx, 120);
	mipi_dsi_dcs_set_display_on_multi(&ctx);

	return ctx.accum_err;
}

static int ili9488_prepare(struct drm_panel *panel)
{
	struct ili9488 *ili = panel_to_ili9488(panel);
	int ret;

	ret = ili9488_power_on(ili);
	if (ret)
		return ret;

	ret = ili9488_activate(ili);
	if (ret) {
		ili9488_power_off(ili);
		return ret;
	}

	return 0;
}

static int ili9488_deactivate(struct ili9488 *ili)
{
	struct mipi_dsi_multi_context ctx = { .dsi = ili->dsi };

	mipi_dsi_dcs_set_display_off_multi(&ctx);
	mipi_dsi_dcs_enter_sleep_mode_multi(&ctx);
	mipi_dsi_msleep(&ctx, 120);

	return ctx.accum_err;
}

static int ili9488_unprepare(struct drm_panel *panel)
{
	struct ili9488 *ili = panel_to_ili9488(panel);
	struct mipi_dsi_device *dsi = ili->dsi;
	int ret;

	ili9488_deactivate(ili);
	ret = ili9488_power_off(ili);
	if (ret < 0)
		dev_err(&dsi->dev, "power off failed: %d\n", ret);

	return ret;
}

static int ili9488_get_modes(struct drm_panel *panel, struct drm_connector *connector)
{
	struct ili9488 *ili = panel_to_ili9488(panel);
	const struct drm_display_mode *mode = ili->desc->display_mode;

	connector->display_info.bpc = ili->desc->bpc;

	return drm_connector_helper_get_modes_fixed(connector, mode);
}

static enum drm_panel_orientation ili9488_get_orientation(struct drm_panel *panel)
{
	struct ili9488 *ili = panel_to_ili9488(panel);

	return ili->orientation;
}

static const struct drm_panel_funcs ili9488_funcs = {
	.prepare	= ili9488_prepare,
	.unprepare	= ili9488_unprepare,
	.get_modes	= ili9488_get_modes,
	.get_orientation = ili9488_get_orientation,
};

static int ili9488_dsi_probe(struct mipi_dsi_device *dsi)
{
	struct device *dev = &dsi->dev;
	struct ili9488 *ili;
	int i, ret;

	ili = devm_drm_panel_alloc(dev, struct ili9488, panel, &ili9488_funcs,
				   DRM_MODE_CONNECTOR_DSI);
	if (IS_ERR(ili))
		return PTR_ERR(ili);

	ili->desc = device_get_match_data(dev);
	ili->dsi = dsi;

	dsi->mode_flags = ili->desc->mode_flags;
	dsi->format = ili->desc->format;
	dsi->lanes = ili->desc->lanes;

	ili->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
	if (IS_ERR(ili->reset))
		return dev_err_probe(dev, PTR_ERR(ili->reset),
				     "failed to get reset-gpios\n");

	for (i = 0; i < ARRAY_SIZE(ili->supplies); i++)
		ili->supplies[i].supply = regulator_names[i];

	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ili->supplies),
				      ili->supplies);
	if (ret < 0)
		return dev_err_probe(dev, ret, "failed to get regulators\n");

	ret = drm_of_get_panel_orientation(dev->of_node, &ili->orientation);
	if (ret)
		return dev_err_probe(dev, ret, "failed to get orientation\n");

	ret = drm_panel_of_backlight(&ili->panel);
	if (ret)
		return dev_err_probe(dev, ret, "failed to get backlight\n");

	ili->panel.prepare_prev_first = true;

	ret = devm_drm_panel_add(dev, &ili->panel);
	if (ret)
		return ret;

	ret = devm_mipi_dsi_attach(dev, dsi);
	if (ret < 0)
		return dev_err_probe(dev, ret, "failed to attach to DSI host\n");

	return 0;
}

static const struct ili9488_desc e35gh_i_mw800cb_desc = {
	.init_sequence = e35gh_i_mw800cb_init,
	.display_mode = &e35gh_i_mw800cb_display_mode,
	.mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE |
		      MIPI_DSI_MODE_LPM | MIPI_DSI_CLOCK_NON_CONTINUOUS,
	.format = MIPI_DSI_FMT_RGB666_PACKED,
	.lanes = 1,
	.bpc = 6,
};

static const struct of_device_id ili9488_of_match[] = {
	{ .compatible = "focuslcds,e35gh-i-mw800cb", .data = &e35gh_i_mw800cb_desc },
	{ }
};

MODULE_DEVICE_TABLE(of, ili9488_of_match);

static struct mipi_dsi_driver ili9488_dsi_driver = {
	.probe	= ili9488_dsi_probe,
	.driver = {
		.name		= "ili9488-dsi",
		.of_match_table	= ili9488_of_match,
	},
};
module_mipi_dsi_driver(ili9488_dsi_driver);

MODULE_AUTHOR("Igor Reznichenko <igor@reznichenko.net>");
MODULE_DESCRIPTION("Ilitek ILI9488 Controller Driver");
MODULE_LICENSE("GPL");