[deliverable/linux.git] / drivers / video / backlight / ams369fg06.c

/*
 * ams369fg06 AMOLED LCD panel driver.
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Author: Jingoo Han  <jg1.han@samsung.com>
 *
 * Derived from drivers/video/s6e63m0.c
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <linux/wait.h>
#include <linux/module.h>
#include <linux/fb.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/spi/spi.h>
#include <linux/lcd.h>
#include <linux/backlight.h>

#define SLEEPMSEC		0x1000
#define ENDDEF			0x2000
#define	DEFMASK			0xFF00
#define COMMAND_ONLY		0xFE
#define DATA_ONLY		0xFF

#define MAX_GAMMA_LEVEL		5
#define GAMMA_TABLE_COUNT	21

#define MIN_BRIGHTNESS		0
#define MAX_BRIGHTNESS		255
#define DEFAULT_BRIGHTNESS	150

struct ams369fg06 {
	struct device			*dev;
	struct spi_device		*spi;
	unsigned int			power;
	struct lcd_device		*ld;
	struct backlight_device		*bd;
	struct lcd_platform_data	*lcd_pd;
};

static const unsigned short seq_display_on[] = {
	0x14, 0x03,
	ENDDEF, 0x0000
};

static const unsigned short seq_display_off[] = {
	0x14, 0x00,
	ENDDEF, 0x0000
};

static const unsigned short seq_stand_by_on[] = {
	0x1D, 0xA1,
	SLEEPMSEC, 200,
	ENDDEF, 0x0000
};

static const unsigned short seq_stand_by_off[] = {
	0x1D, 0xA0,
	SLEEPMSEC, 250,
	ENDDEF, 0x0000
};

static const unsigned short seq_setting[] = {
	0x31, 0x08,
	0x32, 0x14,
	0x30, 0x02,
	0x27, 0x01,
	0x12, 0x08,
	0x13, 0x08,
	0x15, 0x00,
	0x16, 0x00,

	0xef, 0xd0,
	DATA_ONLY, 0xe8,

	0x39, 0x44,
	0x40, 0x00,
	0x41, 0x3f,
	0x42, 0x2a,
	0x43, 0x27,
	0x44, 0x27,
	0x45, 0x1f,
	0x46, 0x44,
	0x50, 0x00,
	0x51, 0x00,
	0x52, 0x17,
	0x53, 0x24,
	0x54, 0x26,
	0x55, 0x1f,
	0x56, 0x43,
	0x60, 0x00,
	0x61, 0x3f,
	0x62, 0x2a,
	0x63, 0x25,
	0x64, 0x24,
	0x65, 0x1b,
	0x66, 0x5c,

	0x17, 0x22,
	0x18, 0x33,
	0x19, 0x03,
	0x1a, 0x01,
	0x22, 0xa4,
	0x23, 0x00,
	0x26, 0xa0,

	0x1d, 0xa0,
	SLEEPMSEC, 300,

	0x14, 0x03,

	ENDDEF, 0x0000
};

/* gamma value: 2.2 */
static const unsigned int ams369fg06_22_250[] = {
	0x00, 0x3f, 0x2a, 0x27, 0x27, 0x1f, 0x44,
	0x00, 0x00, 0x17, 0x24, 0x26, 0x1f, 0x43,
	0x00, 0x3f, 0x2a, 0x25, 0x24, 0x1b, 0x5c,
};

static const unsigned int ams369fg06_22_200[] = {
	0x00, 0x3f, 0x28, 0x29, 0x27, 0x21, 0x3e,
	0x00, 0x00, 0x10, 0x25, 0x27, 0x20, 0x3d,
	0x00, 0x3f, 0x28, 0x27, 0x25, 0x1d, 0x53,
};

static const unsigned int ams369fg06_22_150[] = {
	0x00, 0x3f, 0x2d, 0x29, 0x28, 0x23, 0x37,
	0x00, 0x00, 0x0b, 0x25, 0x28, 0x22, 0x36,
	0x00, 0x3f, 0x2b, 0x28, 0x26, 0x1f, 0x4a,
};

static const unsigned int ams369fg06_22_100[] = {
	0x00, 0x3f, 0x30, 0x2a, 0x2b, 0x24, 0x2f,
	0x00, 0x00, 0x00, 0x25, 0x29, 0x24, 0x2e,
	0x00, 0x3f, 0x2f, 0x29, 0x29, 0x21, 0x3f,
};

static const unsigned int ams369fg06_22_50[] = {
	0x00, 0x3f, 0x3c, 0x2c, 0x2d, 0x27, 0x24,
	0x00, 0x00, 0x00, 0x22, 0x2a, 0x27, 0x23,
	0x00, 0x3f, 0x3b, 0x2c, 0x2b, 0x24, 0x31,
};

struct ams369fg06_gamma {
	unsigned int *gamma_22_table[MAX_GAMMA_LEVEL];
};

static struct ams369fg06_gamma gamma_table = {
	.gamma_22_table[0] = (unsigned int *)&ams369fg06_22_50,
	.gamma_22_table[1] = (unsigned int *)&ams369fg06_22_100,
	.gamma_22_table[2] = (unsigned int *)&ams369fg06_22_150,
	.gamma_22_table[3] = (unsigned int *)&ams369fg06_22_200,
	.gamma_22_table[4] = (unsigned int *)&ams369fg06_22_250,
};

static int ams369fg06_spi_write_byte(struct ams369fg06 *lcd, int addr, int data)
{
	u16 buf[1];
	struct spi_message msg;

	struct spi_transfer xfer = {
		.len		= 2,
		.tx_buf		= buf,
	};

	buf[0] = (addr << 8) | data;

	spi_message_init(&msg);
	spi_message_add_tail(&xfer, &msg);

	return spi_sync(lcd->spi, &msg);
}

static int ams369fg06_spi_write(struct ams369fg06 *lcd, unsigned char address,
	unsigned char command)
{
	int ret = 0;

	if (address != DATA_ONLY)
		ret = ams369fg06_spi_write_byte(lcd, 0x70, address);
	if (command != COMMAND_ONLY)
		ret = ams369fg06_spi_write_byte(lcd, 0x72, command);

	return ret;
}

static int ams369fg06_panel_send_sequence(struct ams369fg06 *lcd,
	const unsigned short *wbuf)
{
	int ret = 0, i = 0;

	while ((wbuf[i] & DEFMASK) != ENDDEF) {
		if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
			ret = ams369fg06_spi_write(lcd, wbuf[i], wbuf[i+1]);
			if (ret)
				break;
		} else
			mdelay(wbuf[i+1]);
		i += 2;
	}

	return ret;
}

static int _ams369fg06_gamma_ctl(struct ams369fg06 *lcd,
	const unsigned int *gamma)
{
	unsigned int i = 0;
	int ret = 0;

	for (i = 0 ; i < GAMMA_TABLE_COUNT / 3; i++) {
		ret = ams369fg06_spi_write(lcd, 0x40 + i, gamma[i]);
		ret = ams369fg06_spi_write(lcd, 0x50 + i, gamma[i+7*1]);
		ret = ams369fg06_spi_write(lcd, 0x60 + i, gamma[i+7*2]);
		if (ret) {
			dev_err(lcd->dev, "failed to set gamma table.\n");
			goto gamma_err;
		}
	}

gamma_err:
	return ret;
}

static int ams369fg06_gamma_ctl(struct ams369fg06 *lcd, int brightness)
{
	int ret = 0;
	int gamma = 0;

	if ((brightness >= 0) && (brightness <= 50))
		gamma = 0;
	else if ((brightness > 50) && (brightness <= 100))
		gamma = 1;
	else if ((brightness > 100) && (brightness <= 150))
		gamma = 2;
	else if ((brightness > 150) && (brightness <= 200))
		gamma = 3;
	else if ((brightness > 200) && (brightness <= 255))
		gamma = 4;

	ret = _ams369fg06_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);

	return ret;
}

static int ams369fg06_ldi_init(struct ams369fg06 *lcd)
{
	int ret, i;
	static const unsigned short *init_seq[] = {
		seq_setting,
		seq_stand_by_off,
	};

	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
		ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
		if (ret)
			break;
	}

	return ret;
}

static int ams369fg06_ldi_enable(struct ams369fg06 *lcd)
{
	int ret, i;
	static const unsigned short *init_seq[] = {
		seq_stand_by_off,
		seq_display_on,
	};

	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
		ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
		if (ret)
			break;
	}

	return ret;
}

static int ams369fg06_ldi_disable(struct ams369fg06 *lcd)
{
	int ret, i;

	static const unsigned short *init_seq[] = {
		seq_display_off,
		seq_stand_by_on,
	};

	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
		ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
		if (ret)
			break;
	}

	return ret;
}

static int ams369fg06_power_is_on(int power)
{
	return ((power) <= FB_BLANK_NORMAL);
}

static int ams369fg06_power_on(struct ams369fg06 *lcd)
{
	int ret = 0;
	struct lcd_platform_data *pd = NULL;
	struct backlight_device *bd = NULL;

	pd = lcd->lcd_pd;
	if (!pd) {
		dev_err(lcd->dev, "platform data is NULL.\n");
		return -EFAULT;
	}

	bd = lcd->bd;
	if (!bd) {
		dev_err(lcd->dev, "backlight device is NULL.\n");
		return -EFAULT;
	}

	if (!pd->power_on) {
		dev_err(lcd->dev, "power_on is NULL.\n");
		return -EFAULT;
	} else {
		pd->power_on(lcd->ld, 1);
		mdelay(pd->power_on_delay);
	}

	if (!pd->reset) {
		dev_err(lcd->dev, "reset is NULL.\n");
		return -EFAULT;
	} else {
		pd->reset(lcd->ld);
		mdelay(pd->reset_delay);
	}

	ret = ams369fg06_ldi_init(lcd);
	if (ret) {
		dev_err(lcd->dev, "failed to initialize ldi.\n");
		return ret;
	}

	ret = ams369fg06_ldi_enable(lcd);
	if (ret) {
		dev_err(lcd->dev, "failed to enable ldi.\n");
		return ret;
	}

	/* set brightness to current value after power on or resume. */
	ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
	if (ret) {
		dev_err(lcd->dev, "lcd gamma setting failed.\n");
		return ret;
	}

	return 0;
}

static int ams369fg06_power_off(struct ams369fg06 *lcd)
{
	int ret = 0;
	struct lcd_platform_data *pd = NULL;

	pd = lcd->lcd_pd;
	if (!pd) {
		dev_err(lcd->dev, "platform data is NULL\n");
		return -EFAULT;
	}

	ret = ams369fg06_ldi_disable(lcd);
	if (ret) {
		dev_err(lcd->dev, "lcd setting failed.\n");
		return -EIO;
	}

	mdelay(pd->power_off_delay);

	if (!pd->power_on) {
		dev_err(lcd->dev, "power_on is NULL.\n");
		return -EFAULT;
	} else
		pd->power_on(lcd->ld, 0);

	return 0;
}

static int ams369fg06_power(struct ams369fg06 *lcd, int power)
{
	int ret = 0;

	if (ams369fg06_power_is_on(power) &&
		!ams369fg06_power_is_on(lcd->power))
		ret = ams369fg06_power_on(lcd);
	else if (!ams369fg06_power_is_on(power) &&
		ams369fg06_power_is_on(lcd->power))
		ret = ams369fg06_power_off(lcd);

	if (!ret)
		lcd->power = power;

	return ret;
}

static int ams369fg06_get_power(struct lcd_device *ld)
{
	struct ams369fg06 *lcd = lcd_get_data(ld);

	return lcd->power;
}

static int ams369fg06_set_power(struct lcd_device *ld, int power)
{
	struct ams369fg06 *lcd = lcd_get_data(ld);

	if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
		power != FB_BLANK_NORMAL) {
		dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
		return -EINVAL;
	}

	return ams369fg06_power(lcd, power);
}

static int ams369fg06_get_brightness(struct backlight_device *bd)
{
	return bd->props.brightness;
}

static int ams369fg06_set_brightness(struct backlight_device *bd)
{
	int ret = 0;
	int brightness = bd->props.brightness;
	struct ams369fg06 *lcd = dev_get_drvdata(&bd->dev);

	if (brightness < MIN_BRIGHTNESS ||
		brightness > bd->props.max_brightness) {
		dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
			MIN_BRIGHTNESS, MAX_BRIGHTNESS);
		return -EINVAL;
	}

	ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
	if (ret) {
		dev_err(&bd->dev, "lcd brightness setting failed.\n");
		return -EIO;
	}

	return ret;
}

static struct lcd_ops ams369fg06_lcd_ops = {
	.get_power = ams369fg06_get_power,
	.set_power = ams369fg06_set_power,
};

static const struct backlight_ops ams369fg06_backlight_ops = {
	.get_brightness = ams369fg06_get_brightness,
	.update_status = ams369fg06_set_brightness,
};

static int __devinit ams369fg06_probe(struct spi_device *spi)
{
	int ret = 0;
	struct ams369fg06 *lcd = NULL;
	struct lcd_device *ld = NULL;
	struct backlight_device *bd = NULL;
	struct backlight_properties props;

	lcd = devm_kzalloc(&spi->dev, sizeof(struct ams369fg06), GFP_KERNEL);
	if (!lcd)
		return -ENOMEM;

	/* ams369fg06 lcd panel uses 3-wire 16bits SPI Mode. */
	spi->bits_per_word = 16;

	ret = spi_setup(spi);
	if (ret < 0) {
		dev_err(&spi->dev, "spi setup failed.\n");
		return ret;
	}

	lcd->spi = spi;
	lcd->dev = &spi->dev;

	lcd->lcd_pd = spi->dev.platform_data;
	if (!lcd->lcd_pd) {
		dev_err(&spi->dev, "platform data is NULL\n");
		return -EFAULT;
	}

	ld = lcd_device_register("ams369fg06", &spi->dev, lcd,
		&ams369fg06_lcd_ops);
	if (IS_ERR(ld))
		return PTR_ERR(ld);

	lcd->ld = ld;

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = MAX_BRIGHTNESS;

	bd = backlight_device_register("ams369fg06-bl", &spi->dev, lcd,
		&ams369fg06_backlight_ops, &props);
	if (IS_ERR(bd)) {
		ret =  PTR_ERR(bd);
		goto out_lcd_unregister;
	}

	bd->props.brightness = DEFAULT_BRIGHTNESS;
	lcd->bd = bd;

	if (!lcd->lcd_pd->lcd_enabled) {
		/*
		 * if lcd panel was off from bootloader then
		 * current lcd status is powerdown and then
		 * it enables lcd panel.
		 */
		lcd->power = FB_BLANK_POWERDOWN;

		ams369fg06_power(lcd, FB_BLANK_UNBLANK);
	} else
		lcd->power = FB_BLANK_UNBLANK;

	dev_set_drvdata(&spi->dev, lcd);

	dev_info(&spi->dev, "ams369fg06 panel driver has been probed.\n");

	return 0;

out_lcd_unregister:
	lcd_device_unregister(ld);
	return ret;
}

static int __devexit ams369fg06_remove(struct spi_device *spi)
{
	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);

	ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
	backlight_device_unregister(lcd->bd);
	lcd_device_unregister(lcd->ld);

	return 0;
}

#if defined(CONFIG_PM)
static unsigned int before_power;

static int ams369fg06_suspend(struct spi_device *spi, pm_message_t mesg)
{
	int ret = 0;
	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);

	dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);

	before_power = lcd->power;

	/*
	 * when lcd panel is suspend, lcd panel becomes off
	 * regardless of status.
	 */
	ret = ams369fg06_power(lcd, FB_BLANK_POWERDOWN);

	return ret;
}

static int ams369fg06_resume(struct spi_device *spi)
{
	int ret = 0;
	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);

	/*
	 * after suspended, if lcd panel status is FB_BLANK_UNBLANK
	 * (at that time, before_power is FB_BLANK_UNBLANK) then
	 * it changes that status to FB_BLANK_POWERDOWN to get lcd on.
	 */
	if (before_power == FB_BLANK_UNBLANK)
		lcd->power = FB_BLANK_POWERDOWN;

	dev_dbg(&spi->dev, "before_power = %d\n", before_power);

	ret = ams369fg06_power(lcd, before_power);

	return ret;
}
#else
#define ams369fg06_suspend	NULL
#define ams369fg06_resume	NULL
#endif

static void ams369fg06_shutdown(struct spi_device *spi)
{
	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);

	ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
}

static struct spi_driver ams369fg06_driver = {
	.driver = {
		.name	= "ams369fg06",
		.owner	= THIS_MODULE,
	},
	.probe		= ams369fg06_probe,
	.remove		= __devexit_p(ams369fg06_remove),
	.shutdown	= ams369fg06_shutdown,
	.suspend	= ams369fg06_suspend,
	.resume		= ams369fg06_resume,
};

module_spi_driver(ams369fg06_driver);

MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
MODULE_DESCRIPTION("ams369fg06 LCD Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
a4c8aaa5 JH	1	/*
	2	* ams369fg06 AMOLED LCD panel driver.
	3	*
	4	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	5	* Author: Jingoo Han <jg1.han@samsung.com>
	6	*
	7	* Derived from drivers/video/s6e63m0.c
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	22	*/
	23
	24	#include <linux/wait.h>
355b200b	25	#include <linux/module.h>
a4c8aaa5 JH	26	#include <linux/fb.h>
	27	#include <linux/delay.h>
	28	#include <linux/gpio.h>
	29	#include <linux/spi/spi.h>
	30	#include <linux/lcd.h>
	31	#include <linux/backlight.h>
	32
	33	#define SLEEPMSEC 0x1000
	34	#define ENDDEF 0x2000
	35	#define DEFMASK 0xFF00
	36	#define COMMAND_ONLY 0xFE
	37	#define DATA_ONLY 0xFF
	38
	39	#define MAX_GAMMA_LEVEL 5
	40	#define GAMMA_TABLE_COUNT 21
	41
	42	#define MIN_BRIGHTNESS 0
	43	#define MAX_BRIGHTNESS 255
	44	#define DEFAULT_BRIGHTNESS 150
	45
	46	struct ams369fg06 {
	47	struct device *dev;
	48	struct spi_device *spi;
	49	unsigned int power;
	50	struct lcd_device *ld;
	51	struct backlight_device *bd;
	52	struct lcd_platform_data *lcd_pd;
	53	};
	54
	55	static const unsigned short seq_display_on[] = {
	56	0x14, 0x03,
	57	ENDDEF, 0x0000
	58	};
	59
	60	static const unsigned short seq_display_off[] = {
	61	0x14, 0x00,
	62	ENDDEF, 0x0000
	63	};
	64
	65	static const unsigned short seq_stand_by_on[] = {
	66	0x1D, 0xA1,
	67	SLEEPMSEC, 200,
	68	ENDDEF, 0x0000
	69	};
	70
	71	static const unsigned short seq_stand_by_off[] = {
	72	0x1D, 0xA0,
	73	SLEEPMSEC, 250,
	74	ENDDEF, 0x0000
	75	};
	76
	77	static const unsigned short seq_setting[] = {
	78	0x31, 0x08,
	79	0x32, 0x14,
	80	0x30, 0x02,
	81	0x27, 0x01,
	82	0x12, 0x08,
	83	0x13, 0x08,
	84	0x15, 0x00,
	85	0x16, 0x00,
	86
	87	0xef, 0xd0,
	88	DATA_ONLY, 0xe8,
	89
90	0x39, 0x44,
91	0x40, 0x00,
92	0x41, 0x3f,
93	0x42, 0x2a,
94	0x43, 0x27,
95	0x44, 0x27,
96	0x45, 0x1f,
97	0x46, 0x44,
98	0x50, 0x00,
99	0x51, 0x00,
100	0x52, 0x17,
101	0x53, 0x24,
102	0x54, 0x26,
103	0x55, 0x1f,
104	0x56, 0x43,
105	0x60, 0x00,
106	0x61, 0x3f,
107	0x62, 0x2a,
108	0x63, 0x25,
109	0x64, 0x24,
110	0x65, 0x1b,
111	0x66, 0x5c,
112
113	0x17, 0x22,
114	0x18, 0x33,
115	0x19, 0x03,
116	0x1a, 0x01,
117	0x22, 0xa4,
118	0x23, 0x00,
119	0x26, 0xa0,
120
121	0x1d, 0xa0,
122	SLEEPMSEC, 300,
123
124	0x14, 0x03,
125
126	ENDDEF, 0x0000
127	};
128
129	/* gamma value: 2.2 */
130	static const unsigned int ams369fg06_22_250[] = {
131	0x00, 0x3f, 0x2a, 0x27, 0x27, 0x1f, 0x44,
132	0x00, 0x00, 0x17, 0x24, 0x26, 0x1f, 0x43,
133	0x00, 0x3f, 0x2a, 0x25, 0x24, 0x1b, 0x5c,
134	};
135
136	static const unsigned int ams369fg06_22_200[] = {
137	0x00, 0x3f, 0x28, 0x29, 0x27, 0x21, 0x3e,
138	0x00, 0x00, 0x10, 0x25, 0x27, 0x20, 0x3d,
139	0x00, 0x3f, 0x28, 0x27, 0x25, 0x1d, 0x53,
140	};
141
142	static const unsigned int ams369fg06_22_150[] = {
143	0x00, 0x3f, 0x2d, 0x29, 0x28, 0x23, 0x37,
144	0x00, 0x00, 0x0b, 0x25, 0x28, 0x22, 0x36,
145	0x00, 0x3f, 0x2b, 0x28, 0x26, 0x1f, 0x4a,
146	};
147
148	static const unsigned int ams369fg06_22_100[] = {
149	0x00, 0x3f, 0x30, 0x2a, 0x2b, 0x24, 0x2f,
150	0x00, 0x00, 0x00, 0x25, 0x29, 0x24, 0x2e,
151	0x00, 0x3f, 0x2f, 0x29, 0x29, 0x21, 0x3f,
152	};
153
154	static const unsigned int ams369fg06_22_50[] = {
155	0x00, 0x3f, 0x3c, 0x2c, 0x2d, 0x27, 0x24,
156	0x00, 0x00, 0x00, 0x22, 0x2a, 0x27, 0x23,
157	0x00, 0x3f, 0x3b, 0x2c, 0x2b, 0x24, 0x31,
158	};
159
160	struct ams369fg06_gamma {
161	unsigned int *gamma_22_table[MAX_GAMMA_LEVEL];
162	};
163
164	static struct ams369fg06_gamma gamma_table = {
165	.gamma_22_table[0] = (unsigned int *)&ams369fg06_22_50,
166	.gamma_22_table[1] = (unsigned int *)&ams369fg06_22_100,
167	.gamma_22_table[2] = (unsigned int *)&ams369fg06_22_150,
168	.gamma_22_table[3] = (unsigned int *)&ams369fg06_22_200,
169	.gamma_22_table[4] = (unsigned int *)&ams369fg06_22_250,
170	};
171
172	static int ams369fg06_spi_write_byte(struct ams369fg06 *lcd, int addr, int data)
173	{
174	u16 buf[1];
175	struct spi_message msg;
176
177	struct spi_transfer xfer = {
178	.len = 2,
179	.tx_buf = buf,
180	};
181
182	buf[0] = (addr << 8) \| data;
183
184	spi_message_init(&msg);
185	spi_message_add_tail(&xfer, &msg);
186
187	return spi_sync(lcd->spi, &msg);
188	}
189
190	static int ams369fg06_spi_write(struct ams369fg06 *lcd, unsigned char address,
191	unsigned char command)
192	{
193	int ret = 0;
194
195	if (address != DATA_ONLY)
196	ret = ams369fg06_spi_write_byte(lcd, 0x70, address);
197	if (command != COMMAND_ONLY)
198	ret = ams369fg06_spi_write_byte(lcd, 0x72, command);
199
200	return ret;
201	}
202
203	static int ams369fg06_panel_send_sequence(struct ams369fg06 *lcd,
204	const unsigned short *wbuf)
205	{
206	int ret = 0, i = 0;
207
208	while ((wbuf[i] & DEFMASK) != ENDDEF) {
209	if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
210	ret = ams369fg06_spi_write(lcd, wbuf[i], wbuf[i+1]);
211	if (ret)
212	break;
213	} else
214	mdelay(wbuf[i+1]);
215	i += 2;
216	}
217
218	return ret;
219	}
220
221	static int _ams369fg06_gamma_ctl(struct ams369fg06 *lcd,
222	const unsigned int *gamma)
223	{
224	unsigned int i = 0;
225	int ret = 0;
226
227	for (i = 0 ; i < GAMMA_TABLE_COUNT / 3; i++) {
228	ret = ams369fg06_spi_write(lcd, 0x40 + i, gamma[i]);
229	ret = ams369fg06_spi_write(lcd, 0x50 + i, gamma[i+7*1]);
230	ret = ams369fg06_spi_write(lcd, 0x60 + i, gamma[i+7*2]);
231	if (ret) {
232	dev_err(lcd->dev, "failed to set gamma table.\n");
233	goto gamma_err;
234	}
235	}
236
237	gamma_err:
238	return ret;
239	}
240
241	static int ams369fg06_gamma_ctl(struct ams369fg06 *lcd, int brightness)
242	{
243	int ret = 0;
244	int gamma = 0;
245
246	if ((brightness >= 0) && (brightness <= 50))
247	gamma = 0;
248	else if ((brightness > 50) && (brightness <= 100))
249	gamma = 1;
250	else if ((brightness > 100) && (brightness <= 150))
251	gamma = 2;
252	else if ((brightness > 150) && (brightness <= 200))
253	gamma = 3;
254	else if ((brightness > 200) && (brightness <= 255))
255	gamma = 4;
256
257	ret = _ams369fg06_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);
258
259	return ret;
260	}
261
262	static int ams369fg06_ldi_init(struct ams369fg06 *lcd)
263	{
264	int ret, i;
265	static const unsigned short *init_seq[] = {
266	seq_setting,
267	seq_stand_by_off,
268	};
269
270	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
271	ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
272	if (ret)
273	break;
274	}
275
276	return ret;
277	}
278
279	static int ams369fg06_ldi_enable(struct ams369fg06 *lcd)
280	{
281	int ret, i;
282	static const unsigned short *init_seq[] = {
283	seq_stand_by_off,
284	seq_display_on,
285	};
286
287	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
288	ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
289	if (ret)
290	break;
291	}
292
293	return ret;
294	}
295
296	static int ams369fg06_ldi_disable(struct ams369fg06 *lcd)
297	{
298	int ret, i;
299
300	static const unsigned short *init_seq[] = {
301	seq_display_off,
302	seq_stand_by_on,
303	};
304
305	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
306	ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
307	if (ret)
308	break;
309	}
310
311	return ret;
312	}
313
314	static int ams369fg06_power_is_on(int power)
315	{
316	return ((power) <= FB_BLANK_NORMAL);
317	}
318
319	static int ams369fg06_power_on(struct ams369fg06 *lcd)
320	{
321	int ret = 0;
322	struct lcd_platform_data *pd = NULL;
323	struct backlight_device *bd = NULL;
324
325	pd = lcd->lcd_pd;
326	if (!pd) {
327	dev_err(lcd->dev, "platform data is NULL.\n");
328	return -EFAULT;
329	}
330
331	bd = lcd->bd;
332	if (!bd) {
333	dev_err(lcd->dev, "backlight device is NULL.\n");
334	return -EFAULT;
335	}
336
337	if (!pd->power_on) {
338	dev_err(lcd->dev, "power_on is NULL.\n");
339	return -EFAULT;
340	} else {
341	pd->power_on(lcd->ld, 1);
342	mdelay(pd->power_on_delay);
343	}
344
345	if (!pd->reset) {
346	dev_err(lcd->dev, "reset is NULL.\n");
347	return -EFAULT;
348	} else {
349	pd->reset(lcd->ld);
350	mdelay(pd->reset_delay);
351	}
352
353	ret = ams369fg06_ldi_init(lcd);
354	if (ret) {
355	dev_err(lcd->dev, "failed to initialize ldi.\n");
356	return ret;
357	}
358
359	ret = ams369fg06_ldi_enable(lcd);
360	if (ret) {
361	dev_err(lcd->dev, "failed to enable ldi.\n");
362	return ret;
363	}
364
365	/* set brightness to current value after power on or resume. */
366	ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
367	if (ret) {
368	dev_err(lcd->dev, "lcd gamma setting failed.\n");
369	return ret;
370	}
371
372	return 0;
373	}
374
375	static int ams369fg06_power_off(struct ams369fg06 *lcd)
376	{
377	int ret = 0;
378	struct lcd_platform_data *pd = NULL;
379
380	pd = lcd->lcd_pd;
381	if (!pd) {
382	dev_err(lcd->dev, "platform data is NULL\n");
383	return -EFAULT;
384	}
385
386	ret = ams369fg06_ldi_disable(lcd);
387	if (ret) {
388	dev_err(lcd->dev, "lcd setting failed.\n");
389	return -EIO;
390	}
391
392	mdelay(pd->power_off_delay);
393
394	if (!pd->power_on) {
395	dev_err(lcd->dev, "power_on is NULL.\n");
396	return -EFAULT;
397	} else
398	pd->power_on(lcd->ld, 0);
399
400	return 0;
401	}
402
403	static int ams369fg06_power(struct ams369fg06 *lcd, int power)
404	{
405	int ret = 0;
406
407	if (ams369fg06_power_is_on(power) &&
408	!ams369fg06_power_is_on(lcd->power))
409	ret = ams369fg06_power_on(lcd);
410	else if (!ams369fg06_power_is_on(power) &&
411	ams369fg06_power_is_on(lcd->power))
412	ret = ams369fg06_power_off(lcd);
413
414	if (!ret)
415	lcd->power = power;
416
417	return ret;
418	}
419
420	static int ams369fg06_get_power(struct lcd_device *ld)
421	{
422	struct ams369fg06 *lcd = lcd_get_data(ld);
423
424	return lcd->power;
425	}
426
427	static int ams369fg06_set_power(struct lcd_device *ld, int power)
428	{
429	struct ams369fg06 *lcd = lcd_get_data(ld);
430
431	if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
432	power != FB_BLANK_NORMAL) {
433	dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
434	return -EINVAL;
435	}
436
437	return ams369fg06_power(lcd, power);
438	}
439
440	static int ams369fg06_get_brightness(struct backlight_device *bd)
441	{
442	return bd->props.brightness;
443	}
444
445	static int ams369fg06_set_brightness(struct backlight_device *bd)
446	{
447	int ret = 0;
448	int brightness = bd->props.brightness;
449	struct ams369fg06 *lcd = dev_get_drvdata(&bd->dev);
450
451	if (brightness < MIN_BRIGHTNESS \|\|
452	brightness > bd->props.max_brightness) {
453	dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
454	MIN_BRIGHTNESS, MAX_BRIGHTNESS);
455	return -EINVAL;
456	}
457
458	ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
459	if (ret) {
460	dev_err(&bd->dev, "lcd brightness setting failed.\n");
461	return -EIO;
462	}
463
464	return ret;
465	}
466
467	static struct lcd_ops ams369fg06_lcd_ops = {
468	.get_power = ams369fg06_get_power,
469	.set_power = ams369fg06_set_power,
470	};
471
472	static const struct backlight_ops ams369fg06_backlight_ops = {
473	.get_brightness = ams369fg06_get_brightness,
474	.update_status = ams369fg06_set_brightness,
475	};
476
477	static int __devinit ams369fg06_probe(struct spi_device *spi)
478	{
479	int ret = 0;
480	struct ams369fg06 *lcd = NULL;
481	struct lcd_device *ld = NULL;
482	struct backlight_device *bd = NULL;
ef22f6a7	483	struct backlight_properties props;
a4c8aaa5	484
80629efc	485	lcd = devm_kzalloc(&spi->dev, sizeof(struct ams369fg06), GFP_KERNEL);
a4c8aaa5 JH	486	if (!lcd)
	487	return -ENOMEM;
	488
	489	/* ams369fg06 lcd panel uses 3-wire 16bits SPI Mode. */
	490	spi->bits_per_word = 16;
	491
	492	ret = spi_setup(spi);
	493	if (ret < 0) {
	494	dev_err(&spi->dev, "spi setup failed.\n");
80629efc	495	return ret;
a4c8aaa5 JH	496	}
	497
	498	lcd->spi = spi;
	499	lcd->dev = &spi->dev;
	500
	501	lcd->lcd_pd = spi->dev.platform_data;
	502	if (!lcd->lcd_pd) {
	503	dev_err(&spi->dev, "platform data is NULL\n");
80629efc	504	return -EFAULT;
a4c8aaa5 JH	505	}
	506
	507	ld = lcd_device_register("ams369fg06", &spi->dev, lcd,
	508	&ams369fg06_lcd_ops);
80629efc JH	509	if (IS_ERR(ld))
80629efc JH	510	return PTR_ERR(ld);
a4c8aaa5 JH	511
	512	lcd->ld = ld;
	513
ef22f6a7 AL	514	memset(&props, 0, sizeof(struct backlight_properties));
	515	props.type = BACKLIGHT_RAW;
	516	props.max_brightness = MAX_BRIGHTNESS;
	517
a4c8aaa5	518	bd = backlight_device_register("ams369fg06-bl", &spi->dev, lcd,
ef22f6a7	519	&ams369fg06_backlight_ops, &props);
a4c8aaa5 JH	520	if (IS_ERR(bd)) {
	521	ret = PTR_ERR(bd);
	522	goto out_lcd_unregister;
	523	}
	524
a4c8aaa5	525	bd->props.brightness = DEFAULT_BRIGHTNESS;
a4c8aaa5 JH	526	lcd->bd = bd;
	527
	528	if (!lcd->lcd_pd->lcd_enabled) {
	529	/*
	530	* if lcd panel was off from bootloader then
	531	* current lcd status is powerdown and then
	532	* it enables lcd panel.
	533	*/
	534	lcd->power = FB_BLANK_POWERDOWN;
	535
	536	ams369fg06_power(lcd, FB_BLANK_UNBLANK);
	537	} else
	538	lcd->power = FB_BLANK_UNBLANK;
	539
	540	dev_set_drvdata(&spi->dev, lcd);
	541
	542	dev_info(&spi->dev, "ams369fg06 panel driver has been probed.\n");
	543
	544	return 0;
	545
	546	out_lcd_unregister:
	547	lcd_device_unregister(ld);
a4c8aaa5 JH	548	return ret;
	549	}
	550
	551	static int __devexit ams369fg06_remove(struct spi_device *spi)
	552	{
	553	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);
	554
	555	ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
	556	backlight_device_unregister(lcd->bd);
	557	lcd_device_unregister(lcd->ld);
a4c8aaa5 JH	558
	559	return 0;
	560	}
	561
	562	#if defined(CONFIG_PM)
	563	static unsigned int before_power;
	564
	565	static int ams369fg06_suspend(struct spi_device *spi, pm_message_t mesg)
	566	{
	567	int ret = 0;
	568	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);
	569
	570	dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
	571
	572	before_power = lcd->power;
	573
	574	/*
	575	* when lcd panel is suspend, lcd panel becomes off
	576	* regardless of status.
	577	*/
	578	ret = ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
	579
	580	return ret;
	581	}
	582
	583	static int ams369fg06_resume(struct spi_device *spi)
	584	{
	585	int ret = 0;
	586	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);
	587
	588	/*
	589	* after suspended, if lcd panel status is FB_BLANK_UNBLANK
	590	* (at that time, before_power is FB_BLANK_UNBLANK) then
	591	* it changes that status to FB_BLANK_POWERDOWN to get lcd on.
	592	*/
	593	if (before_power == FB_BLANK_UNBLANK)
	594	lcd->power = FB_BLANK_POWERDOWN;
	595
	596	dev_dbg(&spi->dev, "before_power = %d\n", before_power);
	597
	598	ret = ams369fg06_power(lcd, before_power);
	599
	600	return ret;
	601	}
	602	#else
	603	#define ams369fg06_suspend NULL
	604	#define ams369fg06_resume NULL
	605	#endif
	606
	607	static void ams369fg06_shutdown(struct spi_device *spi)
	608	{
	609	struct ams369fg06 *lcd = dev_get_drvdata(&spi->dev);
	610
	611	ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
	612	}
	613
	614	static struct spi_driver ams369fg06_driver = {
	615	.driver = {
	616	.name = "ams369fg06",
a4c8aaa5 JH	617	.owner = THIS_MODULE,
	618	},
	619	.probe = ams369fg06_probe,
	620	.remove = __devexit_p(ams369fg06_remove),
	621	.shutdown = ams369fg06_shutdown,
	622	.suspend = ams369fg06_suspend,
	623	.resume = ams369fg06_resume,
	624	};
	625
462dd838	626	module_spi_driver(ams369fg06_driver);
a4c8aaa5 JH	627
	628	MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
	629	MODULE_DESCRIPTION("ams369fg06 LCD Driver");
	630	MODULE_LICENSE("GPL");