1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Novatek NT35510 panel driver
4 * Copyright (C) 2020 Linus Walleij <linus.walleij@linaro.org>
5 * Based on code by Robert Teather (C) 2012 Samsung
6 *
7 * This display driver (and I refer to the physical component NT35510,
8 * not this Linux kernel software driver) can handle:
9 * 480x864, 480x854, 480x800, 480x720 and 480x640 pixel displays.
10 * It has 480x840x24bit SRAM embedded for storing a frame.
11 * When powered on the display is by default in 480x800 mode.
12 *
13 * The actual panels using this component have different names, but
14 * the code needed to set up and configure the panel will be similar,
15 * so they should all use the NT35510 driver with appropriate configuration
16 * per-panel, e.g. for physical size.
17 *
18 * This driver is for the DSI interface to panels using the NT35510.
19 *
20 * The NT35510 can also use an RGB (DPI) interface combined with an
21 * I2C or SPI interface for setting up the NT35510. If this is needed
22 * this panel driver should be refactored to also support that use
23 * case.
24 */
25 #include <linux/backlight.h>
26 #include <linux/bitops.h>
27 #include <linux/gpio/consumer.h>
28 #include <linux/module.h>
29 #include <linux/of_device.h>
30 #include <linux/regmap.h>
31 #include <linux/regulator/consumer.h>
32
33 #include <video/mipi_display.h>
34
35 #include <drm/drm_mipi_dsi.h>
36 #include <drm/drm_modes.h>
37 #include <drm/drm_panel.h>
38
39 #define MCS_CMD_MAUCCTR 0xF0 /* Manufacturer command enable */
40 #define MCS_CMD_READ_ID1 0xDA
41 #define MCS_CMD_READ_ID2 0xDB
42 #define MCS_CMD_READ_ID3 0xDC
43 #define MCS_CMD_MTP_READ_SETTING 0xF8 /* Uncertain about name */
44 #define MCS_CMD_MTP_READ_PARAM 0xFF /* Uncertain about name */
45
46 /*
47 * These manufacturer commands are available after we enable manufacturer
48 * command set (MCS) for page 0.
49 */
50 #define NT35510_P0_DOPCTR 0xB1
51 #define NT35510_P0_SDHDTCTR 0xB6
52 #define NT35510_P0_GSEQCTR 0xB7
53 #define NT35510_P0_SDEQCTR 0xB8
54 #define NT35510_P0_SDVPCTR 0xBA
55 #define NT35510_P0_DPFRCTR1 0xBD
56 #define NT35510_P0_DPFRCTR2 0xBE
57 #define NT35510_P0_DPFRCTR3 0xBF
58 #define NT35510_P0_DPMCTR12 0xCC
59
60 #define NT35510_P0_DOPCTR_LEN 2
61 #define NT35510_P0_GSEQCTR_LEN 2
62 #define NT35510_P0_SDEQCTR_LEN 4
63 #define NT35510_P0_SDVPCTR_LEN 1
64 #define NT35510_P0_DPFRCTR1_LEN 5
65 #define NT35510_P0_DPFRCTR2_LEN 5
66 #define NT35510_P0_DPFRCTR3_LEN 5
67 #define NT35510_P0_DPMCTR12_LEN 3
68
69 #define NT35510_DOPCTR_0_RAMKP BIT(7) /* Contents kept in sleep */
70 #define NT35510_DOPCTR_0_DSITE BIT(6) /* Enable TE signal */
71 #define NT35510_DOPCTR_0_DSIG BIT(5) /* Enable generic read/write */
72 #define NT35510_DOPCTR_0_DSIM BIT(4) /* Enable video mode on DSI */
73 #define NT35510_DOPCTR_0_EOTP BIT(3) /* Support EoTP */
74 #define NT35510_DOPCTR_0_N565 BIT(2) /* RGB or BGR pixel format */
75 #define NT35510_DOPCTR_1_TW_PWR_SEL BIT(4) /* TE power selector */
76 #define NT35510_DOPCTR_1_CRGB BIT(3) /* RGB or BGR byte order */
77 #define NT35510_DOPCTR_1_CTB BIT(2) /* Vertical scanning direction */
78 #define NT35510_DOPCTR_1_CRL BIT(1) /* Source driver data shift */
79 #define NT35510_P0_SDVPCTR_PRG BIT(2) /* 0 = normal operation, 1 = VGLO */
80 #define NT35510_P0_SDVPCTR_AVDD 0 /* source driver output = AVDD */
81 #define NT35510_P0_SDVPCTR_OFFCOL 1 /* source driver output = off color */
82 #define NT35510_P0_SDVPCTR_AVSS 2 /* source driver output = AVSS */
83 #define NT35510_P0_SDVPCTR_HI_Z 3 /* source driver output = High impedance */
84
85 /*
86 * These manufacturer commands are available after we enable manufacturer
87 * command set (MCS) for page 1.
88 */
89 #define NT35510_P1_SETAVDD 0xB0
90 #define NT35510_P1_SETAVEE 0xB1
91 #define NT35510_P1_SETVCL 0xB2
92 #define NT35510_P1_SETVGH 0xB3
93 #define NT35510_P1_SETVRGH 0xB4
94 #define NT35510_P1_SETVGL 0xB5
95 #define NT35510_P1_BT1CTR 0xB6
96 #define NT35510_P1_BT2CTR 0xB7
97 #define NT35510_P1_BT3CTR 0xB8
98 #define NT35510_P1_BT4CTR 0xB9 /* VGH boosting times/freq */
99 #define NT35510_P1_BT5CTR 0xBA
100 #define NT35510_P1_PFMCTR 0xBB
101 #define NT35510_P1_SETVGP 0xBC
102 #define NT35510_P1_SETVGN 0xBD
103 #define NT35510_P1_SETVCMOFF 0xBE
104 #define NT35510_P1_VGHCTR 0xBF /* VGH output ctrl */
105 #define NT35510_P1_SET_GAMMA_RED_POS 0xD1
106 #define NT35510_P1_SET_GAMMA_GREEN_POS 0xD2
107 #define NT35510_P1_SET_GAMMA_BLUE_POS 0xD3
108 #define NT35510_P1_SET_GAMMA_RED_NEG 0xD4
109 #define NT35510_P1_SET_GAMMA_GREEN_NEG 0xD5
110 #define NT35510_P1_SET_GAMMA_BLUE_NEG 0xD6
111
112 /* AVDD and AVEE setting 3 bytes */
113 #define NT35510_P1_AVDD_LEN 3
114 #define NT35510_P1_AVEE_LEN 3
115 #define NT35510_P1_VGH_LEN 3
116 #define NT35510_P1_VGL_LEN 3
117 #define NT35510_P1_VGP_LEN 3
118 #define NT35510_P1_VGN_LEN 3
119 /* BT1CTR thru BT5CTR setting 3 bytes */
120 #define NT35510_P1_BT1CTR_LEN 3
121 #define NT35510_P1_BT2CTR_LEN 3
122 #define NT35510_P1_BT4CTR_LEN 3
123 #define NT35510_P1_BT5CTR_LEN 3
124 /* 52 gamma parameters times two per color: positive and negative */
125 #define NT35510_P1_GAMMA_LEN 52
126
127 /**
128 * struct nt35510_config - the display-specific NT35510 configuration
129 *
130 * Some of the settings provide an array of bytes, A, B C which mean:
131 * A = normal / idle off mode
132 * B = idle on mode
133 * C = partial / idle off mode
134 *
135 * Gamma correction arrays are 10bit numbers, two consecutive bytes
136 * makes out one point on the gamma correction curve. The points are
137 * not linearly placed along the X axis, we get points 0, 1, 3, 5
138 * 7, 11, 15, 23, 31, 47, 63, 95, 127, 128, 160, 192, 208, 224, 232,
139 * 240, 244, 248, 250, 252, 254, 255. The voltages tuples form
140 * V0, V1, V3 ... V255, with 0x0000 being the lowest voltage and
141 * 0x03FF being the highest voltage.
142 *
143 * Each value must be strictly higher than the previous value forming
144 * a rising curve like this:
145 *
146 * ^
147 * | V255
148 * | V254
149 * | ....
150 * | V5
151 * | V3
152 * | V1
153 * | V0
154 * +------------------------------------------->
155 *
156 * The details about all settings can be found in the NT35510 Application
157 * Note.
158 */
159 struct nt35510_config {
160 /**
161 * @width_mm: physical panel width [mm]
162 */
163 u32 width_mm;
164 /**
165 * @height_mm: physical panel height [mm]
166 */
167 u32 height_mm;
168 /**
169 * @mode: the display mode. This is only relevant outside the panel
170 * in video mode: in command mode this is configuring the internal
171 * timing in the display controller.
172 */
173 const struct drm_display_mode mode;
174 /**
175 * @avdd: setting for AVDD ranging from 0x00 = 6.5V to 0x14 = 4.5V
176 * in 0.1V steps the default is 0x05 which means 6.0V
177 */
178 u8 avdd[NT35510_P1_AVDD_LEN];
179 /**
180 * @bt1ctr: setting for boost power control for the AVDD step-up
181 * circuit (1)
182 * bits 0..2 in the lower nibble controls PCK, the booster clock
183 * frequency for the step-up circuit:
184 * 0 = Hsync/32
185 * 1 = Hsync/16
186 * 2 = Hsync/8
187 * 3 = Hsync/4
188 * 4 = Hsync/2
189 * 5 = Hsync
190 * 6 = Hsync x 2
191 * 7 = Hsync x 4
192 * bits 4..6 in the upper nibble controls BTP, the boosting
193 * amplification for the the step-up circuit:
194 * 0 = Disable
195 * 1 = 1.5 x VDDB
196 * 2 = 1.66 x VDDB
197 * 3 = 2 x VDDB
198 * 4 = 2.5 x VDDB
199 * 5 = 3 x VDDB
200 * The defaults are 4 and 4 yielding 0x44
201 */
202 u8 bt1ctr[NT35510_P1_BT1CTR_LEN];
203 /**
204 * @avee: setting for AVEE ranging from 0x00 = -6.5V to 0x14 = -4.5V
205 * in 0.1V steps the default is 0x05 which means -6.0V
206 */
207 u8 avee[NT35510_P1_AVEE_LEN];
208 /**
209 * @bt2ctr: setting for boost power control for the AVEE step-up
210 * circuit (2)
211 * bits 0..2 in the lower nibble controls NCK, the booster clock
212 * frequency, the values are the same as for PCK in @bt1ctr.
213 * bits 4..5 in the upper nibble controls BTN, the boosting
214 * amplification for the the step-up circuit.
215 * 0 = Disable
216 * 1 = -1.5 x VDDB
217 * 2 = -2 x VDDB
218 * 3 = -2.5 x VDDB
219 * 4 = -3 x VDDB
220 * The defaults are 4 and 3 yielding 0x34
221 */
222 u8 bt2ctr[NT35510_P1_BT2CTR_LEN];
223 /**
224 * @vgh: setting for VGH ranging from 0x00 = 7.0V to 0x0B = 18.0V
225 * in 1V steps, the default is 0x08 which means 15V
226 */
227 u8 vgh[NT35510_P1_VGH_LEN];
228 /**
229 * @bt4ctr: setting for boost power control for the VGH step-up
230 * circuit (4)
231 * bits 0..2 in the lower nibble controls HCK, the booster clock
232 * frequency, the values are the same as for PCK in @bt1ctr.
233 * bits 4..5 in the upper nibble controls BTH, the boosting
234 * amplification for the the step-up circuit.
235 * 0 = AVDD + VDDB
236 * 1 = AVDD - AVEE
237 * 2 = AVDD - AVEE + VDDB
238 * 3 = AVDD x 2 - AVEE
239 * The defaults are 4 and 3 yielding 0x34
240 */
241 u8 bt4ctr[NT35510_P1_BT4CTR_LEN];
242 /**
243 * @vgl: setting for VGL ranging from 0x00 = -2V to 0x0f = -15V in
244 * 1V steps, the default is 0x08 which means -10V
245 */
246 u8 vgl[NT35510_P1_VGL_LEN];
247 /**
248 * @bt5ctr: setting for boost power control for the VGL step-up
249 * circuit (5)
250 * bits 0..2 in the lower nibble controls LCK, the booster clock
251 * frequency, the values are the same as for PCK in @bt1ctr.
252 * bits 4..5 in the upper nibble controls BTL, the boosting
253 * amplification for the the step-up circuit.
254 * 0 = AVEE + VCL
255 * 1 = AVEE - AVDD
256 * 2 = AVEE + VCL - AVDD
257 * 3 = AVEE x 2 - AVDD
258 * The defaults are 3 and 2 yielding 0x32
259 */
260 u8 bt5ctr[NT35510_P1_BT5CTR_LEN];
261 /**
262 * @vgp: setting for VGP, the positive gamma divider voltages
263 * VGMP the high voltage and VGSP the low voltage.
264 * The first byte contains bit 8 of VGMP and VGSP in bits 4 and 0
265 * The second byte contains bit 0..7 of VGMP
266 * The third byte contains bit 0..7 of VGSP
267 * VGMP 0x00 = 3.0V .. 0x108 = 6.3V in steps of 12.5mV
268 * VGSP 0x00 = 0V .. 0x111 = 3.7V in steps of 12.5mV
269 */
270 u8 vgp[NT35510_P1_VGP_LEN];
271 /**
272 * @vgn: setting for VGN, the negative gamma divider voltages,
273 * same layout of bytes as @vgp.
274 */
275 u8 vgn[NT35510_P1_VGN_LEN];
276 /**
277 * @sdeqctr: Source driver control settings, first byte is
278 * 0 for mode 1 and 1 for mode 2. Mode 1 uses two steps and
279 * mode 2 uses three steps meaning EQS3 is not used in mode
280 * 1. Mode 2 is default. The last three parameters are EQS1, EQS2
281 * and EQS3, setting the rise time for each equalizer step:
282 * 0x00 = 0.0 us to 0x0f = 7.5 us in steps of 0.5us. The default
283 * is 0x07 = 3.5 us.
284 */
285 u8 sdeqctr[NT35510_P0_SDEQCTR_LEN];
286 /**
287 * @sdvpctr: power/voltage behaviour during vertical porch time
288 */
289 u8 sdvpctr;
290 /**
291 * @t1: the number of pixel clocks on one scanline, range
292 * 0x100 (258 ticks) .. 0x3FF (1024 ticks) so the value + 1
293 * clock ticks.
294 */
295 u16 t1;
296 /**
297 * @vbp: vertical back porch toward the PANEL note: not toward
298 * the DSI host; these are separate interfaces, in from DSI host
299 * and out to the panel.
300 */
301 u8 vbp;
302 /**
303 * @vfp: vertical front porch toward the PANEL.
304 */
305 u8 vfp;
306 /**
307 * @psel: pixel clock divisor: 0 = 1, 1 = 2, 2 = 4, 3 = 8.
308 */
309 u8 psel;
310 /**
311 * @dpmctr12: Display timing control 12
312 * Byte 1 bit 4 selects LVGL voltage level: 0 = VGLX, 1 = VGL_REG
313 * Byte 1 bit 1 selects gate signal mode: 0 = non-overlap, 1 = overlap
314 * Byte 1 bit 0 selects output signal control R/L swap, 0 = normal
315 * 1 = swap all O->E, L->R
316 * Byte 2 is CLW delay clock for CK O/E and CKB O/E signals:
317 * 0x00 = 0us .. 0xFF = 12.75us in 0.05us steps
318 * Byte 3 is FTI_H0 delay time for STP O/E signals:
319 * 0x00 = 0us .. 0xFF = 12.75us in 0.05us steps
320 */
321 u8 dpmctr12[NT35510_P0_DPMCTR12_LEN];
322 /**
323 * @gamma_corr_pos_r: Red gamma correction parameters, positive
324 */
325 u8 gamma_corr_pos_r[NT35510_P1_GAMMA_LEN];
326 /**
327 * @gamma_corr_pos_g: Green gamma correction parameters, positive
328 */
329 u8 gamma_corr_pos_g[NT35510_P1_GAMMA_LEN];
330 /**
331 * @gamma_corr_pos_b: Blue gamma correction parameters, positive
332 */
333 u8 gamma_corr_pos_b[NT35510_P1_GAMMA_LEN];
334 /**
335 * @gamma_corr_neg_r: Red gamma correction parameters, negative
336 */
337 u8 gamma_corr_neg_r[NT35510_P1_GAMMA_LEN];
338 /**
339 * @gamma_corr_neg_g: Green gamma correction parameters, negative
340 */
341 u8 gamma_corr_neg_g[NT35510_P1_GAMMA_LEN];
342 /**
343 * @gamma_corr_neg_b: Blue gamma correction parameters, negative
344 */
345 u8 gamma_corr_neg_b[NT35510_P1_GAMMA_LEN];
346 };
347
348 /**
349 * struct nt35510 - state container for the NT35510 panel
350 */
351 struct nt35510 {
352 /**
353 * @dev: the container device
354 */
355 struct device *dev;
356 /**
357 * @conf: the specific panel configuration, as the NT35510
358 * can be combined with many physical panels, they can have
359 * different physical dimensions and gamma correction etc,
360 * so this is stored in the config.
361 */
362 const struct nt35510_config *conf;
363 /**
364 * @panel: the DRM panel object for the instance
365 */
366 struct drm_panel panel;
367 /**
368 * @supplies: regulators supplying the panel
369 */
370 struct regulator_bulk_data supplies[2];
371 /**
372 * @reset_gpio: the reset line
373 */
374 struct gpio_desc *reset_gpio;
375 };
376
377 /* Manufacturer command has strictly this byte sequence */
378 static const u8 nt35510_mauc_mtp_read_param[] = { 0xAA, 0x55, 0x25, 0x01 };
379 static const u8 nt35510_mauc_mtp_read_setting[] = { 0x01, 0x02, 0x00, 0x20,
380 0x33, 0x13, 0x00, 0x40,
381 0x00, 0x00, 0x23, 0x02 };
382 static const u8 nt35510_mauc_select_page_0[] = { 0x55, 0xAA, 0x52, 0x08, 0x00 };
383 static const u8 nt35510_mauc_select_page_1[] = { 0x55, 0xAA, 0x52, 0x08, 0x01 };
384 static const u8 nt35510_vgh_on[] = { 0x01 };
385
panel_to_nt35510(struct drm_panel * panel)386 static inline struct nt35510 *panel_to_nt35510(struct drm_panel *panel)
387 {
388 return container_of(panel, struct nt35510, panel);
389 }
390
391 #define NT35510_ROTATE_0_SETTING 0x02
392 #define NT35510_ROTATE_180_SETTING 0x00
393
nt35510_send_long(struct nt35510 * nt,struct mipi_dsi_device * dsi,u8 cmd,u8 cmdlen,const u8 * seq)394 static int nt35510_send_long(struct nt35510 *nt, struct mipi_dsi_device *dsi,
395 u8 cmd, u8 cmdlen, const u8 *seq)
396 {
397 const u8 *seqp = seq;
398 int cmdwritten = 0;
399 int chunk = cmdlen;
400 int ret;
401
402 if (chunk > 15)
403 chunk = 15;
404 ret = mipi_dsi_dcs_write(dsi, cmd, seqp, chunk);
405 if (ret < 0) {
406 dev_err(nt->dev, "error sending DCS command seq cmd %02x\n", cmd);
407 return ret;
408 }
409 cmdwritten += chunk;
410 seqp += chunk;
411
412 while (cmdwritten < cmdlen) {
413 chunk = cmdlen - cmdwritten;
414 if (chunk > 15)
415 chunk = 15;
416 ret = mipi_dsi_generic_write(dsi, seqp, chunk);
417 if (ret < 0) {
418 dev_err(nt->dev, "error sending generic write seq %02x\n", cmd);
419 return ret;
420 }
421 cmdwritten += chunk;
422 seqp += chunk;
423 }
424 dev_dbg(nt->dev, "sent command %02x %02x bytes\n", cmd, cmdlen);
425 return 0;
426 }
427
nt35510_read_id(struct nt35510 * nt)428 static int nt35510_read_id(struct nt35510 *nt)
429 {
430 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
431 u8 id1, id2, id3;
432 int ret;
433
434 ret = mipi_dsi_dcs_read(dsi, MCS_CMD_READ_ID1, &id1, 1);
435 if (ret < 0) {
436 dev_err(nt->dev, "could not read MTP ID1\n");
437 return ret;
438 }
439 ret = mipi_dsi_dcs_read(dsi, MCS_CMD_READ_ID2, &id2, 1);
440 if (ret < 0) {
441 dev_err(nt->dev, "could not read MTP ID2\n");
442 return ret;
443 }
444 ret = mipi_dsi_dcs_read(dsi, MCS_CMD_READ_ID3, &id3, 1);
445 if (ret < 0) {
446 dev_err(nt->dev, "could not read MTP ID3\n");
447 return ret;
448 }
449
450 /*
451 * Multi-Time Programmable (?) memory contains manufacturer
452 * ID (e.g. Hydis 0x55), driver ID (e.g. NT35510 0xc0) and
453 * version.
454 */
455 dev_info(nt->dev, "MTP ID manufacturer: %02x version: %02x driver: %02x\n", id1, id2, id3);
456
457 return 0;
458 }
459
460 /**
461 * nt35510_setup_power() - set up power config in page 1
462 * @nt: the display instance to set up
463 */
nt35510_setup_power(struct nt35510 * nt)464 static int nt35510_setup_power(struct nt35510 *nt)
465 {
466 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
467 int ret;
468
469 ret = nt35510_send_long(nt, dsi, NT35510_P1_SETAVDD,
470 NT35510_P1_AVDD_LEN,
471 nt->conf->avdd);
472 if (ret)
473 return ret;
474 ret = nt35510_send_long(nt, dsi, NT35510_P1_BT1CTR,
475 NT35510_P1_BT1CTR_LEN,
476 nt->conf->bt1ctr);
477 if (ret)
478 return ret;
479 ret = nt35510_send_long(nt, dsi, NT35510_P1_SETAVEE,
480 NT35510_P1_AVEE_LEN,
481 nt->conf->avee);
482 if (ret)
483 return ret;
484 ret = nt35510_send_long(nt, dsi, NT35510_P1_BT2CTR,
485 NT35510_P1_BT2CTR_LEN,
486 nt->conf->bt2ctr);
487 if (ret)
488 return ret;
489 ret = nt35510_send_long(nt, dsi, NT35510_P1_SETVGH,
490 NT35510_P1_VGH_LEN,
491 nt->conf->vgh);
492 if (ret)
493 return ret;
494 ret = nt35510_send_long(nt, dsi, NT35510_P1_BT4CTR,
495 NT35510_P1_BT4CTR_LEN,
496 nt->conf->bt4ctr);
497 if (ret)
498 return ret;
499 ret = nt35510_send_long(nt, dsi, NT35510_P1_VGHCTR,
500 ARRAY_SIZE(nt35510_vgh_on),
501 nt35510_vgh_on);
502 if (ret)
503 return ret;
504 ret = nt35510_send_long(nt, dsi, NT35510_P1_SETVGL,
505 NT35510_P1_VGL_LEN,
506 nt->conf->vgl);
507 if (ret)
508 return ret;
509 ret = nt35510_send_long(nt, dsi, NT35510_P1_BT5CTR,
510 NT35510_P1_BT5CTR_LEN,
511 nt->conf->bt5ctr);
512 if (ret)
513 return ret;
514 ret = nt35510_send_long(nt, dsi, NT35510_P1_SETVGP,
515 NT35510_P1_VGP_LEN,
516 nt->conf->vgp);
517 if (ret)
518 return ret;
519 ret = nt35510_send_long(nt, dsi, NT35510_P1_SETVGN,
520 NT35510_P1_VGN_LEN,
521 nt->conf->vgn);
522 if (ret)
523 return ret;
524
525 /* Typically 10 ms */
526 usleep_range(10000, 20000);
527
528 return 0;
529 }
530
531 /**
532 * nt35510_setup_display() - set up display config in page 0
533 * @nt: the display instance to set up
534 */
nt35510_setup_display(struct nt35510 * nt)535 static int nt35510_setup_display(struct nt35510 *nt)
536 {
537 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
538 const struct nt35510_config *conf = nt->conf;
539 u8 dopctr[NT35510_P0_DOPCTR_LEN];
540 u8 gseqctr[NT35510_P0_GSEQCTR_LEN];
541 u8 dpfrctr[NT35510_P0_DPFRCTR1_LEN];
542 /* FIXME: set up any rotation (assume none for now) */
543 u8 addr_mode = NT35510_ROTATE_0_SETTING;
544 u8 val;
545 int ret;
546
547 /* Enable TE, EoTP and RGB pixel format */
548 dopctr[0] = NT35510_DOPCTR_0_DSITE | NT35510_DOPCTR_0_EOTP |
549 NT35510_DOPCTR_0_N565;
550 dopctr[1] = NT35510_DOPCTR_1_CTB;
551 ret = nt35510_send_long(nt, dsi, NT35510_P0_DOPCTR,
552 NT35510_P0_DOPCTR_LEN,
553 dopctr);
554 if (ret)
555 return ret;
556
557 ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_ADDRESS_MODE, &addr_mode,
558 sizeof(addr_mode));
559 if (ret < 0)
560 return ret;
561
562 /*
563 * Source data hold time, default 0x05 = 2.5us
564 * 0x00..0x3F = 0 .. 31.5us in steps of 0.5us
565 * 0x0A = 5us
566 */
567 val = 0x0A;
568 ret = mipi_dsi_dcs_write(dsi, NT35510_P0_SDHDTCTR, &val,
569 sizeof(val));
570 if (ret < 0)
571 return ret;
572
573 /* EQ control for gate signals, 0x00 = 0 us */
574 gseqctr[0] = 0x00;
575 gseqctr[1] = 0x00;
576 ret = nt35510_send_long(nt, dsi, NT35510_P0_GSEQCTR,
577 NT35510_P0_GSEQCTR_LEN,
578 gseqctr);
579 if (ret)
580 return ret;
581
582 ret = nt35510_send_long(nt, dsi, NT35510_P0_SDEQCTR,
583 NT35510_P0_SDEQCTR_LEN,
584 conf->sdeqctr);
585 if (ret)
586 return ret;
587
588 ret = mipi_dsi_dcs_write(dsi, NT35510_P0_SDVPCTR,
589 &conf->sdvpctr, 1);
590 if (ret < 0)
591 return ret;
592
593 /*
594 * Display timing control for active and idle off mode:
595 * the first byte contains
596 * the two high bits of T1A and second byte the low 8 bits, and
597 * the valid range is 0x100 (257) to 0x3ff (1023) representing
598 * 258..1024 (+1) pixel clock ticks for one scanline. At 20MHz pixel
599 * clock this covers the range of 12.90us .. 51.20us in steps of
600 * 0.05us, the default is 0x184 (388) representing 389 ticks.
601 * The third byte is VBPDA, vertical back porch display active
602 * and the fourth VFPDA, vertical front porch display active,
603 * both given in number of scanlines in the range 0x02..0xff
604 * for 2..255 scanlines. The fifth byte is 2 bits selecting
605 * PSEL for active and idle off mode, how much the 20MHz clock
606 * is divided by 0..3. This needs to be adjusted to get the right
607 * frame rate.
608 */
609 dpfrctr[0] = (conf->t1 >> 8) & 0xFF;
610 dpfrctr[1] = conf->t1 & 0xFF;
611 /* Vertical back porch */
612 dpfrctr[2] = conf->vbp;
613 /* Vertical front porch */
614 dpfrctr[3] = conf->vfp;
615 dpfrctr[4] = conf->psel;
616 ret = nt35510_send_long(nt, dsi, NT35510_P0_DPFRCTR1,
617 NT35510_P0_DPFRCTR1_LEN,
618 dpfrctr);
619 if (ret)
620 return ret;
621 /* For idle and partial idle off mode we decrease front porch by one */
622 dpfrctr[3]--;
623 ret = nt35510_send_long(nt, dsi, NT35510_P0_DPFRCTR2,
624 NT35510_P0_DPFRCTR2_LEN,
625 dpfrctr);
626 if (ret)
627 return ret;
628 ret = nt35510_send_long(nt, dsi, NT35510_P0_DPFRCTR3,
629 NT35510_P0_DPFRCTR3_LEN,
630 dpfrctr);
631 if (ret)
632 return ret;
633
634 /* Enable TE on vblank */
635 ret = mipi_dsi_dcs_set_tear_on(dsi, MIPI_DSI_DCS_TEAR_MODE_VBLANK);
636 if (ret)
637 return ret;
638
639 /* Turn on the pads? */
640 ret = nt35510_send_long(nt, dsi, NT35510_P0_DPMCTR12,
641 NT35510_P0_DPMCTR12_LEN,
642 conf->dpmctr12);
643 if (ret)
644 return ret;
645
646 return 0;
647 }
648
nt35510_set_brightness(struct backlight_device * bl)649 static int nt35510_set_brightness(struct backlight_device *bl)
650 {
651 struct nt35510 *nt = bl_get_data(bl);
652 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
653 u8 brightness = bl->props.brightness;
654 int ret;
655
656 dev_dbg(nt->dev, "set brightness %d\n", brightness);
657 ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
658 &brightness,
659 sizeof(brightness));
660 if (ret < 0)
661 return ret;
662
663 return 0;
664 }
665
666 static const struct backlight_ops nt35510_bl_ops = {
667 .update_status = nt35510_set_brightness,
668 };
669
670 /*
671 * This power-on sequence
672 */
nt35510_power_on(struct nt35510 * nt)673 static int nt35510_power_on(struct nt35510 *nt)
674 {
675 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
676 int ret;
677
678 ret = regulator_bulk_enable(ARRAY_SIZE(nt->supplies), nt->supplies);
679 if (ret < 0) {
680 dev_err(nt->dev, "unable to enable regulators\n");
681 return ret;
682 }
683
684 /* Toggle RESET in accordance with datasheet page 370 */
685 if (nt->reset_gpio) {
686 gpiod_set_value(nt->reset_gpio, 1);
687 /* Active min 10 us according to datasheet, let's say 20 */
688 usleep_range(20, 1000);
689 gpiod_set_value(nt->reset_gpio, 0);
690 /*
691 * 5 ms during sleep mode, 120 ms during sleep out mode
692 * according to datasheet, let's use 120-140 ms.
693 */
694 usleep_range(120000, 140000);
695 }
696
697 ret = nt35510_send_long(nt, dsi, MCS_CMD_MTP_READ_PARAM,
698 ARRAY_SIZE(nt35510_mauc_mtp_read_param),
699 nt35510_mauc_mtp_read_param);
700 if (ret)
701 return ret;
702
703 ret = nt35510_send_long(nt, dsi, MCS_CMD_MTP_READ_SETTING,
704 ARRAY_SIZE(nt35510_mauc_mtp_read_setting),
705 nt35510_mauc_mtp_read_setting);
706 if (ret)
707 return ret;
708
709 ret = nt35510_read_id(nt);
710 if (ret)
711 return ret;
712
713 /* Set up stuff in manufacturer control, page 1 */
714 ret = nt35510_send_long(nt, dsi, MCS_CMD_MAUCCTR,
715 ARRAY_SIZE(nt35510_mauc_select_page_1),
716 nt35510_mauc_select_page_1);
717 if (ret)
718 return ret;
719
720 ret = nt35510_setup_power(nt);
721 if (ret)
722 return ret;
723
724 ret = nt35510_send_long(nt, dsi, NT35510_P1_SET_GAMMA_RED_POS,
725 NT35510_P1_GAMMA_LEN,
726 nt->conf->gamma_corr_pos_r);
727 if (ret)
728 return ret;
729 ret = nt35510_send_long(nt, dsi, NT35510_P1_SET_GAMMA_GREEN_POS,
730 NT35510_P1_GAMMA_LEN,
731 nt->conf->gamma_corr_pos_g);
732 if (ret)
733 return ret;
734 ret = nt35510_send_long(nt, dsi, NT35510_P1_SET_GAMMA_BLUE_POS,
735 NT35510_P1_GAMMA_LEN,
736 nt->conf->gamma_corr_pos_b);
737 if (ret)
738 return ret;
739 ret = nt35510_send_long(nt, dsi, NT35510_P1_SET_GAMMA_RED_NEG,
740 NT35510_P1_GAMMA_LEN,
741 nt->conf->gamma_corr_neg_r);
742 if (ret)
743 return ret;
744 ret = nt35510_send_long(nt, dsi, NT35510_P1_SET_GAMMA_GREEN_NEG,
745 NT35510_P1_GAMMA_LEN,
746 nt->conf->gamma_corr_neg_g);
747 if (ret)
748 return ret;
749 ret = nt35510_send_long(nt, dsi, NT35510_P1_SET_GAMMA_BLUE_NEG,
750 NT35510_P1_GAMMA_LEN,
751 nt->conf->gamma_corr_neg_b);
752 if (ret)
753 return ret;
754
755 /* Set up stuff in manufacturer control, page 0 */
756 ret = nt35510_send_long(nt, dsi, MCS_CMD_MAUCCTR,
757 ARRAY_SIZE(nt35510_mauc_select_page_0),
758 nt35510_mauc_select_page_0);
759 if (ret)
760 return ret;
761
762 ret = nt35510_setup_display(nt);
763 if (ret)
764 return ret;
765
766 return 0;
767 }
768
nt35510_power_off(struct nt35510 * nt)769 static int nt35510_power_off(struct nt35510 *nt)
770 {
771 int ret;
772
773 ret = regulator_bulk_disable(ARRAY_SIZE(nt->supplies), nt->supplies);
774 if (ret)
775 return ret;
776
777 if (nt->reset_gpio)
778 gpiod_set_value(nt->reset_gpio, 1);
779
780 return 0;
781 }
782
nt35510_unprepare(struct drm_panel * panel)783 static int nt35510_unprepare(struct drm_panel *panel)
784 {
785 struct nt35510 *nt = panel_to_nt35510(panel);
786 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
787 int ret;
788
789 ret = mipi_dsi_dcs_set_display_off(dsi);
790 if (ret) {
791 dev_err(nt->dev, "failed to turn display off (%d)\n", ret);
792 return ret;
793 }
794 usleep_range(10000, 20000);
795
796 /* Enter sleep mode */
797 ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
798 if (ret) {
799 dev_err(nt->dev, "failed to enter sleep mode (%d)\n", ret);
800 return ret;
801 }
802
803 /* Wait 4 frames, how much is that 5ms in the vendor driver */
804 usleep_range(5000, 10000);
805
806 ret = nt35510_power_off(nt);
807 if (ret)
808 return ret;
809
810 return 0;
811 }
812
nt35510_prepare(struct drm_panel * panel)813 static int nt35510_prepare(struct drm_panel *panel)
814 {
815 struct nt35510 *nt = panel_to_nt35510(panel);
816 struct mipi_dsi_device *dsi = to_mipi_dsi_device(nt->dev);
817 int ret;
818
819 ret = nt35510_power_on(nt);
820 if (ret)
821 return ret;
822
823 /* Exit sleep mode */
824 ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
825 if (ret) {
826 dev_err(nt->dev, "failed to exit sleep mode (%d)\n", ret);
827 return ret;
828 }
829 /* Up to 120 ms */
830 usleep_range(120000, 150000);
831
832 ret = mipi_dsi_dcs_set_display_on(dsi);
833 if (ret) {
834 dev_err(nt->dev, "failed to turn display on (%d)\n", ret);
835 return ret;
836 }
837 /* Some 10 ms */
838 usleep_range(10000, 20000);
839
840 return 0;
841 }
842
nt35510_get_modes(struct drm_panel * panel,struct drm_connector * connector)843 static int nt35510_get_modes(struct drm_panel *panel,
844 struct drm_connector *connector)
845 {
846 struct nt35510 *nt = panel_to_nt35510(panel);
847 struct drm_display_mode *mode;
848 struct drm_display_info *info;
849
850 info = &connector->display_info;
851 info->width_mm = nt->conf->width_mm;
852 info->height_mm = nt->conf->height_mm;
853 mode = drm_mode_duplicate(connector->dev, &nt->conf->mode);
854 if (!mode) {
855 dev_err(panel->dev, "bad mode or failed to add mode\n");
856 return -EINVAL;
857 }
858 drm_mode_set_name(mode);
859 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
860
861 mode->width_mm = nt->conf->width_mm;
862 mode->height_mm = nt->conf->height_mm;
863 drm_mode_probed_add(connector, mode);
864
865 return 1; /* Number of modes */
866 }
867
868 static const struct drm_panel_funcs nt35510_drm_funcs = {
869 .unprepare = nt35510_unprepare,
870 .prepare = nt35510_prepare,
871 .get_modes = nt35510_get_modes,
872 };
873
nt35510_probe(struct mipi_dsi_device * dsi)874 static int nt35510_probe(struct mipi_dsi_device *dsi)
875 {
876 struct device *dev = &dsi->dev;
877 struct nt35510 *nt;
878 int ret;
879
880 nt = devm_kzalloc(dev, sizeof(struct nt35510), GFP_KERNEL);
881 if (!nt)
882 return -ENOMEM;
883 mipi_dsi_set_drvdata(dsi, nt);
884 nt->dev = dev;
885
886 dsi->lanes = 2;
887 dsi->format = MIPI_DSI_FMT_RGB888;
888 /*
889 * Datasheet suggests max HS rate for NT35510 is 250 MHz
890 * (period time 4ns, see figure 7.6.4 page 365) and max LP rate is
891 * 20 MHz (period time 50ns, see figure 7.6.6. page 366).
892 * However these frequencies appear in source code for the Hydis
893 * HVA40WV1 panel and setting up the LP frequency makes the panel
894 * not work.
895 *
896 * TODO: if other panels prove to be closer to the datasheet,
897 * maybe make this a per-panel config in struct nt35510_config?
898 */
899 dsi->hs_rate = 349440000;
900 dsi->lp_rate = 9600000;
901 dsi->mode_flags = MIPI_DSI_CLOCK_NON_CONTINUOUS;
902
903 /*
904 * Every new incarnation of this display must have a unique
905 * data entry for the system in this driver.
906 */
907 nt->conf = of_device_get_match_data(dev);
908 if (!nt->conf) {
909 dev_err(dev, "missing device configuration\n");
910 return -ENODEV;
911 }
912
913 nt->supplies[0].supply = "vdd"; /* 2.3-4.8 V */
914 nt->supplies[1].supply = "vddi"; /* 1.65-3.3V */
915 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(nt->supplies),
916 nt->supplies);
917 if (ret < 0)
918 return ret;
919 ret = regulator_set_voltage(nt->supplies[0].consumer,
920 2300000, 4800000);
921 if (ret)
922 return ret;
923 ret = regulator_set_voltage(nt->supplies[1].consumer,
924 1650000, 3300000);
925 if (ret)
926 return ret;
927
928 nt->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS);
929 if (IS_ERR(nt->reset_gpio)) {
930 dev_err(dev, "error getting RESET GPIO\n");
931 return PTR_ERR(nt->reset_gpio);
932 }
933
934 drm_panel_init(&nt->panel, dev, &nt35510_drm_funcs,
935 DRM_MODE_CONNECTOR_DSI);
936
937 /*
938 * First, try to locate an external backlight (such as on GPIO)
939 * if this fails, assume we will want to use the internal backlight
940 * control.
941 */
942 ret = drm_panel_of_backlight(&nt->panel);
943 if (ret) {
944 dev_err(dev, "error getting external backlight %d\n", ret);
945 return ret;
946 }
947 if (!nt->panel.backlight) {
948 struct backlight_device *bl;
949
950 bl = devm_backlight_device_register(dev, "nt35510", dev, nt,
951 &nt35510_bl_ops, NULL);
952 if (IS_ERR(bl)) {
953 dev_err(dev, "failed to register backlight device\n");
954 return PTR_ERR(bl);
955 }
956 bl->props.max_brightness = 255;
957 bl->props.brightness = 255;
958 bl->props.power = FB_BLANK_POWERDOWN;
959 nt->panel.backlight = bl;
960 }
961
962 drm_panel_add(&nt->panel);
963
964 ret = mipi_dsi_attach(dsi);
965 if (ret < 0)
966 drm_panel_remove(&nt->panel);
967
968 return 0;
969 }
970
nt35510_remove(struct mipi_dsi_device * dsi)971 static int nt35510_remove(struct mipi_dsi_device *dsi)
972 {
973 struct nt35510 *nt = mipi_dsi_get_drvdata(dsi);
974 int ret;
975
976 mipi_dsi_detach(dsi);
977 /* Power off */
978 ret = nt35510_power_off(nt);
979 drm_panel_remove(&nt->panel);
980
981 return ret;
982 }
983
984 /*
985 * These gamma correction values are 10bit tuples, so only bits 0 and 1 is
986 * ever used in the first byte. They form a positive and negative gamma
987 * correction curve for each color, values must be strictly higher for each
988 * step on the curve. As can be seen these default curves goes from 0x0001
989 * to 0x03FE.
990 */
991 #define NT35510_GAMMA_POS_DEFAULT 0x00, 0x01, 0x00, 0x43, 0x00, \
992 0x6B, 0x00, 0x87, 0x00, 0xA3, 0x00, 0xCE, 0x00, 0xF1, 0x01, \
993 0x27, 0x01, 0x53, 0x01, 0x98, 0x01, 0xCE, 0x02, 0x22, 0x02, \
994 0x83, 0x02, 0x78, 0x02, 0x9E, 0x02, 0xDD, 0x03, 0x00, 0x03, \
995 0x2E, 0x03, 0x54, 0x03, 0x7F, 0x03, 0x95, 0x03, 0xB3, 0x03, \
996 0xC2, 0x03, 0xE1, 0x03, 0xF1, 0x03, 0xFE
997
998 #define NT35510_GAMMA_NEG_DEFAULT 0x00, 0x01, 0x00, 0x43, 0x00, \
999 0x6B, 0x00, 0x87, 0x00, 0xA3, 0x00, 0xCE, 0x00, 0xF1, 0x01, \
1000 0x27, 0x01, 0x53, 0x01, 0x98, 0x01, 0xCE, 0x02, 0x22, 0x02, \
1001 0x43, 0x02, 0x50, 0x02, 0x9E, 0x02, 0xDD, 0x03, 0x00, 0x03, \
1002 0x2E, 0x03, 0x54, 0x03, 0x7F, 0x03, 0x95, 0x03, 0xB3, 0x03, \
1003 0xC2, 0x03, 0xE1, 0x03, 0xF1, 0x03, 0xFE
1004
1005 /*
1006 * The Hydis HVA40WV1 panel
1007 */
1008 static const struct nt35510_config nt35510_hydis_hva40wv1 = {
1009 .width_mm = 52,
1010 .height_mm = 86,
1011 /**
1012 * As the Hydis panel is used in command mode, the porches etc
1013 * are settings programmed internally into the NT35510 controller
1014 * and generated toward the physical display. As the panel is not
1015 * used in video mode, these are not really exposed to the DSI
1016 * host.
1017 *
1018 * Display frame rate control:
1019 * Frame rate = (20 MHz / 1) / (389 * (7 + 50 + 800)) ~= 60 Hz
1020 */
1021 .mode = {
1022 /* The internal pixel clock of the NT35510 is 20 MHz */
1023 .clock = 20000,
1024 .hdisplay = 480,
1025 .hsync_start = 480 + 2, /* HFP = 2 */
1026 .hsync_end = 480 + 2 + 0, /* HSync = 0 */
1027 .htotal = 480 + 2 + 0 + 5, /* HFP = 5 */
1028 .vdisplay = 800,
1029 .vsync_start = 800 + 2, /* VFP = 2 */
1030 .vsync_end = 800 + 2 + 0, /* VSync = 0 */
1031 .vtotal = 800 + 2 + 0 + 5, /* VBP = 5 */
1032 .flags = 0,
1033 },
1034 /* 0x09: AVDD = 5.6V */
1035 .avdd = { 0x09, 0x09, 0x09 },
1036 /* 0x34: PCK = Hsync/2, BTP = 2 x VDDB */
1037 .bt1ctr = { 0x34, 0x34, 0x34 },
1038 /* 0x09: AVEE = -5.6V */
1039 .avee = { 0x09, 0x09, 0x09 },
1040 /* 0x24: NCK = Hsync/2, BTN = -2 x VDDB */
1041 .bt2ctr = { 0x24, 0x24, 0x24 },
1042 /* 0x05 = 12V */
1043 .vgh = { 0x05, 0x05, 0x05 },
1044 /* 0x24: NCKA = Hsync/2, VGH = 2 x AVDD - AVEE */
1045 .bt4ctr = { 0x24, 0x24, 0x24 },
1046 /* 0x0B = -13V */
1047 .vgl = { 0x0B, 0x0B, 0x0B },
1048 /* 0x24: LCKA = Hsync, VGL = AVDD + VCL - AVDD */
1049 .bt5ctr = { 0x24, 0x24, 0x24 },
1050 /* VGMP: 0x0A3 = 5.0375V, VGSP = 0V */
1051 .vgp = { 0x00, 0xA3, 0x00 },
1052 /* VGMP: 0x0A3 = 5.0375V, VGSP = 0V */
1053 .vgn = { 0x00, 0xA3, 0x00 },
1054 /* SDEQCTR: source driver EQ mode 2, 2.5 us rise time on each step */
1055 .sdeqctr = { 0x01, 0x05, 0x05, 0x05 },
1056 /* SDVPCTR: Normal operation off color during v porch */
1057 .sdvpctr = 0x01,
1058 /* T1: number of pixel clocks on one scanline: 0x184 = 389 clocks */
1059 .t1 = 0x0184,
1060 /* VBP: vertical back porch toward the panel */
1061 .vbp = 7,
1062 /* VFP: vertical front porch toward the panel */
1063 .vfp = 50,
1064 /* PSEL: divide pixel clock 20MHz with 1 (no clock downscaling) */
1065 .psel = 0,
1066 /* DPTMCTR12: 0x03: LVGL = VGLX, overlap mode, swap R->L O->E */
1067 .dpmctr12 = { 0x03, 0x00, 0x00, },
1068 /* Default gamma correction values */
1069 .gamma_corr_pos_r = { NT35510_GAMMA_POS_DEFAULT },
1070 .gamma_corr_pos_g = { NT35510_GAMMA_POS_DEFAULT },
1071 .gamma_corr_pos_b = { NT35510_GAMMA_POS_DEFAULT },
1072 .gamma_corr_neg_r = { NT35510_GAMMA_NEG_DEFAULT },
1073 .gamma_corr_neg_g = { NT35510_GAMMA_NEG_DEFAULT },
1074 .gamma_corr_neg_b = { NT35510_GAMMA_NEG_DEFAULT },
1075 };
1076
1077 static const struct of_device_id nt35510_of_match[] = {
1078 {
1079 .compatible = "hydis,hva40wv1",
1080 .data = &nt35510_hydis_hva40wv1,
1081 },
1082 { }
1083 };
1084 MODULE_DEVICE_TABLE(of, nt35510_of_match);
1085
1086 static struct mipi_dsi_driver nt35510_driver = {
1087 .probe = nt35510_probe,
1088 .remove = nt35510_remove,
1089 .driver = {
1090 .name = "panel-novatek-nt35510",
1091 .of_match_table = nt35510_of_match,
1092 },
1093 };
1094 module_mipi_dsi_driver(nt35510_driver);
1095
1096 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
1097 MODULE_DESCRIPTION("NT35510-based panel driver");
1098 MODULE_LICENSE("GPL v2");
1099