[u-boot.git] / drivers / video / lg4573.c

// SPDX-License-Identifier: GPL-2.0
/*
 * LCD: LG4573, TFT 4.3", 480x800, RGB24
 * LCD initialization via SPI
 *
 */
#include <common.h>
#include <backlight.h>
#include <command.h>
#include <display.h>
#include <dm.h>
#include <dm/read.h>
#include <dm/uclass-internal.h>
#include <errno.h>
#include <spi.h>
#include <asm/gpio.h>

#define PWR_ON_DELAY_MSECS  120

static int lb043wv_spi_write_u16(struct spi_slave *slave, u16 val)
{
	unsigned short buf16 = htons(val);
	int ret = 0;

	ret = spi_xfer(slave, 16, &buf16, NULL,
		       SPI_XFER_BEGIN | SPI_XFER_END);
	if (ret)
		debug("%s: Failed to send: %d\n", __func__, ret);

	return ret;
}

static void lb043wv_spi_write_u16_array(struct spi_slave *slave, u16 *buff,
					int size)
{
	int i;

	for (i = 0; i < size; i++)
		lb043wv_spi_write_u16(slave, buff[i]);
}

static void lb043wv_display_mode_settings(struct spi_slave *slave)
{
	static u16 display_mode_settings[] = {
	  0x703A,
	  0x7270,
	  0x70B1,
	  0x7208,
	  0x723B,
	  0x720F,
	  0x70B2,
	  0x7200,
	  0x72C8,
	  0x70B3,
	  0x7200,
	  0x70B4,
	  0x7200,
	  0x70B5,
	  0x7242,
	  0x7210,
	  0x7210,
	  0x7200,
	  0x7220,
	  0x70B6,
	  0x720B,
	  0x720F,
	  0x723C,
	  0x7213,
	  0x7213,
	  0x72E8,
	  0x70B7,
	  0x7246,
	  0x7206,
	  0x720C,
	  0x7200,
	  0x7200,
	};

	debug("transfer display mode settings\n");
	lb043wv_spi_write_u16_array(slave, display_mode_settings,
				    ARRAY_SIZE(display_mode_settings));
}

static void lb043wv_power_settings(struct spi_slave *slave)
{
	static u16 power_settings[] = {
	  0x70C0,
	  0x7201,
	  0x7211,
	  0x70C3,
	  0x7207,
	  0x7203,
	  0x7204,
	  0x7204,
	  0x7204,
	  0x70C4,
	  0x7212,
	  0x7224,
	  0x7218,
	  0x7218,
	  0x7202,
	  0x7249,
	  0x70C5,
	  0x726F,
	  0x70C6,
	  0x7241,
	  0x7263,
	};

	debug("transfer power settings\n");
	lb043wv_spi_write_u16_array(slave, power_settings,
				    ARRAY_SIZE(power_settings));
}

static void lb043wv_gamma_settings(struct spi_slave *slave)
{
	static u16 gamma_settings[] = {
	  0x70D0,
	  0x7203,
	  0x7207,
	  0x7273,
	  0x7235,
	  0x7200,
	  0x7201,
	  0x7220,
	  0x7200,
	  0x7203,
	  0x70D1,
	  0x7203,
	  0x7207,
	  0x7273,
	  0x7235,
	  0x7200,
	  0x7201,
	  0x7220,
	  0x7200,
	  0x7203,
	  0x70D2,
	  0x7203,
	  0x7207,
	  0x7273,
	  0x7235,
	  0x7200,
	  0x7201,
	  0x7220,
	  0x7200,
	  0x7203,
	  0x70D3,
	  0x7203,
	  0x7207,
	  0x7273,
	  0x7235,
	  0x7200,
	  0x7201,
	  0x7220,
	  0x7200,
	  0x7203,
	  0x70D4,
	  0x7203,
	  0x7207,
	  0x7273,
	  0x7235,
	  0x7200,
	  0x7201,
	  0x7220,
	  0x7200,
	  0x7203,
	  0x70D5,
	  0x7203,
	  0x7207,
	  0x7273,
	  0x7235,
	  0x7200,
	  0x7201,
	  0x7220,
	  0x7200,
	  0x7203,
	};

	debug("transfer gamma settings\n");
	lb043wv_spi_write_u16_array(slave, gamma_settings,
				    ARRAY_SIZE(gamma_settings));
}

static void lb043wv_display_on(struct spi_slave *slave)
{
	static u16 sleep_out = 0x7011;
	static u16 display_on = 0x7029;

	lb043wv_spi_write_u16(slave, sleep_out);
	mdelay(PWR_ON_DELAY_MSECS);
	lb043wv_spi_write_u16(slave, display_on);
}

static int lg4573_spi_startup(struct spi_slave *slave)
{
	int ret;

	ret = spi_claim_bus(slave);
	if (ret)
		return ret;

	lb043wv_display_mode_settings(slave);
	lb043wv_power_settings(slave);
	lb043wv_gamma_settings(slave);
	lb043wv_display_on(slave);

	spi_release_bus(slave);
	return 0;
}

static int do_lgset(struct cmd_tbl *cmdtp, int flag, int argc,
		    char *const argv[])
{
	struct spi_slave *slave;
	struct udevice *dev;
	int ret;

	ret = uclass_get_device_by_driver(UCLASS_DISPLAY,
					  DM_GET_DRIVER(lg4573_lcd), &dev);
	if (ret) {
		printf("%s: Could not get lg4573 device\n", __func__);
		return ret;
	}
	slave = dev_get_parent_priv(dev);
	if (!slave) {
		printf("%s: No slave data\n", __func__);
		return -ENODEV;
	}
	lg4573_spi_startup(slave);

	return 0;
}

U_BOOT_CMD(
	lgset,	2,	1,	do_lgset,
	"set lgdisplay",
	""
);

static int lg4573_bind(struct udevice *dev)
{
	return 0;
}

static int lg4573_probe(struct udevice *dev)
{
	return 0;
}

static const struct udevice_id lg4573_ids[] = {
	{ .compatible = "lg,lg4573" },
	{ }
};

struct lg4573_lcd_priv {
	struct display_timing timing;
	struct udevice *backlight;
	struct gpio_desc enable;
	int panel_bpp;
	u32 power_on_delay;
};

static int lg4573_lcd_read_timing(struct udevice *dev,
				  struct display_timing *timing)
{
	struct lg4573_lcd_priv *priv = dev_get_priv(dev);

	memcpy(timing, &priv->timing, sizeof(struct display_timing));

	return 0;
}

static int lg4573_lcd_enable(struct udevice *dev, int bpp,
			     const struct display_timing *edid)
{
	struct spi_slave *slave = dev_get_parent_priv(dev);
	struct lg4573_lcd_priv *priv = dev_get_priv(dev);
	int ret = 0;

	dm_gpio_set_value(&priv->enable, 1);
	ret = backlight_enable(priv->backlight);

	mdelay(priv->power_on_delay);
	lg4573_spi_startup(slave);

	return ret;
};

static const struct dm_display_ops lg4573_lcd_ops = {
	.read_timing = lg4573_lcd_read_timing,
	.enable = lg4573_lcd_enable,
};

static int lg4573_ofdata_to_platdata(struct udevice *dev)
{
	struct lg4573_lcd_priv *priv = dev_get_priv(dev);
	int ret;

	ret = uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
					   "backlight", &priv->backlight);
	if (ret) {
		debug("%s: Cannot get backlight: ret=%d\n", __func__, ret);
		return log_ret(ret);
	}
	ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
				   GPIOD_IS_OUT);
	if (ret) {
		debug("%s: Warning: cannot get enable GPIO: ret=%d\n",
		      __func__, ret);
		if (ret != -ENOENT)
			return log_ret(ret);
	}

	priv->power_on_delay = dev_read_u32_default(dev, "power-on-delay", 10);

	return 0;
}

U_BOOT_DRIVER(lg4573_lcd) = {
	.name   = "lg4573",
	.id     = UCLASS_DISPLAY,
	.ops    = &lg4573_lcd_ops,
	.ofdata_to_platdata	= lg4573_ofdata_to_platdata,
	.of_match = lg4573_ids,
	.bind   = lg4573_bind,
	.probe  = lg4573_probe,
	.priv_auto_alloc_size = sizeof(struct lg4573_lcd_priv),
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0
fc1a79d9 HS	2	/*
	3	* LCD: LG4573, TFT 4.3", 480x800, RGB24
	4	* LCD initialization via SPI
	5	*
fc1a79d9 HS	6	*/
fc1a79d9 HS	7	#include <common.h>
79db1b46	8	#include <backlight.h>
09140113	9	#include <command.h>
79db1b46 HS	10	#include <display.h>
	11	#include <dm.h>
	12	#include <dm/read.h>
	13	#include <dm/uclass-internal.h>
fc1a79d9 HS	14	#include <errno.h>
fc1a79d9 HS	15	#include <spi.h>
79db1b46	16	#include <asm/gpio.h>
fc1a79d9 HS	17
	18	#define PWR_ON_DELAY_MSECS 120
	19
79db1b46	20	static int lb043wv_spi_write_u16(struct spi_slave *slave, u16 val)
fc1a79d9	21	{
fc1a79d9 HS	22	unsigned short buf16 = htons(val);
	23	int ret = 0;
	24
79db1b46 HS	25	ret = spi_xfer(slave, 16, &buf16, NULL,
79db1b46 HS	26	SPI_XFER_BEGIN \| SPI_XFER_END);
fc1a79d9 HS	27	if (ret)
	28	debug("%s: Failed to send: %d\n", __func__, ret);
	29
	30	return ret;
	31	}
	32
79db1b46	33	static void lb043wv_spi_write_u16_array(struct spi_slave slave, u16 buff,
fc1a79d9 HS	34	int size)
	35	{
	36	int i;
	37
	38	for (i = 0; i < size; i++)
79db1b46	39	lb043wv_spi_write_u16(slave, buff[i]);
fc1a79d9 HS	40	}
fc1a79d9 HS	41
79db1b46	42	static void lb043wv_display_mode_settings(struct spi_slave *slave)
fc1a79d9 HS	43	{
	44	static u16 display_mode_settings[] = {
	45	0x703A,
	46	0x7270,
	47	0x70B1,
	48	0x7208,
	49	0x723B,
	50	0x720F,
	51	0x70B2,
	52	0x7200,
	53	0x72C8,
	54	0x70B3,
	55	0x7200,
	56	0x70B4,
	57	0x7200,
	58	0x70B5,
	59	0x7242,
	60	0x7210,
	61	0x7210,
	62	0x7200,
	63	0x7220,
	64	0x70B6,
	65	0x720B,
	66	0x720F,
	67	0x723C,
	68	0x7213,
	69	0x7213,
	70	0x72E8,
	71	0x70B7,
	72	0x7246,
	73	0x7206,
	74	0x720C,
	75	0x7200,
	76	0x7200,
	77	};
	78
	79	debug("transfer display mode settings\n");
79db1b46	80	lb043wv_spi_write_u16_array(slave, display_mode_settings,
fc1a79d9 HS	81	ARRAY_SIZE(display_mode_settings));
	82	}
	83
79db1b46	84	static void lb043wv_power_settings(struct spi_slave *slave)
fc1a79d9 HS	85	{
	86	static u16 power_settings[] = {
	87	0x70C0,
	88	0x7201,
	89	0x7211,
	90	0x70C3,
	91	0x7207,
	92	0x7203,
	93	0x7204,
	94	0x7204,
	95	0x7204,
	96	0x70C4,
	97	0x7212,
	98	0x7224,
	99	0x7218,
	100	0x7218,
	101	0x7202,
	102	0x7249,
	103	0x70C5,
	104	0x726F,
	105	0x70C6,
	106	0x7241,
	107	0x7263,
	108	};
	109
	110	debug("transfer power settings\n");
79db1b46	111	lb043wv_spi_write_u16_array(slave, power_settings,
fc1a79d9 HS	112	ARRAY_SIZE(power_settings));
	113	}
	114
79db1b46	115	static void lb043wv_gamma_settings(struct spi_slave *slave)
fc1a79d9 HS	116	{
	117	static u16 gamma_settings[] = {
	118	0x70D0,
	119	0x7203,
	120	0x7207,
	121	0x7273,
	122	0x7235,
	123	0x7200,
	124	0x7201,
	125	0x7220,
	126	0x7200,
	127	0x7203,
	128	0x70D1,
	129	0x7203,
	130	0x7207,
	131	0x7273,
	132	0x7235,
	133	0x7200,
	134	0x7201,
	135	0x7220,
	136	0x7200,
	137	0x7203,
	138	0x70D2,
	139	0x7203,
	140	0x7207,
	141	0x7273,
	142	0x7235,
	143	0x7200,
	144	0x7201,
	145	0x7220,
	146	0x7200,
	147	0x7203,
	148	0x70D3,
	149	0x7203,
	150	0x7207,
	151	0x7273,
	152	0x7235,
	153	0x7200,
	154	0x7201,
	155	0x7220,
	156	0x7200,
	157	0x7203,
	158	0x70D4,
	159	0x7203,
	160	0x7207,
	161	0x7273,
	162	0x7235,
	163	0x7200,
	164	0x7201,
	165	0x7220,
	166	0x7200,
	167	0x7203,
	168	0x70D5,
	169	0x7203,
	170	0x7207,
	171	0x7273,
	172	0x7235,
	173	0x7200,
	174	0x7201,
	175	0x7220,
	176	0x7200,
	177	0x7203,
	178	};
	179
180	debug("transfer gamma settings\n");
79db1b46	181	lb043wv_spi_write_u16_array(slave, gamma_settings,
fc1a79d9 HS	182	ARRAY_SIZE(gamma_settings));
	183	}
	184
79db1b46	185	static void lb043wv_display_on(struct spi_slave *slave)
fc1a79d9 HS	186	{
	187	static u16 sleep_out = 0x7011;
	188	static u16 display_on = 0x7029;
	189
79db1b46	190	lb043wv_spi_write_u16(slave, sleep_out);
fc1a79d9	191	mdelay(PWR_ON_DELAY_MSECS);
79db1b46	192	lb043wv_spi_write_u16(slave, display_on);
fc1a79d9 HS	193	}
fc1a79d9 HS	194
79db1b46	195	static int lg4573_spi_startup(struct spi_slave *slave)
fc1a79d9	196	{
fc1a79d9 HS	197	int ret;
fc1a79d9 HS	198
79db1b46 HS	199	ret = spi_claim_bus(slave);
	200	if (ret)
	201	return ret;
fc1a79d9	202
79db1b46 HS	203	lb043wv_display_mode_settings(slave);
	204	lb043wv_power_settings(slave);
	205	lb043wv_gamma_settings(slave);
	206	lb043wv_display_on(slave);
fc1a79d9	207
79db1b46	208	spi_release_bus(slave);
fc1a79d9	209	return 0;
fc1a79d9 HS	210	}
fc1a79d9 HS	211
09140113 SG	212	static int do_lgset(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	213	char *const argv[])
fc1a79d9	214	{
79db1b46 HS	215	struct spi_slave *slave;
	216	struct udevice *dev;
	217	int ret;
	218
	219	ret = uclass_get_device_by_driver(UCLASS_DISPLAY,
	220	DM_GET_DRIVER(lg4573_lcd), &dev);
	221	if (ret) {
	222	printf("%s: Could not get lg4573 device\n", __func__);
	223	return ret;
	224	}
	225	slave = dev_get_parent_priv(dev);
	226	if (!slave) {
	227	printf("%s: No slave data\n", __func__);
	228	return -ENODEV;
	229	}
	230	lg4573_spi_startup(slave);
	231
fc1a79d9 HS	232	return 0;
	233	}
	234
	235	U_BOOT_CMD(
	236	lgset, 2, 1, do_lgset,
	237	"set lgdisplay",
	238	""
	239	);
79db1b46 HS	240
	241	static int lg4573_bind(struct udevice *dev)
	242	{
	243	return 0;
	244	}
	245
	246	static int lg4573_probe(struct udevice *dev)
	247	{
	248	return 0;
	249	}
	250
	251	static const struct udevice_id lg4573_ids[] = {
	252	{ .compatible = "lg,lg4573" },
	253	{ }
	254	};
	255
	256	struct lg4573_lcd_priv {
	257	struct display_timing timing;
	258	struct udevice *backlight;
	259	struct gpio_desc enable;
	260	int panel_bpp;
	261	u32 power_on_delay;
	262	};
	263
	264	static int lg4573_lcd_read_timing(struct udevice *dev,
	265	struct display_timing *timing)
	266	{
	267	struct lg4573_lcd_priv *priv = dev_get_priv(dev);
	268
	269	memcpy(timing, &priv->timing, sizeof(struct display_timing));
	270
	271	return 0;
	272	}
	273
	274	static int lg4573_lcd_enable(struct udevice *dev, int bpp,
	275	const struct display_timing *edid)
	276	{
	277	struct spi_slave *slave = dev_get_parent_priv(dev);
	278	struct lg4573_lcd_priv *priv = dev_get_priv(dev);
	279	int ret = 0;
	280
	281	dm_gpio_set_value(&priv->enable, 1);
	282	ret = backlight_enable(priv->backlight);
	283
	284	mdelay(priv->power_on_delay);
	285	lg4573_spi_startup(slave);
	286
	287	return ret;
	288	};
	289
	290	static const struct dm_display_ops lg4573_lcd_ops = {
	291	.read_timing = lg4573_lcd_read_timing,
	292	.enable = lg4573_lcd_enable,
	293	};
	294
	295	static int lg4573_ofdata_to_platdata(struct udevice *dev)
	296	{
	297	struct lg4573_lcd_priv *priv = dev_get_priv(dev);
	298	int ret;
	299
	300	ret = uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
	301	"backlight", &priv->backlight);
	302	if (ret) {
	303	debug("%s: Cannot get backlight: ret=%d\n", __func__, ret);
304	return log_ret(ret);
305	}
306	ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
307	GPIOD_IS_OUT);
308	if (ret) {
309	debug("%s: Warning: cannot get enable GPIO: ret=%d\n",
310	__func__, ret);
311	if (ret != -ENOENT)
312	return log_ret(ret);
313	}
314
315	priv->power_on_delay = dev_read_u32_default(dev, "power-on-delay", 10);
316
317	return 0;
318	}
319
320	U_BOOT_DRIVER(lg4573_lcd) = {
321	.name = "lg4573",
322	.id = UCLASS_DISPLAY,
323	.ops = &lg4573_lcd_ops,
324	.ofdata_to_platdata = lg4573_ofdata_to_platdata,
325	.of_match = lg4573_ids,
326	.bind = lg4573_bind,
327	.probe = lg4573_probe,
328	.priv_auto_alloc_size = sizeof(struct lg4573_lcd_priv),
329	};