luckfox-pico-sdk/sysdrv/source/uboot/u-boot/drivers/video/drm/panel-maxim-deserializer.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2022 Rockchip Electronics Co., Ltd
 */

#include <config.h>
#include <common.h>
#include <backlight.h>
#include <errno.h>
#include <malloc.h>
#include <video.h>

#include <asm/gpio.h>
#include <dm/device.h>
#include <dm/read.h>
#include <dm/pinctrl.h>
#include <dm/uclass-id.h>
#include <linux/media-bus-format.h>

#include "rockchip_display.h"
#include "rockchip_panel.h"

struct maxim_deserializer_panel;

struct maxim_deserializer_panel_desc {
	const char *name;
	u16 id;
	struct drm_display_mode mode;
	u32 width_mm;
	u32 height_mm;

	struct {
		const char *name;
		u8 addr;
		u8 dev_id;
	} deserializer;

	void (*prepare)(struct maxim_deserializer_panel *p);
	void (*unprepare)(struct maxim_deserializer_panel *p);
	void (*enable)(struct maxim_deserializer_panel *p);
	void (*disable)(struct maxim_deserializer_panel *p);
};

struct maxim_deserializer_panel {
	struct udevice *dev;
	struct udevice *backlight;
	struct gpio_desc enable_gpio;

	/* the panel desc as detected */
	const struct maxim_deserializer_panel_desc *desc;
};

static void maxim_max96752f_panel_prepare(struct maxim_deserializer_panel *p)
{
	pinctrl_select_state(p->dev, p->desc->name ?
			     p->desc->name : p->desc->deserializer.name);

	dm_i2c_reg_write(p->dev, 0x0002, 0x43);
	dm_i2c_reg_write(p->dev, 0x0140, 0x20);

	dm_i2c_reg_write(p->dev, 0x01ce, 0x5e);	/* oldi */
	dm_i2c_reg_write(p->dev, 0x020c, 0x84);	/* bl_pwm */
	dm_i2c_reg_write(p->dev, 0x0206, 0x83);	/* tp_int */

	dm_i2c_reg_write(p->dev, 0x0215, 0x90);	/* lcd_en */
	mdelay(20);
}

static void maxim_max96752f_panel_unprepare(struct maxim_deserializer_panel *p)
{
	dm_i2c_reg_write(p->dev, 0x0215, 0x80);	/* lcd_en */
}

static void maxim_max96752f_panel_enable(struct maxim_deserializer_panel *p)
{
	dm_i2c_reg_write(p->dev, 0x0227, 0x90);	/* lcd_rst */
	mdelay(20);
	dm_i2c_reg_write(p->dev, 0x020f, 0x90);	/* tp_rst */
	mdelay(100);
	dm_i2c_reg_write(p->dev, 0x0221, 0x90);	/* lcd_stb */
	mdelay(60);
	dm_i2c_reg_write(p->dev, 0x0212, 0x90);	/* bl_current_ctl */
	dm_i2c_reg_write(p->dev, 0x0209, 0x90);	/* bl_en */
}

static void maxim_max96752f_panel_disable(struct maxim_deserializer_panel *p)
{
	dm_i2c_reg_write(p->dev, 0x0209, 0x80);	/* bl_en */
	dm_i2c_reg_write(p->dev, 0x0212, 0x80); /* bl_current_ctl */
	dm_i2c_reg_write(p->dev, 0x0221, 0x80);	/* lcd_stb */
	dm_i2c_reg_write(p->dev, 0x020f, 0x80);	/* tp_rst */
	dm_i2c_reg_write(p->dev, 0x0227, 0x80);	/* lcd_rst */
}

static const struct maxim_deserializer_panel_desc maxim_deserializer_default_panels[] = {
	{
		.deserializer = {
			.name = "max96752f",
			.addr = 0x48,
			.dev_id = 0x82,
		},

		.mode = {
			.clock = 148500,
			.hdisplay = 1920,
			.hsync_start = 1920 + 20,
			.hsync_end = 1920 + 20 + 20,
			.htotal = 1920 + 20 + 20 + 20,
			.vdisplay = 1080,
			.vsync_start = 1080 + 250,
			.vsync_end = 1080 + 250 + 2,
			.vtotal = 1080 + 250 + 2 + 8,
			.flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
		},

		.prepare = maxim_max96752f_panel_prepare,
		.enable = maxim_max96752f_panel_enable,
		.disable = maxim_max96752f_panel_disable,
		.unprepare = maxim_max96752f_panel_unprepare,
	},
};

static void maxim_deserializer_panel_prepare(struct rockchip_panel *panel)
{
	struct maxim_deserializer_panel *p = dev_get_priv(panel->dev);

	if (!p->desc)
		return;

	if (p->desc->prepare)
		p->desc->prepare(p);
}

static void maxim_deserializer_panel_unprepare(struct rockchip_panel *panel)
{
	struct maxim_deserializer_panel *p = dev_get_priv(panel->dev);

	if (!p->desc)
		return;

	if (p->desc->unprepare)
		p->desc->unprepare(p);
}

static void maxim_deserializer_panel_enable(struct rockchip_panel *panel)
{
	struct maxim_deserializer_panel *p = dev_get_priv(panel->dev);

	if (!p->desc)
		return;

	if (p->desc->enable)
		p->desc->enable(p);

	if (p->backlight)
		backlight_enable(p->backlight);
}

static void maxim_deserializer_panel_disable(struct rockchip_panel *panel)
{
	struct maxim_deserializer_panel *p = dev_get_priv(panel->dev);

	if (!p->desc)
		return;

	if (p->backlight)
		backlight_disable(p->backlight);

	if (p->desc->disable)
		p->desc->disable(p);
}

static u16 maxim_deserializer_panel_get_id(struct maxim_deserializer_panel *p)
{
	/* TODO */
	return 0;
}

static int maxim_deserializer_panel_detect(struct maxim_deserializer_panel *p)
{
	const struct maxim_deserializer_panel_desc *desc = NULL;
	struct udevice *dev = p->dev;
	struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
	u16 id = maxim_deserializer_panel_get_id(p);
	unsigned int i, ret;

	if (id) {
		/* TODO */
	} else {
		u8 dev_id;

		for (i = 0; i < ARRAY_SIZE(maxim_deserializer_default_panels); i++) {
			chip->chip_addr = maxim_deserializer_default_panels[i].deserializer.addr;

			ret = dm_i2c_reg_read(dev, 0x000d);
			if (ret < 0)
				continue;

			dev_id = ret;

			if (maxim_deserializer_default_panels[i].deserializer.dev_id == dev_id) {
				desc = &maxim_deserializer_default_panels[i];
				break;
			}
		}
	}

	if (!desc)
		return -ENODEV;

	p->desc = desc;
	chip->chip_addr = desc->deserializer.addr;

	return 0;
}

static int maxim_deserializer_panel_get_mode(struct rockchip_panel *panel,
					     struct drm_display_mode *mode)
{
	struct maxim_deserializer_panel *p = dev_get_priv(panel->dev);
	int ret;

	ret = maxim_deserializer_panel_detect(p);
	if (ret)
		return ret;

	memcpy(mode, &p->desc->mode, sizeof(struct drm_display_mode));
	mode->vrefresh = drm_mode_vrefresh(mode);

	return 0;
}

static const struct rockchip_panel_funcs maxim_deserializer_panel_funcs = {
	.prepare = maxim_deserializer_panel_prepare,
	.unprepare = maxim_deserializer_panel_unprepare,
	.enable = maxim_deserializer_panel_enable,
	.disable = maxim_deserializer_panel_disable,
	.get_mode = maxim_deserializer_panel_get_mode,
};

static void maxim_deserializer_panel_power_on(struct maxim_deserializer_panel *p)
{
	if (dm_gpio_is_valid(&p->enable_gpio)) {
		dm_gpio_set_value(&p->enable_gpio, 1);
		mdelay(500);
	}
}

static int maxim_deserializer_panel_probe(struct udevice *dev)
{
	struct maxim_deserializer_panel *p = dev_get_priv(dev);
	struct rockchip_panel *panel;
	int ret;

	ret = i2c_set_chip_offset_len(dev, 2);
	if (ret)
		return ret;

	p->dev = dev;

	ret = uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
					   "backlight", &p->backlight);
	if (ret && ret != -ENOENT) {
		dev_err(dev, "%s: Cannot get backlight: %d\n", __func__, ret);
		return ret;
	}

	ret = gpio_request_by_name(dev, "enable-gpios", 0,
				   &p->enable_gpio, GPIOD_IS_OUT);
	if (ret && ret != -ENOENT) {
		dev_err(dev, "%s: Cannot get enable GPIO: %d\n", __func__, ret);
		return ret;
	}

	maxim_deserializer_panel_power_on(p);

	panel = calloc(1, sizeof(*panel));
	if (!panel)
		return -ENOMEM;

	dev->driver_data = (ulong)panel;
	panel->dev = dev;
	panel->bus_format = MEDIA_BUS_FMT_RGB888_1X24;
	panel->funcs = &maxim_deserializer_panel_funcs;

	return 0;
}

static const struct udevice_id maxim_deserializer_panel_of_match[] = {
	{ .compatible = "maxim,deserializer-panel", },
	{}
};

U_BOOT_DRIVER(maxim_deserializer_panel) = {
	.name = "maxim_deserializer_panel",
	.id = UCLASS_PANEL,
	.of_match = maxim_deserializer_panel_of_match,
	.probe = maxim_deserializer_panel_probe,
	.priv_auto_alloc_size = sizeof(struct maxim_deserializer_panel),
};