[linux-block.git] / drivers / video / fbdev / omap / lcd_mipid.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * LCD driver for MIPI DBI-C / DCS compatible LCDs
 *
 * Copyright (C) 2006 Nokia Corporation
 * Author: Imre Deak <imre.deak@nokia.com>
 */
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/spi/spi.h>
#include <linux/module.h>

#include <linux/platform_data/lcd-mipid.h>

#include "omapfb.h"

#define MIPID_MODULE_NAME		"lcd_mipid"

#define MIPID_CMD_READ_DISP_ID		0x04
#define MIPID_CMD_READ_RED		0x06
#define MIPID_CMD_READ_GREEN		0x07
#define MIPID_CMD_READ_BLUE		0x08
#define MIPID_CMD_READ_DISP_STATUS	0x09
#define MIPID_CMD_RDDSDR		0x0F
#define MIPID_CMD_SLEEP_IN		0x10
#define MIPID_CMD_SLEEP_OUT		0x11
#define MIPID_CMD_DISP_OFF		0x28
#define MIPID_CMD_DISP_ON		0x29

#define MIPID_ESD_CHECK_PERIOD		msecs_to_jiffies(5000)

#define to_mipid_device(p)		container_of(p, struct mipid_device, \
						panel)
struct mipid_device {
	int		enabled;
	int		revision;
	unsigned int	saved_bklight_level;
	unsigned long	hw_guard_end;		/* next value of jiffies
						   when we can issue the
						   next sleep in/out command */
	unsigned long	hw_guard_wait;		/* max guard time in jiffies */

	struct omapfb_device	*fbdev;
	struct spi_device	*spi;
	struct mutex		mutex;
	struct lcd_panel	panel;

	struct delayed_work	esd_work;
	void			(*esd_check)(struct mipid_device *m);
};

static void mipid_transfer(struct mipid_device *md, int cmd, const u8 *wbuf,
			   int wlen, u8 *rbuf, int rlen)
{
	struct spi_message	m;
	struct spi_transfer	*x, xfer[4];
	u16			w;
	int			r;

	BUG_ON(md->spi == NULL);

	spi_message_init(&m);

	memset(xfer, 0, sizeof(xfer));
	x = &xfer[0];

	cmd &=  0xff;
	x->tx_buf		= &cmd;
	x->bits_per_word	= 9;
	x->len			= 2;
	spi_message_add_tail(x, &m);

	if (wlen) {
		x++;
		x->tx_buf		= wbuf;
		x->len			= wlen;
		x->bits_per_word	= 9;
		spi_message_add_tail(x, &m);
	}

	if (rlen) {
		x++;
		x->rx_buf	= &w;
		x->len		= 1;
		spi_message_add_tail(x, &m);

		if (rlen > 1) {
			/* Arrange for the extra clock before the first
			 * data bit.
			 */
			x->bits_per_word = 9;
			x->len		 = 2;

			x++;
			x->rx_buf	 = &rbuf[1];
			x->len		 = rlen - 1;
			spi_message_add_tail(x, &m);
		}
	}

	r = spi_sync(md->spi, &m);
	if (r < 0)
		dev_dbg(&md->spi->dev, "spi_sync %d\n", r);

	if (rlen)
		rbuf[0] = w & 0xff;
}

static inline void mipid_cmd(struct mipid_device *md, int cmd)
{
	mipid_transfer(md, cmd, NULL, 0, NULL, 0);
}

static inline void mipid_write(struct mipid_device *md,
			       int reg, const u8 *buf, int len)
{
	mipid_transfer(md, reg, buf, len, NULL, 0);
}

static inline void mipid_read(struct mipid_device *md,
			      int reg, u8 *buf, int len)
{
	mipid_transfer(md, reg, NULL, 0, buf, len);
}

static void set_data_lines(struct mipid_device *md, int data_lines)
{
	u16 par;

	switch (data_lines) {
	case 16:
		par = 0x150;
		break;
	case 18:
		par = 0x160;
		break;
	case 24:
		par = 0x170;
		break;
	}
	mipid_write(md, 0x3a, (u8 *)&par, 2);
}

static void send_init_string(struct mipid_device *md)
{
	u16 initpar[] = { 0x0102, 0x0100, 0x0100 };

	mipid_write(md, 0xc2, (u8 *)initpar, sizeof(initpar));
	set_data_lines(md, md->panel.data_lines);
}

static void hw_guard_start(struct mipid_device *md, int guard_msec)
{
	md->hw_guard_wait = msecs_to_jiffies(guard_msec);
	md->hw_guard_end = jiffies + md->hw_guard_wait;
}

static void hw_guard_wait(struct mipid_device *md)
{
	unsigned long wait = md->hw_guard_end - jiffies;

	if ((long)wait > 0 && time_before_eq(wait,  md->hw_guard_wait)) {
		set_current_state(TASK_UNINTERRUPTIBLE);
		schedule_timeout(wait);
	}
}

static void set_sleep_mode(struct mipid_device *md, int on)
{
	int cmd, sleep_time = 50;

	if (on)
		cmd = MIPID_CMD_SLEEP_IN;
	else
		cmd = MIPID_CMD_SLEEP_OUT;
	hw_guard_wait(md);
	mipid_cmd(md, cmd);
	hw_guard_start(md, 120);
	/*
	 * When we enable the panel, it seems we _have_ to sleep
	 * 120 ms before sending the init string. When disabling the
	 * panel we'll sleep for the duration of 2 frames, so that the
	 * controller can still provide the PCLK,HS,VS signals.
	 */
	if (!on)
		sleep_time = 120;
	msleep(sleep_time);
}

static void set_display_state(struct mipid_device *md, int enabled)
{
	int cmd = enabled ? MIPID_CMD_DISP_ON : MIPID_CMD_DISP_OFF;

	mipid_cmd(md, cmd);
}

static int mipid_set_bklight_level(struct lcd_panel *panel, unsigned int level)
{
	struct mipid_device *md = to_mipid_device(panel);
	struct mipid_platform_data *pd = md->spi->dev.platform_data;

	if (pd->get_bklight_max == NULL || pd->set_bklight_level == NULL)
		return -ENODEV;
	if (level > pd->get_bklight_max(pd))
		return -EINVAL;
	if (!md->enabled) {
		md->saved_bklight_level = level;
		return 0;
	}
	pd->set_bklight_level(pd, level);

	return 0;
}

static unsigned int mipid_get_bklight_level(struct lcd_panel *panel)
{
	struct mipid_device *md = to_mipid_device(panel);
	struct mipid_platform_data *pd = md->spi->dev.platform_data;

	if (pd->get_bklight_level == NULL)
		return -ENODEV;
	return pd->get_bklight_level(pd);
}

static unsigned int mipid_get_bklight_max(struct lcd_panel *panel)
{
	struct mipid_device *md = to_mipid_device(panel);
	struct mipid_platform_data *pd = md->spi->dev.platform_data;

	if (pd->get_bklight_max == NULL)
		return -ENODEV;

	return pd->get_bklight_max(pd);
}

static unsigned long mipid_get_caps(struct lcd_panel *panel)
{
	return OMAPFB_CAPS_SET_BACKLIGHT;
}

static u16 read_first_pixel(struct mipid_device *md)
{
	u16 pixel;
	u8 red, green, blue;

	mutex_lock(&md->mutex);
	mipid_read(md, MIPID_CMD_READ_RED, &red, 1);
	mipid_read(md, MIPID_CMD_READ_GREEN, &green, 1);
	mipid_read(md, MIPID_CMD_READ_BLUE, &blue, 1);
	mutex_unlock(&md->mutex);

	switch (md->panel.data_lines) {
	case 16:
		pixel = ((red >> 1) << 11) | (green << 5) | (blue >> 1);
		break;
	case 24:
		/* 24 bit -> 16 bit */
		pixel = ((red >> 3) << 11) | ((green >> 2) << 5) |
			(blue >> 3);
		break;
	default:
		pixel = 0;
		BUG();
	}

	return pixel;
}

static int mipid_run_test(struct lcd_panel *panel, int test_num)
{
	struct mipid_device *md = to_mipid_device(panel);
	static const u16 test_values[4] = {
		0x0000, 0xffff, 0xaaaa, 0x5555,
	};
	int i;

	if (test_num != MIPID_TEST_RGB_LINES)
		return MIPID_TEST_INVALID;

	for (i = 0; i < ARRAY_SIZE(test_values); i++) {
		int delay;
		unsigned long tmo;

		omapfb_write_first_pixel(md->fbdev, test_values[i]);
		tmo = jiffies + msecs_to_jiffies(100);
		delay = 25;
		while (1) {
			u16 pixel;

			msleep(delay);
			pixel = read_first_pixel(md);
			if (pixel == test_values[i])
				break;
			if (time_after(jiffies, tmo)) {
				dev_err(&md->spi->dev,
					"MIPI LCD RGB I/F test failed: "
					"expecting %04x, got %04x\n",
					test_values[i], pixel);
				return MIPID_TEST_FAILED;
			}
			delay = 10;
		}
	}

	return 0;
}

static void ls041y3_esd_recover(struct mipid_device *md)
{
	dev_err(&md->spi->dev, "performing LCD ESD recovery\n");
	set_sleep_mode(md, 1);
	set_sleep_mode(md, 0);
}

static void ls041y3_esd_check_mode1(struct mipid_device *md)
{
	u8 state1, state2;

	mipid_read(md, MIPID_CMD_RDDSDR, &state1, 1);
	set_sleep_mode(md, 0);
	mipid_read(md, MIPID_CMD_RDDSDR, &state2, 1);
	dev_dbg(&md->spi->dev, "ESD mode 1 state1 %02x state2 %02x\n",
		state1, state2);
	/* Each sleep out command will trigger a self diagnostic and flip
	* Bit6 if the test passes.
	*/
	if (!((state1 ^ state2) & (1 << 6)))
		ls041y3_esd_recover(md);
}

static void ls041y3_esd_check_mode2(struct mipid_device *md)
{
	int i;
	u8 rbuf[2];
	static const struct {
		int	cmd;
		int	wlen;
		u16	wbuf[3];
	} *rd, rd_ctrl[7] = {
		{ 0xb0, 4, { 0x0101, 0x01fe, } },
		{ 0xb1, 4, { 0x01de, 0x0121, } },
		{ 0xc2, 4, { 0x0100, 0x0100, } },
		{ 0xbd, 2, { 0x0100, } },
		{ 0xc2, 4, { 0x01fc, 0x0103, } },
		{ 0xb4, 0, },
		{ 0x00, 0, },
	};

	rd = rd_ctrl;
	for (i = 0; i < 3; i++, rd++)
		mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);

	udelay(10);
	mipid_read(md, rd->cmd, rbuf, 2);
	rd++;

	for (i = 0; i < 3; i++, rd++) {
		udelay(10);
		mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);
	}

	dev_dbg(&md->spi->dev, "ESD mode 2 state %02x\n", rbuf[1]);
	if (rbuf[1] == 0x00)
		ls041y3_esd_recover(md);
}

static void ls041y3_esd_check(struct mipid_device *md)
{
	ls041y3_esd_check_mode1(md);
	if (md->revision >= 0x88)
		ls041y3_esd_check_mode2(md);
}

static void mipid_esd_start_check(struct mipid_device *md)
{
	if (md->esd_check != NULL)
		schedule_delayed_work(&md->esd_work,
				   MIPID_ESD_CHECK_PERIOD);
}

static void mipid_esd_stop_check(struct mipid_device *md)
{
	if (md->esd_check != NULL)
		cancel_delayed_work_sync(&md->esd_work);
}

static void mipid_esd_work(struct work_struct *work)
{
	struct mipid_device *md = container_of(work, struct mipid_device,
					       esd_work.work);

	mutex_lock(&md->mutex);
	md->esd_check(md);
	mutex_unlock(&md->mutex);
	mipid_esd_start_check(md);
}

static int mipid_enable(struct lcd_panel *panel)
{
	struct mipid_device *md = to_mipid_device(panel);

	mutex_lock(&md->mutex);

	if (md->enabled) {
		mutex_unlock(&md->mutex);
		return 0;
	}
	set_sleep_mode(md, 0);
	md->enabled = 1;
	send_init_string(md);
	set_display_state(md, 1);
	mipid_set_bklight_level(panel, md->saved_bklight_level);
	mipid_esd_start_check(md);

	mutex_unlock(&md->mutex);
	return 0;
}

static void mipid_disable(struct lcd_panel *panel)
{
	struct mipid_device *md = to_mipid_device(panel);

	/*
	 * A final ESD work might be called before returning,
	 * so do this without holding the lock.
	 */
	mipid_esd_stop_check(md);
	mutex_lock(&md->mutex);

	if (!md->enabled) {
		mutex_unlock(&md->mutex);
		return;
	}
	md->saved_bklight_level = mipid_get_bklight_level(panel);
	mipid_set_bklight_level(panel, 0);
	set_display_state(md, 0);
	set_sleep_mode(md, 1);
	md->enabled = 0;

	mutex_unlock(&md->mutex);
}

static int panel_enabled(struct mipid_device *md)
{
	u32 disp_status;
	int enabled;

	mipid_read(md, MIPID_CMD_READ_DISP_STATUS, (u8 *)&disp_status, 4);
	disp_status = __be32_to_cpu(disp_status);
	enabled = (disp_status & (1 << 17)) && (disp_status & (1 << 10));
	dev_dbg(&md->spi->dev,
		"LCD panel %senabled by bootloader (status 0x%04x)\n",
		enabled ? "" : "not ", disp_status);
	return enabled;
}

static int mipid_init(struct lcd_panel *panel,
			    struct omapfb_device *fbdev)
{
	struct mipid_device *md = to_mipid_device(panel);

	md->fbdev = fbdev;
	INIT_DELAYED_WORK(&md->esd_work, mipid_esd_work);
	mutex_init(&md->mutex);

	md->enabled = panel_enabled(md);

	if (md->enabled)
		mipid_esd_start_check(md);
	else
		md->saved_bklight_level = mipid_get_bklight_level(panel);

	return 0;
}

static void mipid_cleanup(struct lcd_panel *panel)
{
	struct mipid_device *md = to_mipid_device(panel);

	if (md->enabled)
		mipid_esd_stop_check(md);
}

static const struct lcd_panel mipid_panel = {
	.config		= OMAP_LCDC_PANEL_TFT,

	.bpp		= 16,
	.x_res		= 800,
	.y_res		= 480,
	.pixel_clock	= 21940,
	.hsw		= 50,
	.hfp		= 20,
	.hbp		= 15,
	.vsw		= 2,
	.vfp		= 1,
	.vbp		= 3,

	.init			= mipid_init,
	.cleanup		= mipid_cleanup,
	.enable			= mipid_enable,
	.disable		= mipid_disable,
	.get_caps		= mipid_get_caps,
	.set_bklight_level	= mipid_set_bklight_level,
	.get_bklight_level	= mipid_get_bklight_level,
	.get_bklight_max	= mipid_get_bklight_max,
	.run_test		= mipid_run_test,
};

static int mipid_detect(struct mipid_device *md)
{
	struct mipid_platform_data *pdata;
	u8 display_id[3];

	pdata = md->spi->dev.platform_data;
	if (pdata == NULL) {
		dev_err(&md->spi->dev, "missing platform data\n");
		return -ENOENT;
	}

	mipid_read(md, MIPID_CMD_READ_DISP_ID, display_id, 3);
	dev_dbg(&md->spi->dev, "MIPI display ID: %02x%02x%02x\n",
		display_id[0], display_id[1], display_id[2]);

	switch (display_id[0]) {
	case 0x45:
		md->panel.name = "lph8923";
		break;
	case 0x83:
		md->panel.name = "ls041y3";
		md->esd_check = ls041y3_esd_check;
		break;
	default:
		md->panel.name = "unknown";
		dev_err(&md->spi->dev, "invalid display ID\n");
		return -ENODEV;
	}

	md->revision = display_id[1];
	md->panel.data_lines = pdata->data_lines;
	pr_info("omapfb: %s rev %02x LCD detected, %d data lines\n",
			md->panel.name, md->revision, md->panel.data_lines);

	return 0;
}

static int mipid_spi_probe(struct spi_device *spi)
{
	struct mipid_device *md;
	int r;

	md = kzalloc(sizeof(*md), GFP_KERNEL);
	if (md == NULL) {
		dev_err(&spi->dev, "out of memory\n");
		return -ENOMEM;
	}

	spi->mode = SPI_MODE_0;
	md->spi = spi;
	dev_set_drvdata(&spi->dev, md);
	md->panel = mipid_panel;

	r = mipid_detect(md);
	if (r < 0)
		return r;

	omapfb_register_panel(&md->panel);

	return 0;
}

static int mipid_spi_remove(struct spi_device *spi)
{
	struct mipid_device *md = dev_get_drvdata(&spi->dev);

	mipid_disable(&md->panel);
	kfree(md);

	return 0;
}

static struct spi_driver mipid_spi_driver = {
	.driver = {
		.name	= MIPID_MODULE_NAME,
	},
	.probe	= mipid_spi_probe,
	.remove	= mipid_spi_remove,
};

module_spi_driver(mipid_spi_driver);

MODULE_DESCRIPTION("MIPI display driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
66d2f99d ID	2	/*
	3	* LCD driver for MIPI DBI-C / DCS compatible LCDs
	4	*
	5	* Copyright (C) 2006 Nokia Corporation
	6	* Author: Imre Deak <imre.deak@nokia.com>
66d2f99d ID	7	*/
	8	#include <linux/device.h>
	9	#include <linux/delay.h>
5a0e3ad6	10	#include <linux/slab.h>
66d2f99d ID	11	#include <linux/workqueue.h>
66d2f99d ID	12	#include <linux/spi/spi.h>
355b200b	13	#include <linux/module.h>
66d2f99d	14
2203747c	15	#include <linux/platform_data/lcd-mipid.h>
66d2f99d	16
91773a00 TV	17	#include "omapfb.h"
91773a00 TV	18
66d2f99d ID	19	#define MIPID_MODULE_NAME "lcd_mipid"
	20
	21	#define MIPID_CMD_READ_DISP_ID 0x04
	22	#define MIPID_CMD_READ_RED 0x06
	23	#define MIPID_CMD_READ_GREEN 0x07
	24	#define MIPID_CMD_READ_BLUE 0x08
	25	#define MIPID_CMD_READ_DISP_STATUS 0x09
	26	#define MIPID_CMD_RDDSDR 0x0F
	27	#define MIPID_CMD_SLEEP_IN 0x10
	28	#define MIPID_CMD_SLEEP_OUT 0x11
	29	#define MIPID_CMD_DISP_OFF 0x28
	30	#define MIPID_CMD_DISP_ON 0x29
	31
	32	#define MIPID_ESD_CHECK_PERIOD msecs_to_jiffies(5000)
	33
	34	#define to_mipid_device(p) container_of(p, struct mipid_device, \
	35	panel)
	36	struct mipid_device {
	37	int enabled;
	38	int revision;
	39	unsigned int saved_bklight_level;
	40	unsigned long hw_guard_end; /* next value of jiffies
	41	when we can issue the
	42	next sleep in/out command */
	43	unsigned long hw_guard_wait; /* max guard time in jiffies */
	44
	45	struct omapfb_device *fbdev;
	46	struct spi_device *spi;
	47	struct mutex mutex;
	48	struct lcd_panel panel;
	49
66d2f99d ID	50	struct delayed_work esd_work;
	51	void (esd_check)(struct mipid_device m);
	52	};
	53
	54	static void mipid_transfer(struct mipid_device md, int cmd, const u8 wbuf,
	55	int wlen, u8 *rbuf, int rlen)
	56	{
	57	struct spi_message m;
	58	struct spi_transfer *x, xfer[4];
	59	u16 w;
	60	int r;
	61
	62	BUG_ON(md->spi == NULL);
	63
	64	spi_message_init(&m);
	65
	66	memset(xfer, 0, sizeof(xfer));
	67	x = &xfer[0];
	68
	69	cmd &= 0xff;
	70	x->tx_buf = &cmd;
	71	x->bits_per_word = 9;
	72	x->len = 2;
	73	spi_message_add_tail(x, &m);
	74
	75	if (wlen) {
	76	x++;
	77	x->tx_buf = wbuf;
	78	x->len = wlen;
	79	x->bits_per_word = 9;
	80	spi_message_add_tail(x, &m);
	81	}
	82
	83	if (rlen) {
	84	x++;
	85	x->rx_buf = &w;
	86	x->len = 1;
	87	spi_message_add_tail(x, &m);
	88
	89	if (rlen > 1) {
	90	/* Arrange for the extra clock before the first
	91	* data bit.
	92	*/
	93	x->bits_per_word = 9;
	94	x->len = 2;
	95
	96	x++;
	97	x->rx_buf = &rbuf[1];
	98	x->len = rlen - 1;
	99	spi_message_add_tail(x, &m);
	100	}
	101	}
	102
	103	r = spi_sync(md->spi, &m);
	104	if (r < 0)
	105	dev_dbg(&md->spi->dev, "spi_sync %d\n", r);
	106
	107	if (rlen)
	108	rbuf[0] = w & 0xff;
	109	}
	110
	111	static inline void mipid_cmd(struct mipid_device *md, int cmd)
	112	{
	113	mipid_transfer(md, cmd, NULL, 0, NULL, 0);
114	}
115
116	static inline void mipid_write(struct mipid_device *md,
117	int reg, const u8 *buf, int len)
118	{
119	mipid_transfer(md, reg, buf, len, NULL, 0);
120	}
121
122	static inline void mipid_read(struct mipid_device *md,
123	int reg, u8 *buf, int len)
124	{
125	mipid_transfer(md, reg, NULL, 0, buf, len);
126	}
127
128	static void set_data_lines(struct mipid_device *md, int data_lines)
129	{
130	u16 par;
131
132	switch (data_lines) {
133	case 16:
134	par = 0x150;
135	break;
136	case 18:
137	par = 0x160;
138	break;
139	case 24:
140	par = 0x170;
141	break;
142	}
143	mipid_write(md, 0x3a, (u8 *)&par, 2);
144	}
145
146	static void send_init_string(struct mipid_device *md)
147	{
148	u16 initpar[] = { 0x0102, 0x0100, 0x0100 };
149
150	mipid_write(md, 0xc2, (u8 *)initpar, sizeof(initpar));
151	set_data_lines(md, md->panel.data_lines);
152	}
153
154	static void hw_guard_start(struct mipid_device *md, int guard_msec)
155	{
156	md->hw_guard_wait = msecs_to_jiffies(guard_msec);
157	md->hw_guard_end = jiffies + md->hw_guard_wait;
158	}
159
160	static void hw_guard_wait(struct mipid_device *md)
161	{
162	unsigned long wait = md->hw_guard_end - jiffies;
163
5c9cfda1	164	if ((long)wait > 0 && time_before_eq(wait, md->hw_guard_wait)) {
66d2f99d ID	165	set_current_state(TASK_UNINTERRUPTIBLE);
	166	schedule_timeout(wait);
	167	}
	168	}
	169
	170	static void set_sleep_mode(struct mipid_device *md, int on)
	171	{
	172	int cmd, sleep_time = 50;
	173
	174	if (on)
	175	cmd = MIPID_CMD_SLEEP_IN;
	176	else
	177	cmd = MIPID_CMD_SLEEP_OUT;
	178	hw_guard_wait(md);
	179	mipid_cmd(md, cmd);
	180	hw_guard_start(md, 120);
	181	/*
	182	* When we enable the panel, it seems we _have_ to sleep
	183	* 120 ms before sending the init string. When disabling the
	184	* panel we'll sleep for the duration of 2 frames, so that the
	185	* controller can still provide the PCLK,HS,VS signals.
	186	*/
	187	if (!on)
	188	sleep_time = 120;
	189	msleep(sleep_time);
	190	}
	191
	192	static void set_display_state(struct mipid_device *md, int enabled)
	193	{
	194	int cmd = enabled ? MIPID_CMD_DISP_ON : MIPID_CMD_DISP_OFF;
	195
	196	mipid_cmd(md, cmd);
	197	}
	198
	199	static int mipid_set_bklight_level(struct lcd_panel *panel, unsigned int level)
	200	{
	201	struct mipid_device *md = to_mipid_device(panel);
	202	struct mipid_platform_data *pd = md->spi->dev.platform_data;
	203
	204	if (pd->get_bklight_max == NULL \|\| pd->set_bklight_level == NULL)
	205	return -ENODEV;
	206	if (level > pd->get_bklight_max(pd))
	207	return -EINVAL;
	208	if (!md->enabled) {
	209	md->saved_bklight_level = level;
	210	return 0;
	211	}
	212	pd->set_bklight_level(pd, level);
	213
	214	return 0;
	215	}
	216
	217	static unsigned int mipid_get_bklight_level(struct lcd_panel *panel)
	218	{
	219	struct mipid_device *md = to_mipid_device(panel);
	220	struct mipid_platform_data *pd = md->spi->dev.platform_data;
	221
	222	if (pd->get_bklight_level == NULL)
	223	return -ENODEV;
	224	return pd->get_bklight_level(pd);
	225	}
	226
	227	static unsigned int mipid_get_bklight_max(struct lcd_panel *panel)
	228	{
229	struct mipid_device *md = to_mipid_device(panel);
230	struct mipid_platform_data *pd = md->spi->dev.platform_data;
231
232	if (pd->get_bklight_max == NULL)
233	return -ENODEV;
234
235	return pd->get_bklight_max(pd);
236	}
237
238	static unsigned long mipid_get_caps(struct lcd_panel *panel)
239	{
240	return OMAPFB_CAPS_SET_BACKLIGHT;
241	}
242
243	static u16 read_first_pixel(struct mipid_device *md)
244	{
245	u16 pixel;
246	u8 red, green, blue;
247
248	mutex_lock(&md->mutex);
249	mipid_read(md, MIPID_CMD_READ_RED, &red, 1);
250	mipid_read(md, MIPID_CMD_READ_GREEN, &green, 1);
251	mipid_read(md, MIPID_CMD_READ_BLUE, &blue, 1);
252	mutex_unlock(&md->mutex);
253
254	switch (md->panel.data_lines) {
255	case 16:
256	pixel = ((red >> 1) << 11) \| (green << 5) \| (blue >> 1);
257	break;
258	case 24:
259	/* 24 bit -> 16 bit */
260	pixel = ((red >> 3) << 11) \| ((green >> 2) << 5) \|
261	(blue >> 3);
262	break;
263	default:
264	pixel = 0;
265	BUG();
266	}
267
268	return pixel;
269	}
270
271	static int mipid_run_test(struct lcd_panel *panel, int test_num)
272	{
273	struct mipid_device *md = to_mipid_device(panel);
274	static const u16 test_values[4] = {
275	0x0000, 0xffff, 0xaaaa, 0x5555,
276	};
277	int i;
278
279	if (test_num != MIPID_TEST_RGB_LINES)
280	return MIPID_TEST_INVALID;
281
282	for (i = 0; i < ARRAY_SIZE(test_values); i++) {
283	int delay;
284	unsigned long tmo;
285
286	omapfb_write_first_pixel(md->fbdev, test_values[i]);
287	tmo = jiffies + msecs_to_jiffies(100);
288	delay = 25;
289	while (1) {
290	u16 pixel;
291
292	msleep(delay);
293	pixel = read_first_pixel(md);
294	if (pixel == test_values[i])
295	break;
296	if (time_after(jiffies, tmo)) {
297	dev_err(&md->spi->dev,
298	"MIPI LCD RGB I/F test failed: "
299	"expecting %04x, got %04x\n",
300	test_values[i], pixel);
301	return MIPID_TEST_FAILED;
302	}
303	delay = 10;
304	}
305	}
306
307	return 0;
308	}
309
310	static void ls041y3_esd_recover(struct mipid_device *md)
311	{
312	dev_err(&md->spi->dev, "performing LCD ESD recovery\n");
313	set_sleep_mode(md, 1);
314	set_sleep_mode(md, 0);
315	}
316
317	static void ls041y3_esd_check_mode1(struct mipid_device *md)
318	{
319	u8 state1, state2;
320
321	mipid_read(md, MIPID_CMD_RDDSDR, &state1, 1);
322	set_sleep_mode(md, 0);
323	mipid_read(md, MIPID_CMD_RDDSDR, &state2, 1);
324	dev_dbg(&md->spi->dev, "ESD mode 1 state1 %02x state2 %02x\n",
325	state1, state2);
326	/* Each sleep out command will trigger a self diagnostic and flip
327	* Bit6 if the test passes.
328	*/
329	if (!((state1 ^ state2) & (1 << 6)))
330	ls041y3_esd_recover(md);
331	}
332
333	static void ls041y3_esd_check_mode2(struct mipid_device *md)
334	{
335	int i;
336	u8 rbuf[2];
337	static const struct {
338	int cmd;
339	int wlen;
340	u16 wbuf[3];
341	} *rd, rd_ctrl[7] = {
342	{ 0xb0, 4, { 0x0101, 0x01fe, } },
343	{ 0xb1, 4, { 0x01de, 0x0121, } },
344	{ 0xc2, 4, { 0x0100, 0x0100, } },
345	{ 0xbd, 2, { 0x0100, } },
346	{ 0xc2, 4, { 0x01fc, 0x0103, } },
347	{ 0xb4, 0, },
348	{ 0x00, 0, },
349	};
350
351	rd = rd_ctrl;
352	for (i = 0; i < 3; i++, rd++)
353	mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);
354
355	udelay(10);
356	mipid_read(md, rd->cmd, rbuf, 2);
357	rd++;
358
359	for (i = 0; i < 3; i++, rd++) {
360	udelay(10);
361	mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);
362	}
363
364	dev_dbg(&md->spi->dev, "ESD mode 2 state %02x\n", rbuf[1]);
365	if (rbuf[1] == 0x00)
366	ls041y3_esd_recover(md);
367	}
368
369	static void ls041y3_esd_check(struct mipid_device *md)
370	{
371	ls041y3_esd_check_mode1(md);
372	if (md->revision >= 0x88)
373	ls041y3_esd_check_mode2(md);
374	}
375
376	static void mipid_esd_start_check(struct mipid_device *md)
377	{
378	if (md->esd_check != NULL)
71668292	379	schedule_delayed_work(&md->esd_work,
66d2f99d ID	380	MIPID_ESD_CHECK_PERIOD);
	381	}
	382
	383	static void mipid_esd_stop_check(struct mipid_device *md)
	384	{
	385	if (md->esd_check != NULL)
afe2c511	386	cancel_delayed_work_sync(&md->esd_work);
66d2f99d ID	387	}
	388
	389	static void mipid_esd_work(struct work_struct *work)
	390	{
	391	struct mipid_device *md = container_of(work, struct mipid_device,
	392	esd_work.work);
	393
	394	mutex_lock(&md->mutex);
	395	md->esd_check(md);
	396	mutex_unlock(&md->mutex);
	397	mipid_esd_start_check(md);
	398	}
	399
	400	static int mipid_enable(struct lcd_panel *panel)
	401	{
	402	struct mipid_device *md = to_mipid_device(panel);
	403
	404	mutex_lock(&md->mutex);
	405
	406	if (md->enabled) {
	407	mutex_unlock(&md->mutex);
	408	return 0;
	409	}
	410	set_sleep_mode(md, 0);
	411	md->enabled = 1;
	412	send_init_string(md);
	413	set_display_state(md, 1);
	414	mipid_set_bklight_level(panel, md->saved_bklight_level);
	415	mipid_esd_start_check(md);
	416
	417	mutex_unlock(&md->mutex);
	418	return 0;
	419	}
	420
	421	static void mipid_disable(struct lcd_panel *panel)
	422	{
	423	struct mipid_device *md = to_mipid_device(panel);
	424
	425	/*
	426	* A final ESD work might be called before returning,
	427	* so do this without holding the lock.
	428	*/
	429	mipid_esd_stop_check(md);
	430	mutex_lock(&md->mutex);
	431
	432	if (!md->enabled) {
	433	mutex_unlock(&md->mutex);
	434	return;
	435	}
	436	md->saved_bklight_level = mipid_get_bklight_level(panel);
	437	mipid_set_bklight_level(panel, 0);
	438	set_display_state(md, 0);
	439	set_sleep_mode(md, 1);
	440	md->enabled = 0;
	441
	442	mutex_unlock(&md->mutex);
	443	}
	444
	445	static int panel_enabled(struct mipid_device *md)
	446	{
	447	u32 disp_status;
	448	int enabled;
	449
	450	mipid_read(md, MIPID_CMD_READ_DISP_STATUS, (u8 *)&disp_status, 4);
451	disp_status = __be32_to_cpu(disp_status);
452	enabled = (disp_status & (1 << 17)) && (disp_status & (1 << 10));
453	dev_dbg(&md->spi->dev,
454	"LCD panel %senabled by bootloader (status 0x%04x)\n",
455	enabled ? "" : "not ", disp_status);
456	return enabled;
457	}
458
459	static int mipid_init(struct lcd_panel *panel,
460	struct omapfb_device *fbdev)
461	{
462	struct mipid_device *md = to_mipid_device(panel);
463
464	md->fbdev = fbdev;
66d2f99d ID	465	INIT_DELAYED_WORK(&md->esd_work, mipid_esd_work);
	466	mutex_init(&md->mutex);
	467
	468	md->enabled = panel_enabled(md);
	469
	470	if (md->enabled)
	471	mipid_esd_start_check(md);
	472	else
	473	md->saved_bklight_level = mipid_get_bklight_level(panel);
	474
	475	return 0;
	476	}
	477
	478	static void mipid_cleanup(struct lcd_panel *panel)
	479	{
	480	struct mipid_device *md = to_mipid_device(panel);
	481
	482	if (md->enabled)
	483	mipid_esd_stop_check(md);
66d2f99d ID	484	}
66d2f99d ID	485
a86d8d67	486	static const struct lcd_panel mipid_panel = {
66d2f99d ID	487	.config = OMAP_LCDC_PANEL_TFT,
	488
	489	.bpp = 16,
	490	.x_res = 800,
	491	.y_res = 480,
	492	.pixel_clock = 21940,
	493	.hsw = 50,
	494	.hfp = 20,
	495	.hbp = 15,
	496	.vsw = 2,
	497	.vfp = 1,
	498	.vbp = 3,
	499
	500	.init = mipid_init,
	501	.cleanup = mipid_cleanup,
	502	.enable = mipid_enable,
	503	.disable = mipid_disable,
	504	.get_caps = mipid_get_caps,
	505	.set_bklight_level = mipid_set_bklight_level,
	506	.get_bklight_level = mipid_get_bklight_level,
	507	.get_bklight_max = mipid_get_bklight_max,
	508	.run_test = mipid_run_test,
	509	};
	510
	511	static int mipid_detect(struct mipid_device *md)
	512	{
	513	struct mipid_platform_data *pdata;
	514	u8 display_id[3];
	515
	516	pdata = md->spi->dev.platform_data;
	517	if (pdata == NULL) {
	518	dev_err(&md->spi->dev, "missing platform data\n");
	519	return -ENOENT;
	520	}
	521
	522	mipid_read(md, MIPID_CMD_READ_DISP_ID, display_id, 3);
	523	dev_dbg(&md->spi->dev, "MIPI display ID: %02x%02x%02x\n",
	524	display_id[0], display_id[1], display_id[2]);
	525
	526	switch (display_id[0]) {
	527	case 0x45:
	528	md->panel.name = "lph8923";
	529	break;
	530	case 0x83:
	531	md->panel.name = "ls041y3";
	532	md->esd_check = ls041y3_esd_check;
	533	break;
	534	default:
	535	md->panel.name = "unknown";
	536	dev_err(&md->spi->dev, "invalid display ID\n");
	537	return -ENODEV;
	538	}
	539
	540	md->revision = display_id[1];
	541	md->panel.data_lines = pdata->data_lines;
	542	pr_info("omapfb: %s rev %02x LCD detected, %d data lines\n",
	543	md->panel.name, md->revision, md->panel.data_lines);
	544
	545	return 0;
	546	}
	547
	548	static int mipid_spi_probe(struct spi_device *spi)
	549	{
	550	struct mipid_device *md;
551	int r;
552
553	md = kzalloc(sizeof(*md), GFP_KERNEL);
554	if (md == NULL) {
555	dev_err(&spi->dev, "out of memory\n");
556	return -ENOMEM;
557	}
558
559	spi->mode = SPI_MODE_0;
560	md->spi = spi;
561	dev_set_drvdata(&spi->dev, md);
562	md->panel = mipid_panel;
563
564	r = mipid_detect(md);
565	if (r < 0)
566	return r;
567
568	omapfb_register_panel(&md->panel);
569
570	return 0;
571	}
572
573	static int mipid_spi_remove(struct spi_device *spi)
574	{
575	struct mipid_device *md = dev_get_drvdata(&spi->dev);
576
577	mipid_disable(&md->panel);
578	kfree(md);
579
580	return 0;
581	}
582
583	static struct spi_driver mipid_spi_driver = {
584	.driver = {
585	.name = MIPID_MODULE_NAME,
66d2f99d ID	586	},
66d2f99d ID	587	.probe = mipid_spi_probe,
48c68c4f	588	.remove = mipid_spi_remove,
66d2f99d ID	589	};
66d2f99d ID	590
c6d242aa	591	module_spi_driver(mipid_spi_driver);
66d2f99d ID	592
	593	MODULE_DESCRIPTION("MIPI display driver");
	594	MODULE_LICENSE("GPL");