1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2016 InforceComputing
4  * Author: Vinay Simha BN <simhavcs@gmail.com>
5  *
6  * Copyright (C) 2016 Linaro Ltd
7  * Author: Sumit Semwal <sumit.semwal@linaro.org>
8  *
9  * From internet archives, the panel for Nexus 7 2nd Gen, 2013 model is a
10  * JDI model LT070ME05000, and its data sheet is at:
11  * http://panelone.net/en/7-0-inch/JDI_LT070ME05000_7.0_inch-datasheet
12  */
13 
14 #include <linux/backlight.h>
15 #include <linux/delay.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/module.h>
18 #include <linux/of.h>
19 #include <linux/regulator/consumer.h>
20 
21 #include <video/mipi_display.h>
22 
23 #include <drm/drm_crtc.h>
24 #include <drm/drm_mipi_dsi.h>
25 #include <drm/drm_modes.h>
26 #include <drm/drm_panel.h>
27 
28 static const char * const regulator_names[] = {
29 	"vddp",
30 	"iovcc"
31 };
32 
33 struct jdi_panel {
34 	struct drm_panel base;
35 	struct mipi_dsi_device *dsi;
36 
37 	struct regulator_bulk_data supplies[ARRAY_SIZE(regulator_names)];
38 
39 	struct gpio_desc *enable_gpio;
40 	struct gpio_desc *reset_gpio;
41 	struct gpio_desc *dcdc_en_gpio;
42 	struct backlight_device *backlight;
43 
44 	bool prepared;
45 	bool enabled;
46 
47 	const struct drm_display_mode *mode;
48 };
49 
50 static inline struct jdi_panel *to_jdi_panel(struct drm_panel *panel)
51 {
52 	return container_of(panel, struct jdi_panel, base);
53 }
54 
55 static int jdi_panel_init(struct jdi_panel *jdi)
56 {
57 	struct mipi_dsi_device *dsi = jdi->dsi;
58 	struct device *dev = &jdi->dsi->dev;
59 	int ret;
60 
61 	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
62 
63 	ret = mipi_dsi_dcs_soft_reset(dsi);
64 	if (ret < 0)
65 		return ret;
66 
67 	usleep_range(10000, 20000);
68 
69 	ret = mipi_dsi_dcs_set_pixel_format(dsi, MIPI_DCS_PIXEL_FMT_24BIT << 4);
70 	if (ret < 0) {
71 		dev_err(dev, "failed to set pixel format: %d\n", ret);
72 		return ret;
73 	}
74 
75 	ret = mipi_dsi_dcs_set_column_address(dsi, 0, jdi->mode->hdisplay - 1);
76 	if (ret < 0) {
77 		dev_err(dev, "failed to set column address: %d\n", ret);
78 		return ret;
79 	}
80 
81 	ret = mipi_dsi_dcs_set_page_address(dsi, 0, jdi->mode->vdisplay - 1);
82 	if (ret < 0) {
83 		dev_err(dev, "failed to set page address: %d\n", ret);
84 		return ret;
85 	}
86 
87 	/*
88 	 * BIT(5) BCTRL = 1 Backlight Control Block On, Brightness registers
89 	 *                  are active
90 	 * BIT(3) BL = 1    Backlight Control On
91 	 * BIT(2) DD = 0    Display Dimming is Off
92 	 */
93 	ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY,
94 				 (u8[]){ 0x24 }, 1);
95 	if (ret < 0) {
96 		dev_err(dev, "failed to write control display: %d\n", ret);
97 		return ret;
98 	}
99 
100 	/* CABC off */
101 	ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_WRITE_POWER_SAVE,
102 				 (u8[]){ 0x00 }, 1);
103 	if (ret < 0) {
104 		dev_err(dev, "failed to set cabc off: %d\n", ret);
105 		return ret;
106 	}
107 
108 	ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
109 	if (ret < 0) {
110 		dev_err(dev, "failed to set exit sleep mode: %d\n", ret);
111 		return ret;
112 	}
113 
114 	msleep(120);
115 
116 	ret = mipi_dsi_generic_write(dsi, (u8[]){0xB0, 0x00}, 2);
117 	if (ret < 0) {
118 		dev_err(dev, "failed to set mcap: %d\n", ret);
119 		return ret;
120 	}
121 
122 	mdelay(10);
123 
124 	/* Interface setting, video mode */
125 	ret = mipi_dsi_generic_write(dsi, (u8[])
126 				     {0xB3, 0x26, 0x08, 0x00, 0x20, 0x00}, 6);
127 	if (ret < 0) {
128 		dev_err(dev, "failed to set display interface setting: %d\n"
129 			, ret);
130 		return ret;
131 	}
132 
133 	mdelay(20);
134 
135 	ret = mipi_dsi_generic_write(dsi, (u8[]){0xB0, 0x03}, 2);
136 	if (ret < 0) {
137 		dev_err(dev, "failed to set default values for mcap: %d\n"
138 			, ret);
139 		return ret;
140 	}
141 
142 	return 0;
143 }
144 
145 static int jdi_panel_on(struct jdi_panel *jdi)
146 {
147 	struct mipi_dsi_device *dsi = jdi->dsi;
148 	struct device *dev = &jdi->dsi->dev;
149 	int ret;
150 
151 	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
152 
153 	ret = mipi_dsi_dcs_set_display_on(dsi);
154 	if (ret < 0)
155 		dev_err(dev, "failed to set display on: %d\n", ret);
156 
157 	return ret;
158 }
159 
160 static void jdi_panel_off(struct jdi_panel *jdi)
161 {
162 	struct mipi_dsi_device *dsi = jdi->dsi;
163 	struct device *dev = &jdi->dsi->dev;
164 	int ret;
165 
166 	dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
167 
168 	ret = mipi_dsi_dcs_set_display_off(dsi);
169 	if (ret < 0)
170 		dev_err(dev, "failed to set display off: %d\n", ret);
171 
172 	ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
173 	if (ret < 0)
174 		dev_err(dev, "failed to enter sleep mode: %d\n", ret);
175 
176 	msleep(100);
177 }
178 
179 static int jdi_panel_disable(struct drm_panel *panel)
180 {
181 	struct jdi_panel *jdi = to_jdi_panel(panel);
182 
183 	if (!jdi->enabled)
184 		return 0;
185 
186 	backlight_disable(jdi->backlight);
187 
188 	jdi->enabled = false;
189 
190 	return 0;
191 }
192 
193 static int jdi_panel_unprepare(struct drm_panel *panel)
194 {
195 	struct jdi_panel *jdi = to_jdi_panel(panel);
196 	struct device *dev = &jdi->dsi->dev;
197 	int ret;
198 
199 	if (!jdi->prepared)
200 		return 0;
201 
202 	jdi_panel_off(jdi);
203 
204 	ret = regulator_bulk_disable(ARRAY_SIZE(jdi->supplies), jdi->supplies);
205 	if (ret < 0)
206 		dev_err(dev, "regulator disable failed, %d\n", ret);
207 
208 	gpiod_set_value(jdi->enable_gpio, 0);
209 
210 	gpiod_set_value(jdi->reset_gpio, 1);
211 
212 	gpiod_set_value(jdi->dcdc_en_gpio, 0);
213 
214 	jdi->prepared = false;
215 
216 	return 0;
217 }
218 
219 static int jdi_panel_prepare(struct drm_panel *panel)
220 {
221 	struct jdi_panel *jdi = to_jdi_panel(panel);
222 	struct device *dev = &jdi->dsi->dev;
223 	int ret;
224 
225 	if (jdi->prepared)
226 		return 0;
227 
228 	ret = regulator_bulk_enable(ARRAY_SIZE(jdi->supplies), jdi->supplies);
229 	if (ret < 0) {
230 		dev_err(dev, "regulator enable failed, %d\n", ret);
231 		return ret;
232 	}
233 
234 	msleep(20);
235 
236 	gpiod_set_value(jdi->dcdc_en_gpio, 1);
237 	usleep_range(10, 20);
238 
239 	gpiod_set_value(jdi->reset_gpio, 0);
240 	usleep_range(10, 20);
241 
242 	gpiod_set_value(jdi->enable_gpio, 1);
243 	usleep_range(10, 20);
244 
245 	ret = jdi_panel_init(jdi);
246 	if (ret < 0) {
247 		dev_err(dev, "failed to init panel: %d\n", ret);
248 		goto poweroff;
249 	}
250 
251 	ret = jdi_panel_on(jdi);
252 	if (ret < 0) {
253 		dev_err(dev, "failed to set panel on: %d\n", ret);
254 		goto poweroff;
255 	}
256 
257 	jdi->prepared = true;
258 
259 	return 0;
260 
261 poweroff:
262 	ret = regulator_bulk_disable(ARRAY_SIZE(jdi->supplies), jdi->supplies);
263 	if (ret < 0)
264 		dev_err(dev, "regulator disable failed, %d\n", ret);
265 
266 	gpiod_set_value(jdi->enable_gpio, 0);
267 
268 	gpiod_set_value(jdi->reset_gpio, 1);
269 
270 	gpiod_set_value(jdi->dcdc_en_gpio, 0);
271 
272 	return ret;
273 }
274 
275 static int jdi_panel_enable(struct drm_panel *panel)
276 {
277 	struct jdi_panel *jdi = to_jdi_panel(panel);
278 
279 	if (jdi->enabled)
280 		return 0;
281 
282 	backlight_enable(jdi->backlight);
283 
284 	jdi->enabled = true;
285 
286 	return 0;
287 }
288 
289 static const struct drm_display_mode default_mode = {
290 		.clock = 155493,
291 		.hdisplay = 1200,
292 		.hsync_start = 1200 + 48,
293 		.hsync_end = 1200 + 48 + 32,
294 		.htotal = 1200 + 48 + 32 + 60,
295 		.vdisplay = 1920,
296 		.vsync_start = 1920 + 3,
297 		.vsync_end = 1920 + 3 + 5,
298 		.vtotal = 1920 + 3 + 5 + 6,
299 		.flags = 0,
300 };
301 
302 static int jdi_panel_get_modes(struct drm_panel *panel,
303 			       struct drm_connector *connector)
304 {
305 	struct drm_display_mode *mode;
306 	struct jdi_panel *jdi = to_jdi_panel(panel);
307 	struct device *dev = &jdi->dsi->dev;
308 
309 	mode = drm_mode_duplicate(connector->dev, &default_mode);
310 	if (!mode) {
311 		dev_err(dev, "failed to add mode %ux%ux@%u\n",
312 			default_mode.hdisplay, default_mode.vdisplay,
313 			drm_mode_vrefresh(&default_mode));
314 		return -ENOMEM;
315 	}
316 
317 	drm_mode_set_name(mode);
318 
319 	drm_mode_probed_add(connector, mode);
320 
321 	connector->display_info.width_mm = 95;
322 	connector->display_info.height_mm = 151;
323 
324 	return 1;
325 }
326 
327 static int dsi_dcs_bl_get_brightness(struct backlight_device *bl)
328 {
329 	struct mipi_dsi_device *dsi = bl_get_data(bl);
330 	int ret;
331 	u16 brightness = bl->props.brightness;
332 
333 	dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
334 
335 	ret = mipi_dsi_dcs_get_display_brightness(dsi, &brightness);
336 	if (ret < 0)
337 		return ret;
338 
339 	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
340 
341 	return brightness & 0xff;
342 }
343 
344 static int dsi_dcs_bl_update_status(struct backlight_device *bl)
345 {
346 	struct mipi_dsi_device *dsi = bl_get_data(bl);
347 	int ret;
348 
349 	dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
350 
351 	ret = mipi_dsi_dcs_set_display_brightness(dsi, bl->props.brightness);
352 	if (ret < 0)
353 		return ret;
354 
355 	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
356 
357 	return 0;
358 }
359 
360 static const struct backlight_ops dsi_bl_ops = {
361 	.update_status = dsi_dcs_bl_update_status,
362 	.get_brightness = dsi_dcs_bl_get_brightness,
363 };
364 
365 static struct backlight_device *
366 drm_panel_create_dsi_backlight(struct mipi_dsi_device *dsi)
367 {
368 	struct device *dev = &dsi->dev;
369 	struct backlight_properties props;
370 
371 	memset(&props, 0, sizeof(props));
372 	props.type = BACKLIGHT_RAW;
373 	props.brightness = 255;
374 	props.max_brightness = 255;
375 
376 	return devm_backlight_device_register(dev, dev_name(dev), dev, dsi,
377 					      &dsi_bl_ops, &props);
378 }
379 
380 static const struct drm_panel_funcs jdi_panel_funcs = {
381 	.disable = jdi_panel_disable,
382 	.unprepare = jdi_panel_unprepare,
383 	.prepare = jdi_panel_prepare,
384 	.enable = jdi_panel_enable,
385 	.get_modes = jdi_panel_get_modes,
386 };
387 
388 static const struct of_device_id jdi_of_match[] = {
389 	{ .compatible = "jdi,lt070me05000", },
390 	{ }
391 };
392 MODULE_DEVICE_TABLE(of, jdi_of_match);
393 
394 static int jdi_panel_add(struct jdi_panel *jdi)
395 {
396 	struct device *dev = &jdi->dsi->dev;
397 	int ret;
398 	unsigned int i;
399 
400 	jdi->mode = &default_mode;
401 
402 	for (i = 0; i < ARRAY_SIZE(jdi->supplies); i++)
403 		jdi->supplies[i].supply = regulator_names[i];
404 
405 	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(jdi->supplies),
406 				      jdi->supplies);
407 	if (ret < 0) {
408 		dev_err(dev, "failed to init regulator, ret=%d\n", ret);
409 		return ret;
410 	}
411 
412 	jdi->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
413 	if (IS_ERR(jdi->enable_gpio)) {
414 		ret = PTR_ERR(jdi->enable_gpio);
415 		dev_err(dev, "cannot get enable-gpio %d\n", ret);
416 		return ret;
417 	}
418 
419 	jdi->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
420 	if (IS_ERR(jdi->reset_gpio)) {
421 		ret = PTR_ERR(jdi->reset_gpio);
422 		dev_err(dev, "cannot get reset-gpios %d\n", ret);
423 		return ret;
424 	}
425 
426 	jdi->dcdc_en_gpio = devm_gpiod_get(dev, "dcdc-en", GPIOD_OUT_LOW);
427 	if (IS_ERR(jdi->dcdc_en_gpio)) {
428 		ret = PTR_ERR(jdi->dcdc_en_gpio);
429 		dev_err(dev, "cannot get dcdc-en-gpio %d\n", ret);
430 		return ret;
431 	}
432 
433 	jdi->backlight = drm_panel_create_dsi_backlight(jdi->dsi);
434 	if (IS_ERR(jdi->backlight)) {
435 		ret = PTR_ERR(jdi->backlight);
436 		dev_err(dev, "failed to register backlight %d\n", ret);
437 		return ret;
438 	}
439 
440 	drm_panel_init(&jdi->base, &jdi->dsi->dev, &jdi_panel_funcs,
441 		       DRM_MODE_CONNECTOR_DSI);
442 
443 	ret = drm_panel_add(&jdi->base);
444 
445 	return ret;
446 }
447 
448 static void jdi_panel_del(struct jdi_panel *jdi)
449 {
450 	if (jdi->base.dev)
451 		drm_panel_remove(&jdi->base);
452 }
453 
454 static int jdi_panel_probe(struct mipi_dsi_device *dsi)
455 {
456 	struct jdi_panel *jdi;
457 	int ret;
458 
459 	dsi->lanes = 4;
460 	dsi->format = MIPI_DSI_FMT_RGB888;
461 	dsi->mode_flags =  MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_MODE_VIDEO |
462 			   MIPI_DSI_CLOCK_NON_CONTINUOUS;
463 
464 	jdi = devm_kzalloc(&dsi->dev, sizeof(*jdi), GFP_KERNEL);
465 	if (!jdi)
466 		return -ENOMEM;
467 
468 	mipi_dsi_set_drvdata(dsi, jdi);
469 
470 	jdi->dsi = dsi;
471 
472 	ret = jdi_panel_add(jdi);
473 	if (ret < 0)
474 		return ret;
475 
476 	return mipi_dsi_attach(dsi);
477 }
478 
479 static int jdi_panel_remove(struct mipi_dsi_device *dsi)
480 {
481 	struct jdi_panel *jdi = mipi_dsi_get_drvdata(dsi);
482 	int ret;
483 
484 	ret = jdi_panel_disable(&jdi->base);
485 	if (ret < 0)
486 		dev_err(&dsi->dev, "failed to disable panel: %d\n", ret);
487 
488 	ret = mipi_dsi_detach(dsi);
489 	if (ret < 0)
490 		dev_err(&dsi->dev, "failed to detach from DSI host: %d\n",
491 			ret);
492 
493 	jdi_panel_del(jdi);
494 
495 	return 0;
496 }
497 
498 static void jdi_panel_shutdown(struct mipi_dsi_device *dsi)
499 {
500 	struct jdi_panel *jdi = mipi_dsi_get_drvdata(dsi);
501 
502 	jdi_panel_disable(&jdi->base);
503 }
504 
505 static struct mipi_dsi_driver jdi_panel_driver = {
506 	.driver = {
507 		.name = "panel-jdi-lt070me05000",
508 		.of_match_table = jdi_of_match,
509 	},
510 	.probe = jdi_panel_probe,
511 	.remove = jdi_panel_remove,
512 	.shutdown = jdi_panel_shutdown,
513 };
514 module_mipi_dsi_driver(jdi_panel_driver);
515 
516 MODULE_AUTHOR("Sumit Semwal <sumit.semwal@linaro.org>");
517 MODULE_AUTHOR("Vinay Simha BN <simhavcs@gmail.com>");
518 MODULE_DESCRIPTION("JDI LT070ME05000 WUXGA");
519 MODULE_LICENSE("GPL v2");
520