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