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