1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Mantix MLAF057WE51 5.7" MIPI-DSI panel driver
4  *
5  * Copyright (C) Purism SPC 2020
6  */
7 
8 #include <linux/backlight.h>
9 #include <linux/delay.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/media-bus-format.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/regulator/consumer.h>
15 
16 #include <video/mipi_display.h>
17 
18 #include <drm/drm_mipi_dsi.h>
19 #include <drm/drm_modes.h>
20 #include <drm/drm_panel.h>
21 
22 #define DRV_NAME "panel-mantix-mlaf057we51"
23 
24 /* Manufacturer specific Commands send via DSI */
25 #define MANTIX_CMD_OTP_STOP_RELOAD_MIPI 0x41
26 #define MANTIX_CMD_INT_CANCEL           0x4C
27 #define MANTIX_CMD_SPI_FINISH           0x90
28 
29 struct mantix {
30 	struct device *dev;
31 	struct drm_panel panel;
32 
33 	struct gpio_desc *reset_gpio;
34 	struct gpio_desc *tp_rstn_gpio;
35 
36 	struct regulator *avdd;
37 	struct regulator *avee;
38 	struct regulator *vddi;
39 
40 	const struct drm_display_mode *default_mode;
41 };
42 
panel_to_mantix(struct drm_panel * panel)43 static inline struct mantix *panel_to_mantix(struct drm_panel *panel)
44 {
45 	return container_of(panel, struct mantix, panel);
46 }
47 
mantix_init_sequence(struct mantix * ctx)48 static int mantix_init_sequence(struct mantix *ctx)
49 {
50 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(ctx->dev);
51 	struct device *dev = ctx->dev;
52 
53 	/*
54 	 * Init sequence was supplied by the panel vendor.
55 	 */
56 	mipi_dsi_generic_write_seq(dsi, MANTIX_CMD_OTP_STOP_RELOAD_MIPI, 0x5A);
57 
58 	mipi_dsi_generic_write_seq(dsi, MANTIX_CMD_INT_CANCEL, 0x03);
59 	mipi_dsi_generic_write_seq(dsi, MANTIX_CMD_OTP_STOP_RELOAD_MIPI, 0x5A, 0x03);
60 	mipi_dsi_generic_write_seq(dsi, 0x80, 0xA9, 0x00);
61 
62 	mipi_dsi_generic_write_seq(dsi, MANTIX_CMD_OTP_STOP_RELOAD_MIPI, 0x5A, 0x09);
63 	mipi_dsi_generic_write_seq(dsi, 0x80, 0x64, 0x00, 0x64, 0x00, 0x00);
64 	msleep(20);
65 
66 	mipi_dsi_generic_write_seq(dsi, MANTIX_CMD_SPI_FINISH, 0xA5);
67 	mipi_dsi_generic_write_seq(dsi, MANTIX_CMD_OTP_STOP_RELOAD_MIPI, 0x00, 0x2F);
68 	msleep(20);
69 
70 	dev_dbg(dev, "Panel init sequence done\n");
71 	return 0;
72 }
73 
mantix_enable(struct drm_panel * panel)74 static int mantix_enable(struct drm_panel *panel)
75 {
76 	struct mantix *ctx = panel_to_mantix(panel);
77 	struct device *dev = ctx->dev;
78 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
79 	int ret;
80 
81 	ret = mantix_init_sequence(ctx);
82 	if (ret < 0) {
83 		dev_err(ctx->dev, "Panel init sequence failed: %d\n", ret);
84 		return ret;
85 	}
86 
87 	ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
88 	if (ret < 0) {
89 		dev_err(dev, "Failed to exit sleep mode\n");
90 		return ret;
91 	}
92 	msleep(20);
93 
94 	ret = mipi_dsi_dcs_set_display_on(dsi);
95 	if (ret)
96 		return ret;
97 	usleep_range(10000, 12000);
98 
99 	ret = mipi_dsi_turn_on_peripheral(dsi);
100 	if (ret < 0) {
101 		dev_err(dev, "Failed to turn on peripheral\n");
102 		return ret;
103 	}
104 
105 	return 0;
106 }
107 
mantix_disable(struct drm_panel * panel)108 static int mantix_disable(struct drm_panel *panel)
109 {
110 	struct mantix *ctx = panel_to_mantix(panel);
111 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(ctx->dev);
112 	int ret;
113 
114 	ret = mipi_dsi_dcs_set_display_off(dsi);
115 	if (ret < 0)
116 		dev_err(ctx->dev, "Failed to turn off the display: %d\n", ret);
117 
118 	ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
119 	if (ret < 0)
120 		dev_err(ctx->dev, "Failed to enter sleep mode: %d\n", ret);
121 
122 
123 	return 0;
124 }
125 
mantix_unprepare(struct drm_panel * panel)126 static int mantix_unprepare(struct drm_panel *panel)
127 {
128 	struct mantix *ctx = panel_to_mantix(panel);
129 
130 	gpiod_set_value_cansleep(ctx->tp_rstn_gpio, 1);
131 	usleep_range(5000, 6000);
132 	gpiod_set_value_cansleep(ctx->reset_gpio, 1);
133 
134 	regulator_disable(ctx->avee);
135 	regulator_disable(ctx->avdd);
136 	/* T11 */
137 	usleep_range(5000, 6000);
138 	regulator_disable(ctx->vddi);
139 	/* T14 */
140 	msleep(50);
141 
142 	return 0;
143 }
144 
mantix_prepare(struct drm_panel * panel)145 static int mantix_prepare(struct drm_panel *panel)
146 {
147 	struct mantix *ctx = panel_to_mantix(panel);
148 	int ret;
149 
150 	/* Focaltech FT8006P, section 7.3.1 and 7.3.4 */
151 	dev_dbg(ctx->dev, "Resetting the panel\n");
152 	ret = regulator_enable(ctx->vddi);
153 	if (ret < 0) {
154 		dev_err(ctx->dev, "Failed to enable vddi supply: %d\n", ret);
155 		return ret;
156 	}
157 
158 	/* T1 + T2 */
159 	usleep_range(8000, 10000);
160 
161 	ret = regulator_enable(ctx->avdd);
162 	if (ret < 0) {
163 		dev_err(ctx->dev, "Failed to enable avdd supply: %d\n", ret);
164 		return ret;
165 	}
166 
167 	/* T2d */
168 	usleep_range(3500, 4000);
169 	ret = regulator_enable(ctx->avee);
170 	if (ret < 0) {
171 		dev_err(ctx->dev, "Failed to enable avee supply: %d\n", ret);
172 		return ret;
173 	}
174 
175 	/* T3 + T4 + time for voltage to become stable: */
176 	usleep_range(6000, 7000);
177 	gpiod_set_value_cansleep(ctx->reset_gpio, 0);
178 	gpiod_set_value_cansleep(ctx->tp_rstn_gpio, 0);
179 
180 	/* T6 */
181 	msleep(50);
182 
183 	return 0;
184 }
185 
186 static const struct drm_display_mode default_mode_mantix = {
187 	.hdisplay    = 720,
188 	.hsync_start = 720 + 45,
189 	.hsync_end   = 720 + 45 + 14,
190 	.htotal	     = 720 + 45 + 14 + 25,
191 	.vdisplay    = 1440,
192 	.vsync_start = 1440 + 130,
193 	.vsync_end   = 1440 + 130 + 8,
194 	.vtotal	     = 1440 + 130 + 8 + 106,
195 	.clock	     = 85298,
196 	.flags	     = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
197 	.width_mm    = 65,
198 	.height_mm   = 130,
199 };
200 
201 static const struct drm_display_mode default_mode_ys = {
202 	.hdisplay    = 720,
203 	.hsync_start = 720 + 45,
204 	.hsync_end   = 720 + 45 + 14,
205 	.htotal	     = 720 + 45 + 14 + 25,
206 	.vdisplay    = 1440,
207 	.vsync_start = 1440 + 175,
208 	.vsync_end   = 1440 + 175 + 8,
209 	.vtotal	     = 1440 + 175 + 8 + 50,
210 	.clock	     = 85298,
211 	.flags	     = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
212 	.width_mm    = 65,
213 	.height_mm   = 130,
214 };
215 
216 static const u32 mantix_bus_formats[] = {
217 	MEDIA_BUS_FMT_RGB888_1X24,
218 };
219 
mantix_get_modes(struct drm_panel * panel,struct drm_connector * connector)220 static int mantix_get_modes(struct drm_panel *panel,
221 			    struct drm_connector *connector)
222 {
223 	struct mantix *ctx = panel_to_mantix(panel);
224 	struct drm_display_mode *mode;
225 
226 	mode = drm_mode_duplicate(connector->dev, ctx->default_mode);
227 	if (!mode) {
228 		dev_err(ctx->dev, "Failed to add mode %ux%u@%u\n",
229 			ctx->default_mode->hdisplay, ctx->default_mode->vdisplay,
230 			drm_mode_vrefresh(ctx->default_mode));
231 		return -ENOMEM;
232 	}
233 
234 	drm_mode_set_name(mode);
235 
236 	mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
237 	connector->display_info.width_mm = mode->width_mm;
238 	connector->display_info.height_mm = mode->height_mm;
239 	drm_mode_probed_add(connector, mode);
240 
241 	drm_display_info_set_bus_formats(&connector->display_info,
242 					 mantix_bus_formats,
243 					 ARRAY_SIZE(mantix_bus_formats));
244 
245 	return 1;
246 }
247 
248 static const struct drm_panel_funcs mantix_drm_funcs = {
249 	.disable   = mantix_disable,
250 	.unprepare = mantix_unprepare,
251 	.prepare   = mantix_prepare,
252 	.enable	   = mantix_enable,
253 	.get_modes = mantix_get_modes,
254 };
255 
mantix_probe(struct mipi_dsi_device * dsi)256 static int mantix_probe(struct mipi_dsi_device *dsi)
257 {
258 	struct device *dev = &dsi->dev;
259 	struct mantix *ctx;
260 	int ret;
261 
262 	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
263 	if (!ctx)
264 		return -ENOMEM;
265 	ctx->default_mode = of_device_get_match_data(dev);
266 
267 	ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
268 	if (IS_ERR(ctx->reset_gpio)) {
269 		dev_err(dev, "cannot get reset gpio\n");
270 		return PTR_ERR(ctx->reset_gpio);
271 	}
272 
273 	ctx->tp_rstn_gpio = devm_gpiod_get(dev, "mantix,tp-rstn", GPIOD_OUT_HIGH);
274 	if (IS_ERR(ctx->tp_rstn_gpio)) {
275 		dev_err(dev, "cannot get tp-rstn gpio\n");
276 		return PTR_ERR(ctx->tp_rstn_gpio);
277 	}
278 
279 	mipi_dsi_set_drvdata(dsi, ctx);
280 	ctx->dev = dev;
281 
282 	dsi->lanes = 4;
283 	dsi->format = MIPI_DSI_FMT_RGB888;
284 	dsi->mode_flags = MIPI_DSI_MODE_VIDEO |
285 		MIPI_DSI_MODE_VIDEO_BURST | MIPI_DSI_MODE_VIDEO_SYNC_PULSE;
286 
287 	ctx->avdd = devm_regulator_get(dev, "avdd");
288 	if (IS_ERR(ctx->avdd))
289 		return dev_err_probe(dev, PTR_ERR(ctx->avdd), "Failed to request avdd regulator\n");
290 
291 	ctx->avee = devm_regulator_get(dev, "avee");
292 	if (IS_ERR(ctx->avee))
293 		return dev_err_probe(dev, PTR_ERR(ctx->avee), "Failed to request avee regulator\n");
294 
295 	ctx->vddi = devm_regulator_get(dev, "vddi");
296 	if (IS_ERR(ctx->vddi))
297 		return dev_err_probe(dev, PTR_ERR(ctx->vddi), "Failed to request vddi regulator\n");
298 
299 	drm_panel_init(&ctx->panel, dev, &mantix_drm_funcs,
300 		       DRM_MODE_CONNECTOR_DSI);
301 
302 	ret = drm_panel_of_backlight(&ctx->panel);
303 	if (ret)
304 		return ret;
305 
306 	drm_panel_add(&ctx->panel);
307 
308 	ret = mipi_dsi_attach(dsi);
309 	if (ret < 0) {
310 		dev_err(dev, "mipi_dsi_attach failed (%d). Is host ready?\n", ret);
311 		drm_panel_remove(&ctx->panel);
312 		return ret;
313 	}
314 
315 	dev_info(dev, "%ux%u@%u %ubpp dsi %udl - ready\n",
316 		 ctx->default_mode->hdisplay, ctx->default_mode->vdisplay,
317 		 drm_mode_vrefresh(ctx->default_mode),
318 		 mipi_dsi_pixel_format_to_bpp(dsi->format), dsi->lanes);
319 
320 	return 0;
321 }
322 
mantix_shutdown(struct mipi_dsi_device * dsi)323 static void mantix_shutdown(struct mipi_dsi_device *dsi)
324 {
325 	struct mantix *ctx = mipi_dsi_get_drvdata(dsi);
326 
327 	drm_panel_unprepare(&ctx->panel);
328 	drm_panel_disable(&ctx->panel);
329 }
330 
mantix_remove(struct mipi_dsi_device * dsi)331 static void mantix_remove(struct mipi_dsi_device *dsi)
332 {
333 	struct mantix *ctx = mipi_dsi_get_drvdata(dsi);
334 
335 	mantix_shutdown(dsi);
336 
337 	mipi_dsi_detach(dsi);
338 	drm_panel_remove(&ctx->panel);
339 }
340 
341 static const struct of_device_id mantix_of_match[] = {
342 	{ .compatible = "mantix,mlaf057we51-x", .data = &default_mode_mantix },
343 	{ .compatible = "ys,ys57pss36bh5gq", .data = &default_mode_ys },
344 	{ /* sentinel */ }
345 };
346 MODULE_DEVICE_TABLE(of, mantix_of_match);
347 
348 static struct mipi_dsi_driver mantix_driver = {
349 	.probe	= mantix_probe,
350 	.remove = mantix_remove,
351 	.shutdown = mantix_shutdown,
352 	.driver = {
353 		.name = DRV_NAME,
354 		.of_match_table = mantix_of_match,
355 	},
356 };
357 module_mipi_dsi_driver(mantix_driver);
358 
359 MODULE_AUTHOR("Guido Günther <agx@sigxcpu.org>");
360 MODULE_DESCRIPTION("DRM driver for Mantix MLAF057WE51-X MIPI DSI panel");
361 MODULE_LICENSE("GPL v2");
362