1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * MIPI-DSI Novatek NT35560-based panel controller.
4  *
5  * Supported panels include:
6  * Sony ACX424AKM - a 480x854 AMOLED DSI panel
7  * Sony ACX424AKP - a 480x864 AMOLED DSI panel
8  *
9  * Copyright (C) Linaro Ltd. 2019-2021
10  * Author: Linus Walleij
11  * Based on code and know-how from Marcus Lorentzon
12  * Copyright (C) ST-Ericsson SA 2010
13  * Based on code and know-how from Johan Olson and Joakim Wesslen
14  * Copyright (C) Sony Ericsson Mobile Communications 2010
15  */
16 #include <linux/backlight.h>
17 #include <linux/delay.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/module.h>
20 #include <linux/of.h>
21 #include <linux/of_device.h>
22 #include <linux/regulator/consumer.h>
23 
24 #include <video/mipi_display.h>
25 
26 #include <drm/drm_mipi_dsi.h>
27 #include <drm/drm_modes.h>
28 #include <drm/drm_panel.h>
29 
30 #define NT35560_DCS_READ_ID1		0xDA
31 #define NT35560_DCS_READ_ID2		0xDB
32 #define NT35560_DCS_READ_ID3		0xDC
33 #define NT35560_DCS_SET_MDDI		0xAE
34 
35 /*
36  * Sony seems to use vendor ID 0x81
37  */
38 #define DISPLAY_SONY_ACX424AKP_ID1	0x8103
39 #define DISPLAY_SONY_ACX424AKP_ID2	0x811a
40 #define DISPLAY_SONY_ACX424AKP_ID3	0x811b
41 /*
42  * The fourth ID looks like a bug, vendor IDs begin at 0x80
43  * and panel 00 ... seems like default values.
44  */
45 #define DISPLAY_SONY_ACX424AKP_ID4	0x8000
46 
47 struct nt35560_config {
48 	const struct drm_display_mode *vid_mode;
49 	const struct drm_display_mode *cmd_mode;
50 };
51 
52 struct nt35560 {
53 	const struct nt35560_config *conf;
54 	struct drm_panel panel;
55 	struct device *dev;
56 	struct regulator *supply;
57 	struct gpio_desc *reset_gpio;
58 	bool video_mode;
59 };
60 
61 static const struct drm_display_mode sony_acx424akp_vid_mode = {
62 	.clock = 27234,
63 	.hdisplay = 480,
64 	.hsync_start = 480 + 15,
65 	.hsync_end = 480 + 15 + 0,
66 	.htotal = 480 + 15 + 0 + 15,
67 	.vdisplay = 864,
68 	.vsync_start = 864 + 14,
69 	.vsync_end = 864 + 14 + 1,
70 	.vtotal = 864 + 14 + 1 + 11,
71 	.width_mm = 48,
72 	.height_mm = 84,
73 	.flags = DRM_MODE_FLAG_PVSYNC,
74 };
75 
76 /*
77  * The timings are not very helpful as the display is used in
78  * command mode using the maximum HS frequency.
79  */
80 static const struct drm_display_mode sony_acx424akp_cmd_mode = {
81 	.clock = 35478,
82 	.hdisplay = 480,
83 	.hsync_start = 480 + 154,
84 	.hsync_end = 480 + 154 + 16,
85 	.htotal = 480 + 154 + 16 + 32,
86 	.vdisplay = 864,
87 	.vsync_start = 864 + 1,
88 	.vsync_end = 864 + 1 + 1,
89 	.vtotal = 864 + 1 + 1 + 1,
90 	/*
91 	 * Some desired refresh rate, experiments at the maximum "pixel"
92 	 * clock speed (HS clock 420 MHz) yields around 117Hz.
93 	 */
94 	.width_mm = 48,
95 	.height_mm = 84,
96 };
97 
98 static const struct nt35560_config sony_acx424akp_data = {
99 	.vid_mode = &sony_acx424akp_vid_mode,
100 	.cmd_mode = &sony_acx424akp_cmd_mode,
101 };
102 
103 static const struct drm_display_mode sony_acx424akm_vid_mode = {
104 	.clock = 27234,
105 	.hdisplay = 480,
106 	.hsync_start = 480 + 15,
107 	.hsync_end = 480 + 15 + 0,
108 	.htotal = 480 + 15 + 0 + 15,
109 	.vdisplay = 854,
110 	.vsync_start = 854 + 14,
111 	.vsync_end = 854 + 14 + 1,
112 	.vtotal = 854 + 14 + 1 + 11,
113 	.width_mm = 46,
114 	.height_mm = 82,
115 	.flags = DRM_MODE_FLAG_PVSYNC,
116 };
117 
118 /*
119  * The timings are not very helpful as the display is used in
120  * command mode using the maximum HS frequency.
121  */
122 static const struct drm_display_mode sony_acx424akm_cmd_mode = {
123 	.clock = 35478,
124 	.hdisplay = 480,
125 	.hsync_start = 480 + 154,
126 	.hsync_end = 480 + 154 + 16,
127 	.htotal = 480 + 154 + 16 + 32,
128 	.vdisplay = 854,
129 	.vsync_start = 854 + 1,
130 	.vsync_end = 854 + 1 + 1,
131 	.vtotal = 854 + 1 + 1 + 1,
132 	.width_mm = 46,
133 	.height_mm = 82,
134 };
135 
136 static const struct nt35560_config sony_acx424akm_data = {
137 	.vid_mode = &sony_acx424akm_vid_mode,
138 	.cmd_mode = &sony_acx424akm_cmd_mode,
139 };
140 
141 static inline struct nt35560 *panel_to_nt35560(struct drm_panel *panel)
142 {
143 	return container_of(panel, struct nt35560, panel);
144 }
145 
146 #define FOSC			20 /* 20Mhz */
147 #define SCALE_FACTOR_NS_DIV_MHZ	1000
148 
149 static int nt35560_set_brightness(struct backlight_device *bl)
150 {
151 	struct nt35560 *nt = bl_get_data(bl);
152 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
153 	int period_ns = 1023;
154 	int duty_ns = bl->props.brightness;
155 	u8 pwm_ratio;
156 	u8 pwm_div;
157 	u8 par;
158 	int ret;
159 
160 	if (backlight_is_blank(bl)) {
161 		/* Disable backlight */
162 		par = 0x00;
163 		ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY,
164 					 &par, 1);
165 		if (ret) {
166 			dev_err(nt->dev, "failed to disable display backlight (%d)\n", ret);
167 			return ret;
168 		}
169 		return 0;
170 	}
171 
172 	/* Calculate the PWM duty cycle in n/256's */
173 	pwm_ratio = max(((duty_ns * 256) / period_ns) - 1, 1);
174 	pwm_div = max(1,
175 		      ((FOSC * period_ns) / 256) /
176 		      SCALE_FACTOR_NS_DIV_MHZ);
177 
178 	/* Set up PWM dutycycle ONE byte (differs from the standard) */
179 	dev_dbg(nt->dev, "calculated duty cycle %02x\n", pwm_ratio);
180 	ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
181 				 &pwm_ratio, 1);
182 	if (ret < 0) {
183 		dev_err(nt->dev, "failed to set display PWM ratio (%d)\n", ret);
184 		return ret;
185 	}
186 
187 	/*
188 	 * Sequence to write PWMDIV:
189 	 *	address		data
190 	 *	0xF3		0xAA   CMD2 Unlock
191 	 *	0x00		0x01   Enter CMD2 page 0
192 	 *	0X7D		0x01   No reload MTP of CMD2 P1
193 	 *	0x22		PWMDIV
194 	 *	0x7F		0xAA   CMD2 page 1 lock
195 	 */
196 	par = 0xaa;
197 	ret = mipi_dsi_dcs_write(dsi, 0xf3, &par, 1);
198 	if (ret < 0) {
199 		dev_err(nt->dev, "failed to unlock CMD 2 (%d)\n", ret);
200 		return ret;
201 	}
202 	par = 0x01;
203 	ret = mipi_dsi_dcs_write(dsi, 0x00, &par, 1);
204 	if (ret < 0) {
205 		dev_err(nt->dev, "failed to enter page 1 (%d)\n", ret);
206 		return ret;
207 	}
208 	par = 0x01;
209 	ret = mipi_dsi_dcs_write(dsi, 0x7d, &par, 1);
210 	if (ret < 0) {
211 		dev_err(nt->dev, "failed to disable MTP reload (%d)\n", ret);
212 		return ret;
213 	}
214 	ret = mipi_dsi_dcs_write(dsi, 0x22, &pwm_div, 1);
215 	if (ret < 0) {
216 		dev_err(nt->dev, "failed to set PWM divisor (%d)\n", ret);
217 		return ret;
218 	}
219 	par = 0xaa;
220 	ret = mipi_dsi_dcs_write(dsi, 0x7f, &par, 1);
221 	if (ret < 0) {
222 		dev_err(nt->dev, "failed to lock CMD 2 (%d)\n", ret);
223 		return ret;
224 	}
225 
226 	/* Enable backlight */
227 	par = 0x24;
228 	ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY,
229 				 &par, 1);
230 	if (ret < 0) {
231 		dev_err(nt->dev, "failed to enable display backlight (%d)\n", ret);
232 		return ret;
233 	}
234 
235 	return 0;
236 }
237 
238 static const struct backlight_ops nt35560_bl_ops = {
239 	.update_status = nt35560_set_brightness,
240 };
241 
242 static const struct backlight_properties nt35560_bl_props = {
243 	.type = BACKLIGHT_RAW,
244 	.brightness = 512,
245 	.max_brightness = 1023,
246 };
247 
248 static int nt35560_read_id(struct nt35560 *nt)
249 {
250 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
251 	u8 vendor, version, panel;
252 	u16 val;
253 	int ret;
254 
255 	ret = mipi_dsi_dcs_read(dsi, NT35560_DCS_READ_ID1, &vendor, 1);
256 	if (ret < 0) {
257 		dev_err(nt->dev, "could not vendor ID byte\n");
258 		return ret;
259 	}
260 	ret = mipi_dsi_dcs_read(dsi, NT35560_DCS_READ_ID2, &version, 1);
261 	if (ret < 0) {
262 		dev_err(nt->dev, "could not read device version byte\n");
263 		return ret;
264 	}
265 	ret = mipi_dsi_dcs_read(dsi, NT35560_DCS_READ_ID3, &panel, 1);
266 	if (ret < 0) {
267 		dev_err(nt->dev, "could not read panel ID byte\n");
268 		return ret;
269 	}
270 
271 	if (vendor == 0x00) {
272 		dev_err(nt->dev, "device vendor ID is zero\n");
273 		return -ENODEV;
274 	}
275 
276 	val = (vendor << 8) | panel;
277 	switch (val) {
278 	case DISPLAY_SONY_ACX424AKP_ID1:
279 	case DISPLAY_SONY_ACX424AKP_ID2:
280 	case DISPLAY_SONY_ACX424AKP_ID3:
281 	case DISPLAY_SONY_ACX424AKP_ID4:
282 		dev_info(nt->dev, "MTP vendor: %02x, version: %02x, panel: %02x\n",
283 			 vendor, version, panel);
284 		break;
285 	default:
286 		dev_info(nt->dev, "unknown vendor: %02x, version: %02x, panel: %02x\n",
287 			 vendor, version, panel);
288 		break;
289 	}
290 
291 	return 0;
292 }
293 
294 static int nt35560_power_on(struct nt35560 *nt)
295 {
296 	int ret;
297 
298 	ret = regulator_enable(nt->supply);
299 	if (ret) {
300 		dev_err(nt->dev, "failed to enable supply (%d)\n", ret);
301 		return ret;
302 	}
303 
304 	/* Assert RESET */
305 	gpiod_set_value_cansleep(nt->reset_gpio, 1);
306 	udelay(20);
307 	/* De-assert RESET */
308 	gpiod_set_value_cansleep(nt->reset_gpio, 0);
309 	usleep_range(11000, 20000);
310 
311 	return 0;
312 }
313 
314 static void nt35560_power_off(struct nt35560 *nt)
315 {
316 	/* Assert RESET */
317 	gpiod_set_value_cansleep(nt->reset_gpio, 1);
318 	usleep_range(11000, 20000);
319 
320 	regulator_disable(nt->supply);
321 }
322 
323 static int nt35560_prepare(struct drm_panel *panel)
324 {
325 	struct nt35560 *nt = panel_to_nt35560(panel);
326 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
327 	const u8 mddi = 3;
328 	int ret;
329 
330 	ret = nt35560_power_on(nt);
331 	if (ret)
332 		return ret;
333 
334 	ret = nt35560_read_id(nt);
335 	if (ret) {
336 		dev_err(nt->dev, "failed to read panel ID (%d)\n", ret);
337 		goto err_power_off;
338 	}
339 
340 	/* Enabe tearing mode: send TE (tearing effect) at VBLANK */
341 	ret = mipi_dsi_dcs_set_tear_on(dsi,
342 				       MIPI_DSI_DCS_TEAR_MODE_VBLANK);
343 	if (ret) {
344 		dev_err(nt->dev, "failed to enable vblank TE (%d)\n", ret);
345 		goto err_power_off;
346 	}
347 
348 	/*
349 	 * Set MDDI
350 	 *
351 	 * This presumably deactivates the Qualcomm MDDI interface and
352 	 * selects DSI, similar code is found in other drivers such as the
353 	 * Sharp LS043T1LE01 which makes us suspect that this panel may be
354 	 * using a Novatek NT35565 or similar display driver chip that shares
355 	 * this command. Due to the lack of documentation we cannot know for
356 	 * sure.
357 	 */
358 	ret = mipi_dsi_dcs_write(dsi, NT35560_DCS_SET_MDDI,
359 				 &mddi, sizeof(mddi));
360 	if (ret < 0) {
361 		dev_err(nt->dev, "failed to set MDDI (%d)\n", ret);
362 		goto err_power_off;
363 	}
364 
365 	/* Exit sleep mode */
366 	ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
367 	if (ret) {
368 		dev_err(nt->dev, "failed to exit sleep mode (%d)\n", ret);
369 		goto err_power_off;
370 	}
371 	msleep(140);
372 
373 	ret = mipi_dsi_dcs_set_display_on(dsi);
374 	if (ret) {
375 		dev_err(nt->dev, "failed to turn display on (%d)\n", ret);
376 		goto err_power_off;
377 	}
378 	if (nt->video_mode) {
379 		/* In video mode turn peripheral on */
380 		ret = mipi_dsi_turn_on_peripheral(dsi);
381 		if (ret) {
382 			dev_err(nt->dev, "failed to turn on peripheral\n");
383 			goto err_power_off;
384 		}
385 	}
386 
387 	return 0;
388 
389 err_power_off:
390 	nt35560_power_off(nt);
391 	return ret;
392 }
393 
394 static int nt35560_unprepare(struct drm_panel *panel)
395 {
396 	struct nt35560 *nt = panel_to_nt35560(panel);
397 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
398 	int ret;
399 
400 	ret = mipi_dsi_dcs_set_display_off(dsi);
401 	if (ret) {
402 		dev_err(nt->dev, "failed to turn display off (%d)\n", ret);
403 		return ret;
404 	}
405 
406 	/* Enter sleep mode */
407 	ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
408 	if (ret) {
409 		dev_err(nt->dev, "failed to enter sleep mode (%d)\n", ret);
410 		return ret;
411 	}
412 	msleep(85);
413 
414 	nt35560_power_off(nt);
415 
416 	return 0;
417 }
418 
419 
420 static int nt35560_get_modes(struct drm_panel *panel,
421 			     struct drm_connector *connector)
422 {
423 	struct nt35560 *nt = panel_to_nt35560(panel);
424 	const struct nt35560_config *conf = nt->conf;
425 	struct drm_display_mode *mode;
426 
427 	if (nt->video_mode)
428 		mode = drm_mode_duplicate(connector->dev,
429 					  conf->vid_mode);
430 	else
431 		mode = drm_mode_duplicate(connector->dev,
432 					  conf->cmd_mode);
433 	if (!mode) {
434 		dev_err(panel->dev, "bad mode or failed to add mode\n");
435 		return -EINVAL;
436 	}
437 	drm_mode_set_name(mode);
438 	mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
439 
440 	connector->display_info.width_mm = mode->width_mm;
441 	connector->display_info.height_mm = mode->height_mm;
442 
443 	drm_mode_probed_add(connector, mode);
444 
445 	return 1; /* Number of modes */
446 }
447 
448 static const struct drm_panel_funcs nt35560_drm_funcs = {
449 	.unprepare = nt35560_unprepare,
450 	.prepare = nt35560_prepare,
451 	.get_modes = nt35560_get_modes,
452 };
453 
454 static int nt35560_probe(struct mipi_dsi_device *dsi)
455 {
456 	struct device *dev = &dsi->dev;
457 	struct nt35560 *nt;
458 	int ret;
459 
460 	nt = devm_kzalloc(dev, sizeof(struct nt35560), GFP_KERNEL);
461 	if (!nt)
462 		return -ENOMEM;
463 	nt->video_mode = of_property_read_bool(dev->of_node,
464 						"enforce-video-mode");
465 
466 	mipi_dsi_set_drvdata(dsi, nt);
467 	nt->dev = dev;
468 
469 	nt->conf = of_device_get_match_data(dev);
470 	if (!nt->conf) {
471 		dev_err(dev, "missing device configuration\n");
472 		return -ENODEV;
473 	}
474 
475 	dsi->lanes = 2;
476 	dsi->format = MIPI_DSI_FMT_RGB888;
477 	/*
478 	 * FIXME: these come from the ST-Ericsson vendor driver for the
479 	 * HREF520 and seems to reflect limitations in the PLLs on that
480 	 * platform, if you have the datasheet, please cross-check the
481 	 * actual max rates.
482 	 */
483 	dsi->lp_rate = 19200000;
484 	dsi->hs_rate = 420160000;
485 
486 	if (nt->video_mode)
487 		/* Burst mode using event for sync */
488 		dsi->mode_flags =
489 			MIPI_DSI_MODE_VIDEO |
490 			MIPI_DSI_MODE_VIDEO_BURST;
491 	else
492 		dsi->mode_flags =
493 			MIPI_DSI_CLOCK_NON_CONTINUOUS;
494 
495 	nt->supply = devm_regulator_get(dev, "vddi");
496 	if (IS_ERR(nt->supply))
497 		return PTR_ERR(nt->supply);
498 
499 	/* This asserts RESET by default */
500 	nt->reset_gpio = devm_gpiod_get_optional(dev, "reset",
501 						 GPIOD_OUT_HIGH);
502 	if (IS_ERR(nt->reset_gpio))
503 		return dev_err_probe(dev, PTR_ERR(nt->reset_gpio),
504 				     "failed to request GPIO\n");
505 
506 	drm_panel_init(&nt->panel, dev, &nt35560_drm_funcs,
507 		       DRM_MODE_CONNECTOR_DSI);
508 
509 	nt->panel.backlight = devm_backlight_device_register(dev, "nt35560", dev, nt,
510 					&nt35560_bl_ops, &nt35560_bl_props);
511 	if (IS_ERR(nt->panel.backlight))
512 		return dev_err_probe(dev, PTR_ERR(nt->panel.backlight),
513 				     "failed to register backlight device\n");
514 
515 	drm_panel_add(&nt->panel);
516 
517 	ret = mipi_dsi_attach(dsi);
518 	if (ret < 0) {
519 		drm_panel_remove(&nt->panel);
520 		return ret;
521 	}
522 
523 	return 0;
524 }
525 
526 static int nt35560_remove(struct mipi_dsi_device *dsi)
527 {
528 	struct nt35560 *nt = mipi_dsi_get_drvdata(dsi);
529 
530 	mipi_dsi_detach(dsi);
531 	drm_panel_remove(&nt->panel);
532 
533 	return 0;
534 }
535 
536 static const struct of_device_id nt35560_of_match[] = {
537 	{
538 		.compatible = "sony,acx424akp",
539 		.data = &sony_acx424akp_data,
540 	},
541 	{
542 		.compatible = "sony,acx424akm",
543 		.data = &sony_acx424akm_data,
544 	},
545 	{ /* sentinel */ }
546 };
547 MODULE_DEVICE_TABLE(of, nt35560_of_match);
548 
549 static struct mipi_dsi_driver nt35560_driver = {
550 	.probe = nt35560_probe,
551 	.remove = nt35560_remove,
552 	.driver = {
553 		.name = "panel-novatek-nt35560",
554 		.of_match_table = nt35560_of_match,
555 	},
556 };
557 module_mipi_dsi_driver(nt35560_driver);
558 
559 MODULE_AUTHOR("Linus Wallei <linus.walleij@linaro.org>");
560 MODULE_DESCRIPTION("MIPI-DSI Novatek NT35560 Panel Driver");
561 MODULE_LICENSE("GPL v2");
562