[mirror_ubuntu-focal-kernel.git] / drivers / video / backlight / l4f00242t03.c

/*
 * l4f00242t03.c -- support for Epson L4F00242T03 LCD
 *
 * Copyright 2007-2009 Freescale Semiconductor, Inc. All Rights Reserved.
 *
 * Copyright (c) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
 * 	Inspired by Marek Vasut work in l4f00242t03.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/lcd.h>
#include <linux/slab.h>
#include <linux/regulator/consumer.h>

#include <linux/spi/spi.h>
#include <linux/spi/l4f00242t03.h>

struct l4f00242t03_priv {
	struct spi_device	*spi;
	struct lcd_device	*ld;
	int lcd_state;
	struct regulator *io_reg;
	struct regulator *core_reg;
};


static void l4f00242t03_reset(unsigned int gpio)
{
	pr_debug("l4f00242t03_reset.\n");
	gpio_set_value(gpio, 1);
	mdelay(100);
	gpio_set_value(gpio, 0);
	mdelay(10);	/* tRES >= 100us */
	gpio_set_value(gpio, 1);
	mdelay(20);
}

#define param(x) ((x) | 0x100)

static void l4f00242t03_lcd_init(struct spi_device *spi)
{
	struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
	const u16 cmd[] = { 0x36, param(0), 0x3A, param(0x60) };

	dev_dbg(&spi->dev, "initializing LCD\n");

	if (priv->io_reg) {
		regulator_set_voltage(priv->io_reg, 1800000, 1800000);
		regulator_enable(priv->io_reg);
	}

	if (priv->core_reg) {
		regulator_set_voltage(priv->core_reg, 2800000, 2800000);
		regulator_enable(priv->core_reg);
	}

	l4f00242t03_reset(pdata->reset_gpio);

	gpio_set_value(pdata->data_enable_gpio, 1);
	msleep(60);
	spi_write(spi, (const u8 *)cmd, ARRAY_SIZE(cmd) * sizeof(u16));
}

static void l4f00242t03_lcd_powerdown(struct spi_device *spi)
{
	struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);

	dev_dbg(&spi->dev, "Powering down LCD\n");

	gpio_set_value(pdata->data_enable_gpio, 0);

	if (priv->io_reg)
		regulator_disable(priv->io_reg);

	if (priv->core_reg)
		regulator_disable(priv->core_reg);
}

static int l4f00242t03_lcd_power_get(struct lcd_device *ld)
{
	struct l4f00242t03_priv *priv = lcd_get_data(ld);

	return priv->lcd_state;
}

static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
{
	struct l4f00242t03_priv *priv = lcd_get_data(ld);
	struct spi_device *spi = priv->spi;

	const u16 slpout = 0x11;
	const u16 dison = 0x29;

	const u16 slpin = 0x10;
	const u16 disoff = 0x28;

	if (power <= FB_BLANK_NORMAL) {
		if (priv->lcd_state <= FB_BLANK_NORMAL) {
			/* Do nothing, the LCD is running */
		} else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
			dev_dbg(&spi->dev, "Resuming LCD\n");

			spi_write(spi, (const u8 *)&slpout, sizeof(u16));
			msleep(60);
			spi_write(spi, (const u8 *)&dison, sizeof(u16));
		} else {
			/* priv->lcd_state == FB_BLANK_POWERDOWN */
			l4f00242t03_lcd_init(spi);
			priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
			l4f00242t03_lcd_power_set(priv->ld, power);
		}
	} else if (power < FB_BLANK_POWERDOWN) {
		if (priv->lcd_state <= FB_BLANK_NORMAL) {
			/* Send the display in standby */
			dev_dbg(&spi->dev, "Standby the LCD\n");

			spi_write(spi, (const u8 *)&disoff, sizeof(u16));
			msleep(60);
			spi_write(spi, (const u8 *)&slpin, sizeof(u16));
		} else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
			/* Do nothing, the LCD is already in standby */
		} else {
			/* priv->lcd_state == FB_BLANK_POWERDOWN */
			l4f00242t03_lcd_init(spi);
			priv->lcd_state = FB_BLANK_UNBLANK;
			l4f00242t03_lcd_power_set(ld, power);
		}
	} else {
		/* power == FB_BLANK_POWERDOWN */
		if (priv->lcd_state != FB_BLANK_POWERDOWN) {
			/* Clear the screen before shutting down */
			spi_write(spi, (const u8 *)&disoff, sizeof(u16));
			msleep(60);
			l4f00242t03_lcd_powerdown(spi);
		}
	}

	priv->lcd_state = power;

	return 0;
}

static struct lcd_ops l4f_ops = {
	.set_power	= l4f00242t03_lcd_power_set,
	.get_power	= l4f00242t03_lcd_power_get,
};

static int __devinit l4f00242t03_probe(struct spi_device *spi)
{
	struct l4f00242t03_priv *priv;
	struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
	int ret;

	if (pdata == NULL) {
		dev_err(&spi->dev, "Uninitialized platform data.\n");
		return -EINVAL;
	}

	priv = kzalloc(sizeof(struct l4f00242t03_priv), GFP_KERNEL);

	if (priv == NULL) {
		dev_err(&spi->dev, "No memory for this device.\n");
		return -ENOMEM;
	}

	dev_set_drvdata(&spi->dev, priv);
	spi->bits_per_word = 9;
	spi_setup(spi);

	priv->spi = spi;

	ret = gpio_request(pdata->reset_gpio, "lcd l4f00242t03 reset");
	if (ret) {
		dev_err(&spi->dev,
			"Unable to get the lcd l4f00242t03 reset gpio.\n");
		goto err;
	}

	ret = gpio_direction_output(pdata->reset_gpio, 1);
	if (ret)
		goto err2;

	ret = gpio_request(pdata->data_enable_gpio,
				"lcd l4f00242t03 data enable");
	if (ret) {
		dev_err(&spi->dev,
			"Unable to get the lcd l4f00242t03 data en gpio.\n");
		goto err2;
	}

	ret = gpio_direction_output(pdata->data_enable_gpio, 0);
	if (ret)
		goto err3;

	if (pdata->io_supply) {
		priv->io_reg = regulator_get(NULL, pdata->io_supply);

		if (IS_ERR(priv->io_reg)) {
			pr_err("%s: Unable to get the IO regulator\n",
								__func__);
			goto err3;
		}
	}

	if (pdata->core_supply) {
		priv->core_reg = regulator_get(NULL, pdata->core_supply);

		if (IS_ERR(priv->core_reg)) {
			pr_err("%s: Unable to get the core regulator\n",
								__func__);
			goto err4;
		}
	}

	priv->ld = lcd_device_register("l4f00242t03",
					&spi->dev, priv, &l4f_ops);
	if (IS_ERR(priv->ld)) {
		ret = PTR_ERR(priv->ld);
		goto err5;
	}

	/* Init the LCD */
	l4f00242t03_lcd_init(spi);
	priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
	l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_UNBLANK);

	dev_info(&spi->dev, "Epson l4f00242t03 lcd probed.\n");

	return 0;

err5:
	if (priv->core_reg)
		regulator_put(priv->core_reg);
err4:
	if (priv->io_reg)
		regulator_put(priv->io_reg);
err3:
	gpio_free(pdata->data_enable_gpio);
err2:
	gpio_free(pdata->reset_gpio);
err:
	kfree(priv);

	return ret;
}

static int __devexit l4f00242t03_remove(struct spi_device *spi)
{
	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
	struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;

	l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
	lcd_device_unregister(priv->ld);

	dev_set_drvdata(&spi->dev, NULL);

	gpio_free(pdata->data_enable_gpio);
	gpio_free(pdata->reset_gpio);

	if (priv->io_reg)
		regulator_put(priv->io_reg);
	if (priv->core_reg)
		regulator_put(priv->core_reg);

	kfree(priv);

	return 0;
}

static void l4f00242t03_shutdown(struct spi_device *spi)
{
	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);

	if (priv)
		l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);

}

static struct spi_driver l4f00242t03_driver = {
	.driver = {
		.name	= "l4f00242t03",
		.owner	= THIS_MODULE,
	},
	.probe		= l4f00242t03_probe,
	.remove		= __devexit_p(l4f00242t03_remove),
	.shutdown	= l4f00242t03_shutdown,
};

static __init int l4f00242t03_init(void)
{
	return spi_register_driver(&l4f00242t03_driver);
}

static __exit void l4f00242t03_exit(void)
{
	spi_unregister_driver(&l4f00242t03_driver);
}

module_init(l4f00242t03_init);
module_exit(l4f00242t03_exit);

MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
MODULE_DESCRIPTION("EPSON L4F00242T03 LCD");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
e7fb9c4a AP	1	/*
	2	* l4f00242t03.c -- support for Epson L4F00242T03 LCD
	3	*
	4	* Copyright 2007-2009 Freescale Semiconductor, Inc. All Rights Reserved.
	5	*
	6	* Copyright (c) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
	7	* Inspired by Marek Vasut work in l4f00242t03.c
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13
	14	#include <linux/device.h>
	15	#include <linux/kernel.h>
	16	#include <linux/delay.h>
	17	#include <linux/gpio.h>
	18	#include <linux/lcd.h>
5a0e3ad6	19	#include <linux/slab.h>
e7fb9c4a AP	20	#include <linux/regulator/consumer.h>
	21
	22	#include <linux/spi/spi.h>
	23	#include <linux/spi/l4f00242t03.h>
	24
	25	struct l4f00242t03_priv {
	26	struct spi_device *spi;
	27	struct lcd_device *ld;
95558ad1	28	int lcd_state;
e7fb9c4a AP	29	struct regulator *io_reg;
	30	struct regulator *core_reg;
	31	};
	32
	33
	34	static void l4f00242t03_reset(unsigned int gpio)
	35	{
	36	pr_debug("l4f00242t03_reset.\n");
	37	gpio_set_value(gpio, 1);
	38	mdelay(100);
	39	gpio_set_value(gpio, 0);
	40	mdelay(10); /* tRES >= 100us */
	41	gpio_set_value(gpio, 1);
	42	mdelay(20);
	43	}
	44
	45	#define param(x) ((x) \| 0x100)
	46
	47	static void l4f00242t03_lcd_init(struct spi_device *spi)
	48	{
	49	struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
	50	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
	51	const u16 cmd[] = { 0x36, param(0), 0x3A, param(0x60) };
	52
	53	dev_dbg(&spi->dev, "initializing LCD\n");
	54
	55	if (priv->io_reg) {
	56	regulator_set_voltage(priv->io_reg, 1800000, 1800000);
	57	regulator_enable(priv->io_reg);
	58	}
	59
	60	if (priv->core_reg) {
	61	regulator_set_voltage(priv->core_reg, 2800000, 2800000);
	62	regulator_enable(priv->core_reg);
	63	}
	64
aff5ce6c AP	65	l4f00242t03_reset(pdata->reset_gpio);
aff5ce6c AP	66
e7fb9c4a AP	67	gpio_set_value(pdata->data_enable_gpio, 1);
	68	msleep(60);
	69	spi_write(spi, (const u8 )cmd, ARRAY_SIZE(cmd) sizeof(u16));
	70	}
	71
95558ad1 AP	72	static void l4f00242t03_lcd_powerdown(struct spi_device *spi)
	73	{
	74	struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
	75	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
	76
	77	dev_dbg(&spi->dev, "Powering down LCD\n");
	78
	79	gpio_set_value(pdata->data_enable_gpio, 0);
	80
	81	if (priv->io_reg)
	82	regulator_disable(priv->io_reg);
	83
	84	if (priv->core_reg)
	85	regulator_disable(priv->core_reg);
	86	}
	87
	88	static int l4f00242t03_lcd_power_get(struct lcd_device *ld)
	89	{
	90	struct l4f00242t03_priv *priv = lcd_get_data(ld);
	91
	92	return priv->lcd_state;
	93	}
	94
e7fb9c4a AP	95	static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
	96	{
	97	struct l4f00242t03_priv *priv = lcd_get_data(ld);
	98	struct spi_device *spi = priv->spi;
	99
	100	const u16 slpout = 0x11;
	101	const u16 dison = 0x29;
	102
	103	const u16 slpin = 0x10;
	104	const u16 disoff = 0x28;
	105
4dbdf886	106	if (power <= FB_BLANK_NORMAL) {
95558ad1 AP	107	if (priv->lcd_state <= FB_BLANK_NORMAL) {
	108	/* Do nothing, the LCD is running */
	109	} else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
	110	dev_dbg(&spi->dev, "Resuming LCD\n");
	111
	112	spi_write(spi, (const u8 *)&slpout, sizeof(u16));
	113	msleep(60);
	114	spi_write(spi, (const u8 *)&dison, sizeof(u16));
	115	} else {
	116	/* priv->lcd_state == FB_BLANK_POWERDOWN */
	117	l4f00242t03_lcd_init(spi);
	118	priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
	119	l4f00242t03_lcd_power_set(priv->ld, power);
	120	}
	121	} else if (power < FB_BLANK_POWERDOWN) {
	122	if (priv->lcd_state <= FB_BLANK_NORMAL) {
	123	/* Send the display in standby */
	124	dev_dbg(&spi->dev, "Standby the LCD\n");
	125
	126	spi_write(spi, (const u8 *)&disoff, sizeof(u16));
	127	msleep(60);
	128	spi_write(spi, (const u8 *)&slpin, sizeof(u16));
	129	} else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
	130	/* Do nothing, the LCD is already in standby */
	131	} else {
	132	/* priv->lcd_state == FB_BLANK_POWERDOWN */
	133	l4f00242t03_lcd_init(spi);
	134	priv->lcd_state = FB_BLANK_UNBLANK;
	135	l4f00242t03_lcd_power_set(ld, power);
	136	}
e7fb9c4a	137	} else {
95558ad1	138	/* power == FB_BLANK_POWERDOWN */
26bbabc8 AP	139	if (priv->lcd_state != FB_BLANK_POWERDOWN) {
	140	/* Clear the screen before shutting down */
	141	spi_write(spi, (const u8 *)&disoff, sizeof(u16));
	142	msleep(60);
	143	l4f00242t03_lcd_powerdown(spi);
	144	}
e7fb9c4a AP	145	}
e7fb9c4a AP	146
95558ad1 AP	147	priv->lcd_state = power;
95558ad1 AP	148
e7fb9c4a AP	149	return 0;
	150	}
	151
	152	static struct lcd_ops l4f_ops = {
	153	.set_power = l4f00242t03_lcd_power_set,
95558ad1	154	.get_power = l4f00242t03_lcd_power_get,
e7fb9c4a AP	155	};
	156
	157	static int __devinit l4f00242t03_probe(struct spi_device *spi)
	158	{
	159	struct l4f00242t03_priv *priv;
	160	struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
	161	int ret;
	162
	163	if (pdata == NULL) {
	164	dev_err(&spi->dev, "Uninitialized platform data.\n");
	165	return -EINVAL;
	166	}
	167
	168	priv = kzalloc(sizeof(struct l4f00242t03_priv), GFP_KERNEL);
	169
	170	if (priv == NULL) {
	171	dev_err(&spi->dev, "No memory for this device.\n");
beb0a43f	172	return -ENOMEM;
e7fb9c4a AP	173	}
	174
	175	dev_set_drvdata(&spi->dev, priv);
	176	spi->bits_per_word = 9;
	177	spi_setup(spi);
	178
	179	priv->spi = spi;
	180
	181	ret = gpio_request(pdata->reset_gpio, "lcd l4f00242t03 reset");
	182	if (ret) {
	183	dev_err(&spi->dev,
	184	"Unable to get the lcd l4f00242t03 reset gpio.\n");
beb0a43f	185	goto err;
e7fb9c4a AP	186	}
	187
	188	ret = gpio_direction_output(pdata->reset_gpio, 1);
	189	if (ret)
	190	goto err2;
	191
	192	ret = gpio_request(pdata->data_enable_gpio,
	193	"lcd l4f00242t03 data enable");
	194	if (ret) {
	195	dev_err(&spi->dev,
	196	"Unable to get the lcd l4f00242t03 data en gpio.\n");
beb0a43f	197	goto err2;
e7fb9c4a AP	198	}
	199
	200	ret = gpio_direction_output(pdata->data_enable_gpio, 0);
	201	if (ret)
	202	goto err3;
	203
	204	if (pdata->io_supply) {
	205	priv->io_reg = regulator_get(NULL, pdata->io_supply);
	206
	207	if (IS_ERR(priv->io_reg)) {
	208	pr_err("%s: Unable to get the IO regulator\n",
	209	__func__);
	210	goto err3;
	211	}
	212	}
	213
	214	if (pdata->core_supply) {
	215	priv->core_reg = regulator_get(NULL, pdata->core_supply);
	216
	217	if (IS_ERR(priv->core_reg)) {
	218	pr_err("%s: Unable to get the core regulator\n",
	219	__func__);
	220	goto err4;
	221	}
	222	}
	223
	224	priv->ld = lcd_device_register("l4f00242t03",
	225	&spi->dev, priv, &l4f_ops);
	226	if (IS_ERR(priv->ld)) {
	227	ret = PTR_ERR(priv->ld);
	228	goto err5;
	229	}
	230
	231	/* Init the LCD */
e7fb9c4a	232	l4f00242t03_lcd_init(spi);
95558ad1 AP	233	priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
95558ad1 AP	234	l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_UNBLANK);
e7fb9c4a AP	235
	236	dev_info(&spi->dev, "Epson l4f00242t03 lcd probed.\n");
	237
	238	return 0;
	239
	240	err5:
	241	if (priv->core_reg)
	242	regulator_put(priv->core_reg);
	243	err4:
	244	if (priv->io_reg)
	245	regulator_put(priv->io_reg);
	246	err3:
	247	gpio_free(pdata->data_enable_gpio);
	248	err2:
	249	gpio_free(pdata->reset_gpio);
	250	err:
	251	kfree(priv);
	252
	253	return ret;
	254	}
	255
	256	static int __devexit l4f00242t03_remove(struct spi_device *spi)
	257	{
	258	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
	259	struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;
	260
95558ad1	261	l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
e7fb9c4a AP	262	lcd_device_unregister(priv->ld);
e7fb9c4a AP	263
95558ad1 AP	264	dev_set_drvdata(&spi->dev, NULL);
95558ad1 AP	265
e7fb9c4a AP	266	gpio_free(pdata->data_enable_gpio);
	267	gpio_free(pdata->reset_gpio);
	268
	269	if (priv->io_reg)
e7fb9c4a	270	regulator_put(priv->io_reg);
47306fc3 AP	271	if (priv->core_reg)
47306fc3 AP	272	regulator_put(priv->core_reg);
e7fb9c4a AP	273
	274	kfree(priv);
	275
	276	return 0;
	277	}
	278
95558ad1 AP	279	static void l4f00242t03_shutdown(struct spi_device *spi)
	280	{
	281	struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
	282
	283	if (priv)
	284	l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
	285
	286	}
	287
e7fb9c4a AP	288	static struct spi_driver l4f00242t03_driver = {
	289	.driver = {
	290	.name = "l4f00242t03",
	291	.owner = THIS_MODULE,
	292	},
	293	.probe = l4f00242t03_probe,
	294	.remove = __devexit_p(l4f00242t03_remove),
95558ad1	295	.shutdown = l4f00242t03_shutdown,
e7fb9c4a AP	296	};
	297
	298	static __init int l4f00242t03_init(void)
	299	{
	300	return spi_register_driver(&l4f00242t03_driver);
	301	}
	302
	303	static __exit void l4f00242t03_exit(void)
	304	{
	305	spi_unregister_driver(&l4f00242t03_driver);
	306	}
	307
	308	module_init(l4f00242t03_init);
	309	module_exit(l4f00242t03_exit);
	310
	311	MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
	312	MODULE_DESCRIPTION("EPSON L4F00242T03 LCD");
c3cf2e44	313	MODULE_LICENSE("GPL v2");