1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2022 Marek Vasut <marex@denx.de>
4 *
5 * This code is based on drivers/gpu/drm/mxsfb/mxsfb*
6 */
7
8 #include <linux/bitfield.h>
9 #include <linux/clk.h>
10 #include <linux/io.h>
11 #include <linux/iopoll.h>
12 #include <linux/media-bus-format.h>
13 #include <linux/pm_runtime.h>
14 #include <linux/spinlock.h>
15
16 #include <drm/drm_atomic.h>
17 #include <drm/drm_atomic_helper.h>
18 #include <drm/drm_bridge.h>
19 #include <drm/drm_color_mgmt.h>
20 #include <drm/drm_connector.h>
21 #include <drm/drm_crtc.h>
22 #include <drm/drm_encoder.h>
23 #include <drm/drm_fb_dma_helper.h>
24 #include <drm/drm_fourcc.h>
25 #include <drm/drm_framebuffer.h>
26 #include <drm/drm_gem_atomic_helper.h>
27 #include <drm/drm_gem_dma_helper.h>
28 #include <drm/drm_plane.h>
29 #include <drm/drm_print.h>
30 #include <drm/drm_vblank.h>
31
32 #include "lcdif_drv.h"
33 #include "lcdif_regs.h"
34
35 struct lcdif_crtc_state {
36 struct drm_crtc_state base; /* always be the first member */
37 u32 bus_format;
38 u32 bus_flags;
39 };
40
41 static inline struct lcdif_crtc_state *
to_lcdif_crtc_state(struct drm_crtc_state * s)42 to_lcdif_crtc_state(struct drm_crtc_state *s)
43 {
44 return container_of(s, struct lcdif_crtc_state, base);
45 }
46
47 /* -----------------------------------------------------------------------------
48 * CRTC
49 */
50
51 /*
52 * For conversion from YCbCr to RGB, the CSC operates as follows:
53 *
54 * |R| |A1 A2 A3| |Y + D1|
55 * |G| = |B1 B2 B3| * |Cb + D2|
56 * |B| |C1 C2 C3| |Cr + D3|
57 *
58 * The A, B and C coefficients are expressed as Q2.8 fixed point values, and
59 * the D coefficients as Q0.8. Despite the reference manual stating the
60 * opposite, the D1, D2 and D3 offset values are added to Y, Cb and Cr, not
61 * subtracted. They must thus be programmed with negative values.
62 */
63 static const u32 lcdif_yuv2rgb_coeffs[3][2][6] = {
64 [DRM_COLOR_YCBCR_BT601] = {
65 [DRM_COLOR_YCBCR_LIMITED_RANGE] = {
66 /*
67 * BT.601 limited range:
68 *
69 * |R| |1.1644 0.0000 1.5960| |Y - 16 |
70 * |G| = |1.1644 -0.3917 -0.8129| * |Cb - 128|
71 * |B| |1.1644 2.0172 0.0000| |Cr - 128|
72 */
73 CSC0_COEF0_A1(0x12a) | CSC0_COEF0_A2(0x000),
74 CSC0_COEF1_A3(0x199) | CSC0_COEF1_B1(0x12a),
75 CSC0_COEF2_B2(0x79c) | CSC0_COEF2_B3(0x730),
76 CSC0_COEF3_C1(0x12a) | CSC0_COEF3_C2(0x204),
77 CSC0_COEF4_C3(0x000) | CSC0_COEF4_D1(0x1f0),
78 CSC0_COEF5_D2(0x180) | CSC0_COEF5_D3(0x180),
79 },
80 [DRM_COLOR_YCBCR_FULL_RANGE] = {
81 /*
82 * BT.601 full range:
83 *
84 * |R| |1.0000 0.0000 1.4020| |Y - 0 |
85 * |G| = |1.0000 -0.3441 -0.7141| * |Cb - 128|
86 * |B| |1.0000 1.7720 0.0000| |Cr - 128|
87 */
88 CSC0_COEF0_A1(0x100) | CSC0_COEF0_A2(0x000),
89 CSC0_COEF1_A3(0x167) | CSC0_COEF1_B1(0x100),
90 CSC0_COEF2_B2(0x7a8) | CSC0_COEF2_B3(0x749),
91 CSC0_COEF3_C1(0x100) | CSC0_COEF3_C2(0x1c6),
92 CSC0_COEF4_C3(0x000) | CSC0_COEF4_D1(0x000),
93 CSC0_COEF5_D2(0x180) | CSC0_COEF5_D3(0x180),
94 },
95 },
96 [DRM_COLOR_YCBCR_BT709] = {
97 [DRM_COLOR_YCBCR_LIMITED_RANGE] = {
98 /*
99 * Rec.709 limited range:
100 *
101 * |R| |1.1644 0.0000 1.7927| |Y - 16 |
102 * |G| = |1.1644 -0.2132 -0.5329| * |Cb - 128|
103 * |B| |1.1644 2.1124 0.0000| |Cr - 128|
104 */
105 CSC0_COEF0_A1(0x12a) | CSC0_COEF0_A2(0x000),
106 CSC0_COEF1_A3(0x1cb) | CSC0_COEF1_B1(0x12a),
107 CSC0_COEF2_B2(0x7c9) | CSC0_COEF2_B3(0x778),
108 CSC0_COEF3_C1(0x12a) | CSC0_COEF3_C2(0x21d),
109 CSC0_COEF4_C3(0x000) | CSC0_COEF4_D1(0x1f0),
110 CSC0_COEF5_D2(0x180) | CSC0_COEF5_D3(0x180),
111 },
112 [DRM_COLOR_YCBCR_FULL_RANGE] = {
113 /*
114 * Rec.709 full range:
115 *
116 * |R| |1.0000 0.0000 1.5748| |Y - 0 |
117 * |G| = |1.0000 -0.1873 -0.4681| * |Cb - 128|
118 * |B| |1.0000 1.8556 0.0000| |Cr - 128|
119 */
120 CSC0_COEF0_A1(0x100) | CSC0_COEF0_A2(0x000),
121 CSC0_COEF1_A3(0x193) | CSC0_COEF1_B1(0x100),
122 CSC0_COEF2_B2(0x7d0) | CSC0_COEF2_B3(0x788),
123 CSC0_COEF3_C1(0x100) | CSC0_COEF3_C2(0x1db),
124 CSC0_COEF4_C3(0x000) | CSC0_COEF4_D1(0x000),
125 CSC0_COEF5_D2(0x180) | CSC0_COEF5_D3(0x180),
126 },
127 },
128 [DRM_COLOR_YCBCR_BT2020] = {
129 [DRM_COLOR_YCBCR_LIMITED_RANGE] = {
130 /*
131 * BT.2020 limited range:
132 *
133 * |R| |1.1644 0.0000 1.6787| |Y - 16 |
134 * |G| = |1.1644 -0.1874 -0.6505| * |Cb - 128|
135 * |B| |1.1644 2.1418 0.0000| |Cr - 128|
136 */
137 CSC0_COEF0_A1(0x12a) | CSC0_COEF0_A2(0x000),
138 CSC0_COEF1_A3(0x1ae) | CSC0_COEF1_B1(0x12a),
139 CSC0_COEF2_B2(0x7d0) | CSC0_COEF2_B3(0x759),
140 CSC0_COEF3_C1(0x12a) | CSC0_COEF3_C2(0x224),
141 CSC0_COEF4_C3(0x000) | CSC0_COEF4_D1(0x1f0),
142 CSC0_COEF5_D2(0x180) | CSC0_COEF5_D3(0x180),
143 },
144 [DRM_COLOR_YCBCR_FULL_RANGE] = {
145 /*
146 * BT.2020 full range:
147 *
148 * |R| |1.0000 0.0000 1.4746| |Y - 0 |
149 * |G| = |1.0000 -0.1646 -0.5714| * |Cb - 128|
150 * |B| |1.0000 1.8814 0.0000| |Cr - 128|
151 */
152 CSC0_COEF0_A1(0x100) | CSC0_COEF0_A2(0x000),
153 CSC0_COEF1_A3(0x179) | CSC0_COEF1_B1(0x100),
154 CSC0_COEF2_B2(0x7d6) | CSC0_COEF2_B3(0x76e),
155 CSC0_COEF3_C1(0x100) | CSC0_COEF3_C2(0x1e2),
156 CSC0_COEF4_C3(0x000) | CSC0_COEF4_D1(0x000),
157 CSC0_COEF5_D2(0x180) | CSC0_COEF5_D3(0x180),
158 },
159 },
160 };
161
lcdif_set_formats(struct lcdif_drm_private * lcdif,struct drm_plane_state * plane_state,const u32 bus_format)162 static void lcdif_set_formats(struct lcdif_drm_private *lcdif,
163 struct drm_plane_state *plane_state,
164 const u32 bus_format)
165 {
166 struct drm_device *drm = lcdif->drm;
167 const u32 format = plane_state->fb->format->format;
168 bool in_yuv = false;
169 bool out_yuv = false;
170
171 switch (bus_format) {
172 case MEDIA_BUS_FMT_RGB565_1X16:
173 writel(DISP_PARA_LINE_PATTERN_RGB565,
174 lcdif->base + LCDC_V8_DISP_PARA);
175 break;
176 case MEDIA_BUS_FMT_RGB888_1X24:
177 writel(DISP_PARA_LINE_PATTERN_RGB888,
178 lcdif->base + LCDC_V8_DISP_PARA);
179 break;
180 case MEDIA_BUS_FMT_UYVY8_1X16:
181 writel(DISP_PARA_LINE_PATTERN_UYVY_H,
182 lcdif->base + LCDC_V8_DISP_PARA);
183 out_yuv = true;
184 break;
185 default:
186 dev_err(drm->dev, "Unknown media bus format 0x%x\n", bus_format);
187 break;
188 }
189
190 switch (format) {
191 /* RGB Formats */
192 case DRM_FORMAT_RGB565:
193 writel(CTRLDESCL0_5_BPP_16_RGB565,
194 lcdif->base + LCDC_V8_CTRLDESCL0_5);
195 break;
196 case DRM_FORMAT_RGB888:
197 writel(CTRLDESCL0_5_BPP_24_RGB888,
198 lcdif->base + LCDC_V8_CTRLDESCL0_5);
199 break;
200 case DRM_FORMAT_XRGB1555:
201 writel(CTRLDESCL0_5_BPP_16_ARGB1555,
202 lcdif->base + LCDC_V8_CTRLDESCL0_5);
203 break;
204 case DRM_FORMAT_XRGB4444:
205 writel(CTRLDESCL0_5_BPP_16_ARGB4444,
206 lcdif->base + LCDC_V8_CTRLDESCL0_5);
207 break;
208 case DRM_FORMAT_XBGR8888:
209 writel(CTRLDESCL0_5_BPP_32_ABGR8888,
210 lcdif->base + LCDC_V8_CTRLDESCL0_5);
211 break;
212 case DRM_FORMAT_XRGB8888:
213 writel(CTRLDESCL0_5_BPP_32_ARGB8888,
214 lcdif->base + LCDC_V8_CTRLDESCL0_5);
215 break;
216
217 /* YUV Formats */
218 case DRM_FORMAT_YUYV:
219 writel(CTRLDESCL0_5_BPP_YCbCr422 | CTRLDESCL0_5_YUV_FORMAT_VY2UY1,
220 lcdif->base + LCDC_V8_CTRLDESCL0_5);
221 in_yuv = true;
222 break;
223 case DRM_FORMAT_YVYU:
224 writel(CTRLDESCL0_5_BPP_YCbCr422 | CTRLDESCL0_5_YUV_FORMAT_UY2VY1,
225 lcdif->base + LCDC_V8_CTRLDESCL0_5);
226 in_yuv = true;
227 break;
228 case DRM_FORMAT_UYVY:
229 writel(CTRLDESCL0_5_BPP_YCbCr422 | CTRLDESCL0_5_YUV_FORMAT_Y2VY1U,
230 lcdif->base + LCDC_V8_CTRLDESCL0_5);
231 in_yuv = true;
232 break;
233 case DRM_FORMAT_VYUY:
234 writel(CTRLDESCL0_5_BPP_YCbCr422 | CTRLDESCL0_5_YUV_FORMAT_Y2UY1V,
235 lcdif->base + LCDC_V8_CTRLDESCL0_5);
236 in_yuv = true;
237 break;
238
239 default:
240 dev_err(drm->dev, "Unknown pixel format 0x%x\n", format);
241 break;
242 }
243
244 /*
245 * The CSC differentiates between "YCbCr" and "YUV", but the reference
246 * manual doesn't detail how they differ. Experiments showed that the
247 * luminance value is unaffected, only the calculations involving chroma
248 * values differ. The YCbCr mode behaves as expected, with chroma values
249 * being offset by 128. The YUV mode isn't fully understood.
250 */
251 if (!in_yuv && out_yuv) {
252 /* RGB -> YCbCr */
253 writel(CSC0_CTRL_CSC_MODE_RGB2YCbCr,
254 lcdif->base + LCDC_V8_CSC0_CTRL);
255
256 /*
257 * CSC: BT.601 Limited Range RGB to YCbCr coefficients.
258 *
259 * |Y | | 0.2568 0.5041 0.0979| |R| |16 |
260 * |Cb| = |-0.1482 -0.2910 0.4392| * |G| + |128|
261 * |Cr| | 0.4392 0.4392 -0.3678| |B| |128|
262 */
263 writel(CSC0_COEF0_A2(0x081) | CSC0_COEF0_A1(0x041),
264 lcdif->base + LCDC_V8_CSC0_COEF0);
265 writel(CSC0_COEF1_B1(0x7db) | CSC0_COEF1_A3(0x019),
266 lcdif->base + LCDC_V8_CSC0_COEF1);
267 writel(CSC0_COEF2_B3(0x070) | CSC0_COEF2_B2(0x7b6),
268 lcdif->base + LCDC_V8_CSC0_COEF2);
269 writel(CSC0_COEF3_C2(0x7a2) | CSC0_COEF3_C1(0x070),
270 lcdif->base + LCDC_V8_CSC0_COEF3);
271 writel(CSC0_COEF4_D1(0x010) | CSC0_COEF4_C3(0x7ee),
272 lcdif->base + LCDC_V8_CSC0_COEF4);
273 writel(CSC0_COEF5_D3(0x080) | CSC0_COEF5_D2(0x080),
274 lcdif->base + LCDC_V8_CSC0_COEF5);
275 } else if (in_yuv && !out_yuv) {
276 /* YCbCr -> RGB */
277 const u32 *coeffs =
278 lcdif_yuv2rgb_coeffs[plane_state->color_encoding]
279 [plane_state->color_range];
280
281 writel(CSC0_CTRL_CSC_MODE_YCbCr2RGB,
282 lcdif->base + LCDC_V8_CSC0_CTRL);
283
284 writel(coeffs[0], lcdif->base + LCDC_V8_CSC0_COEF0);
285 writel(coeffs[1], lcdif->base + LCDC_V8_CSC0_COEF1);
286 writel(coeffs[2], lcdif->base + LCDC_V8_CSC0_COEF2);
287 writel(coeffs[3], lcdif->base + LCDC_V8_CSC0_COEF3);
288 writel(coeffs[4], lcdif->base + LCDC_V8_CSC0_COEF4);
289 writel(coeffs[5], lcdif->base + LCDC_V8_CSC0_COEF5);
290 } else {
291 /* RGB -> RGB, YCbCr -> YCbCr: bypass colorspace converter. */
292 writel(CSC0_CTRL_BYPASS, lcdif->base + LCDC_V8_CSC0_CTRL);
293 }
294 }
295
lcdif_set_mode(struct lcdif_drm_private * lcdif,u32 bus_flags)296 static void lcdif_set_mode(struct lcdif_drm_private *lcdif, u32 bus_flags)
297 {
298 struct drm_display_mode *m = &lcdif->crtc.state->adjusted_mode;
299 u32 ctrl = 0;
300
301 if (m->flags & DRM_MODE_FLAG_NHSYNC)
302 ctrl |= CTRL_INV_HS;
303 if (m->flags & DRM_MODE_FLAG_NVSYNC)
304 ctrl |= CTRL_INV_VS;
305 if (bus_flags & DRM_BUS_FLAG_DE_LOW)
306 ctrl |= CTRL_INV_DE;
307 if (bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE)
308 ctrl |= CTRL_INV_PXCK;
309
310 writel(ctrl, lcdif->base + LCDC_V8_CTRL);
311
312 writel(DISP_SIZE_DELTA_Y(m->vdisplay) |
313 DISP_SIZE_DELTA_X(m->hdisplay),
314 lcdif->base + LCDC_V8_DISP_SIZE);
315
316 writel(HSYN_PARA_BP_H(m->htotal - m->hsync_end) |
317 HSYN_PARA_FP_H(m->hsync_start - m->hdisplay),
318 lcdif->base + LCDC_V8_HSYN_PARA);
319
320 writel(VSYN_PARA_BP_V(m->vtotal - m->vsync_end) |
321 VSYN_PARA_FP_V(m->vsync_start - m->vdisplay),
322 lcdif->base + LCDC_V8_VSYN_PARA);
323
324 writel(VSYN_HSYN_WIDTH_PW_V(m->vsync_end - m->vsync_start) |
325 VSYN_HSYN_WIDTH_PW_H(m->hsync_end - m->hsync_start),
326 lcdif->base + LCDC_V8_VSYN_HSYN_WIDTH);
327
328 writel(CTRLDESCL0_1_HEIGHT(m->vdisplay) |
329 CTRLDESCL0_1_WIDTH(m->hdisplay),
330 lcdif->base + LCDC_V8_CTRLDESCL0_1);
331
332 /*
333 * Undocumented P_SIZE and T_SIZE register but those written in the
334 * downstream kernel those registers control the AXI burst size. As of
335 * now there are two known values:
336 * 1 - 128Byte
337 * 2 - 256Byte
338 * Downstream set it to 256B burst size to improve the memory
339 * efficiency so set it here too.
340 */
341 ctrl = CTRLDESCL0_3_P_SIZE(2) | CTRLDESCL0_3_T_SIZE(2) |
342 CTRLDESCL0_3_PITCH(lcdif->crtc.primary->state->fb->pitches[0]);
343 writel(ctrl, lcdif->base + LCDC_V8_CTRLDESCL0_3);
344 }
345
lcdif_enable_controller(struct lcdif_drm_private * lcdif)346 static void lcdif_enable_controller(struct lcdif_drm_private *lcdif)
347 {
348 u32 reg;
349
350 /* Set FIFO Panic watermarks, low 1/3, high 2/3 . */
351 writel(FIELD_PREP(PANIC0_THRES_LOW_MASK, 1 * PANIC0_THRES_MAX / 3) |
352 FIELD_PREP(PANIC0_THRES_HIGH_MASK, 2 * PANIC0_THRES_MAX / 3),
353 lcdif->base + LCDC_V8_PANIC0_THRES);
354
355 /*
356 * Enable FIFO Panic, this does not generate interrupt, but
357 * boosts NoC priority based on FIFO Panic watermarks.
358 */
359 writel(INT_ENABLE_D1_PLANE_PANIC_EN,
360 lcdif->base + LCDC_V8_INT_ENABLE_D1);
361
362 reg = readl(lcdif->base + LCDC_V8_DISP_PARA);
363 reg |= DISP_PARA_DISP_ON;
364 writel(reg, lcdif->base + LCDC_V8_DISP_PARA);
365
366 reg = readl(lcdif->base + LCDC_V8_CTRLDESCL0_5);
367 reg |= CTRLDESCL0_5_EN;
368 writel(reg, lcdif->base + LCDC_V8_CTRLDESCL0_5);
369 }
370
lcdif_disable_controller(struct lcdif_drm_private * lcdif)371 static void lcdif_disable_controller(struct lcdif_drm_private *lcdif)
372 {
373 u32 reg;
374 int ret;
375
376 reg = readl(lcdif->base + LCDC_V8_CTRLDESCL0_5);
377 reg &= ~CTRLDESCL0_5_EN;
378 writel(reg, lcdif->base + LCDC_V8_CTRLDESCL0_5);
379
380 ret = readl_poll_timeout(lcdif->base + LCDC_V8_CTRLDESCL0_5,
381 reg, !(reg & CTRLDESCL0_5_EN),
382 0, 36000); /* Wait ~2 frame times max */
383 if (ret)
384 drm_err(lcdif->drm, "Failed to disable controller!\n");
385
386 reg = readl(lcdif->base + LCDC_V8_DISP_PARA);
387 reg &= ~DISP_PARA_DISP_ON;
388 writel(reg, lcdif->base + LCDC_V8_DISP_PARA);
389
390 /* Disable FIFO Panic NoC priority booster. */
391 writel(0, lcdif->base + LCDC_V8_INT_ENABLE_D1);
392 }
393
lcdif_reset_block(struct lcdif_drm_private * lcdif)394 static void lcdif_reset_block(struct lcdif_drm_private *lcdif)
395 {
396 writel(CTRL_SW_RESET, lcdif->base + LCDC_V8_CTRL + REG_SET);
397 readl(lcdif->base + LCDC_V8_CTRL);
398 writel(CTRL_SW_RESET, lcdif->base + LCDC_V8_CTRL + REG_CLR);
399 readl(lcdif->base + LCDC_V8_CTRL);
400 }
401
lcdif_crtc_mode_set_nofb(struct drm_crtc_state * crtc_state,struct drm_plane_state * plane_state)402 static void lcdif_crtc_mode_set_nofb(struct drm_crtc_state *crtc_state,
403 struct drm_plane_state *plane_state)
404 {
405 struct lcdif_crtc_state *lcdif_crtc_state = to_lcdif_crtc_state(crtc_state);
406 struct drm_device *drm = crtc_state->crtc->dev;
407 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(drm);
408 struct drm_display_mode *m = &crtc_state->adjusted_mode;
409
410 DRM_DEV_DEBUG_DRIVER(drm->dev, "Pixel clock: %dkHz (actual: %dkHz)\n",
411 m->clock, (int)(clk_get_rate(lcdif->clk) / 1000));
412 DRM_DEV_DEBUG_DRIVER(drm->dev, "Bridge bus_flags: 0x%08X\n",
413 lcdif_crtc_state->bus_flags);
414 DRM_DEV_DEBUG_DRIVER(drm->dev, "Mode flags: 0x%08X\n", m->flags);
415
416 /* Mandatory eLCDIF reset as per the Reference Manual */
417 lcdif_reset_block(lcdif);
418
419 lcdif_set_formats(lcdif, plane_state, lcdif_crtc_state->bus_format);
420
421 lcdif_set_mode(lcdif, lcdif_crtc_state->bus_flags);
422 }
423
lcdif_crtc_atomic_check(struct drm_crtc * crtc,struct drm_atomic_state * state)424 static int lcdif_crtc_atomic_check(struct drm_crtc *crtc,
425 struct drm_atomic_state *state)
426 {
427 struct drm_device *drm = crtc->dev;
428 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
429 crtc);
430 struct lcdif_crtc_state *lcdif_crtc_state = to_lcdif_crtc_state(crtc_state);
431 bool has_primary = crtc_state->plane_mask &
432 drm_plane_mask(crtc->primary);
433 struct drm_connector_state *connector_state;
434 struct drm_connector *connector;
435 struct drm_encoder *encoder;
436 struct drm_bridge_state *bridge_state;
437 u32 bus_format, bus_flags;
438 bool format_set = false, flags_set = false;
439 int ret, i;
440
441 /* The primary plane has to be enabled when the CRTC is active. */
442 if (crtc_state->active && !has_primary)
443 return -EINVAL;
444
445 ret = drm_atomic_add_affected_planes(state, crtc);
446 if (ret)
447 return ret;
448
449 /* Try to find consistent bus format and flags across first bridges. */
450 for_each_new_connector_in_state(state, connector, connector_state, i) {
451 if (!connector_state->crtc)
452 continue;
453
454 encoder = connector_state->best_encoder;
455
456 struct drm_bridge *bridge __free(drm_bridge_put) =
457 drm_bridge_chain_get_first_bridge(encoder);
458 if (!bridge)
459 continue;
460
461 bridge_state = drm_atomic_get_new_bridge_state(state, bridge);
462 if (!bridge_state)
463 bus_format = MEDIA_BUS_FMT_FIXED;
464 else
465 bus_format = bridge_state->input_bus_cfg.format;
466
467 if (bus_format == MEDIA_BUS_FMT_FIXED) {
468 dev_warn(drm->dev,
469 "[ENCODER:%d:%s]'s bridge does not provide bus format, assuming MEDIA_BUS_FMT_RGB888_1X24.\n"
470 "Please fix bridge driver by handling atomic_get_input_bus_fmts.\n",
471 encoder->base.id, encoder->name);
472 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
473 } else if (!bus_format) {
474 /* If all else fails, default to RGB888_1X24 */
475 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
476 }
477
478 if (!format_set) {
479 lcdif_crtc_state->bus_format = bus_format;
480 format_set = true;
481 } else if (lcdif_crtc_state->bus_format != bus_format) {
482 DRM_DEV_DEBUG_DRIVER(drm->dev, "inconsistent bus format\n");
483 return -EINVAL;
484 }
485
486 if (bridge->timings)
487 bus_flags = bridge->timings->input_bus_flags;
488 else if (bridge_state)
489 bus_flags = bridge_state->input_bus_cfg.flags;
490 else
491 bus_flags = 0;
492
493 if (!flags_set) {
494 lcdif_crtc_state->bus_flags = bus_flags;
495 flags_set = true;
496 } else if (lcdif_crtc_state->bus_flags != bus_flags) {
497 DRM_DEV_DEBUG_DRIVER(drm->dev, "inconsistent bus flags\n");
498 return -EINVAL;
499 }
500 }
501
502 return 0;
503 }
504
lcdif_crtc_atomic_flush(struct drm_crtc * crtc,struct drm_atomic_state * state)505 static void lcdif_crtc_atomic_flush(struct drm_crtc *crtc,
506 struct drm_atomic_state *state)
507 {
508 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
509 struct drm_pending_vblank_event *event;
510 u32 reg;
511
512 reg = readl(lcdif->base + LCDC_V8_CTRLDESCL0_5);
513 reg |= CTRLDESCL0_5_SHADOW_LOAD_EN;
514 writel(reg, lcdif->base + LCDC_V8_CTRLDESCL0_5);
515
516 event = crtc->state->event;
517 crtc->state->event = NULL;
518
519 if (!event)
520 return;
521
522 spin_lock_irq(&crtc->dev->event_lock);
523 if (drm_crtc_vblank_get(crtc) == 0)
524 drm_crtc_arm_vblank_event(crtc, event);
525 else
526 drm_crtc_send_vblank_event(crtc, event);
527 spin_unlock_irq(&crtc->dev->event_lock);
528 }
529
lcdif_crtc_atomic_enable(struct drm_crtc * crtc,struct drm_atomic_state * state)530 static void lcdif_crtc_atomic_enable(struct drm_crtc *crtc,
531 struct drm_atomic_state *state)
532 {
533 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
534 struct drm_crtc_state *new_cstate = drm_atomic_get_new_crtc_state(state, crtc);
535 struct drm_plane_state *new_pstate = drm_atomic_get_new_plane_state(state,
536 crtc->primary);
537 struct drm_display_mode *m = &lcdif->crtc.state->adjusted_mode;
538 struct drm_device *drm = lcdif->drm;
539 dma_addr_t paddr;
540
541 clk_set_rate(lcdif->clk, m->clock * 1000);
542
543 pm_runtime_get_sync(drm->dev);
544
545 lcdif_crtc_mode_set_nofb(new_cstate, new_pstate);
546
547 /* Write cur_buf as well to avoid an initial corrupt frame */
548 paddr = drm_fb_dma_get_gem_addr(new_pstate->fb, new_pstate, 0);
549 if (paddr) {
550 writel(lower_32_bits(paddr),
551 lcdif->base + LCDC_V8_CTRLDESCL_LOW0_4);
552 writel(CTRLDESCL_HIGH0_4_ADDR_HIGH(upper_32_bits(paddr)),
553 lcdif->base + LCDC_V8_CTRLDESCL_HIGH0_4);
554 }
555 lcdif_enable_controller(lcdif);
556
557 drm_crtc_vblank_on(crtc);
558 }
559
lcdif_crtc_atomic_disable(struct drm_crtc * crtc,struct drm_atomic_state * state)560 static void lcdif_crtc_atomic_disable(struct drm_crtc *crtc,
561 struct drm_atomic_state *state)
562 {
563 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
564 struct drm_device *drm = lcdif->drm;
565 struct drm_pending_vblank_event *event;
566
567 drm_crtc_vblank_off(crtc);
568
569 lcdif_disable_controller(lcdif);
570
571 spin_lock_irq(&drm->event_lock);
572 event = crtc->state->event;
573 if (event) {
574 crtc->state->event = NULL;
575 drm_crtc_send_vblank_event(crtc, event);
576 }
577 spin_unlock_irq(&drm->event_lock);
578
579 pm_runtime_put_sync(drm->dev);
580 }
581
lcdif_crtc_atomic_destroy_state(struct drm_crtc * crtc,struct drm_crtc_state * state)582 static void lcdif_crtc_atomic_destroy_state(struct drm_crtc *crtc,
583 struct drm_crtc_state *state)
584 {
585 __drm_atomic_helper_crtc_destroy_state(state);
586 kfree(to_lcdif_crtc_state(state));
587 }
588
lcdif_crtc_reset(struct drm_crtc * crtc)589 static void lcdif_crtc_reset(struct drm_crtc *crtc)
590 {
591 struct lcdif_crtc_state *state;
592
593 if (crtc->state)
594 lcdif_crtc_atomic_destroy_state(crtc, crtc->state);
595
596 crtc->state = NULL;
597
598 state = kzalloc_obj(*state);
599 if (state)
600 __drm_atomic_helper_crtc_reset(crtc, &state->base);
601 }
602
603 static struct drm_crtc_state *
lcdif_crtc_atomic_duplicate_state(struct drm_crtc * crtc)604 lcdif_crtc_atomic_duplicate_state(struct drm_crtc *crtc)
605 {
606 struct lcdif_crtc_state *old = to_lcdif_crtc_state(crtc->state);
607 struct lcdif_crtc_state *new;
608
609 if (WARN_ON(!crtc->state))
610 return NULL;
611
612 new = kzalloc_obj(*new);
613 if (!new)
614 return NULL;
615
616 __drm_atomic_helper_crtc_duplicate_state(crtc, &new->base);
617
618 new->bus_format = old->bus_format;
619 new->bus_flags = old->bus_flags;
620
621 return &new->base;
622 }
623
lcdif_crtc_enable_vblank(struct drm_crtc * crtc)624 static int lcdif_crtc_enable_vblank(struct drm_crtc *crtc)
625 {
626 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
627
628 /* Clear and enable VBLANK IRQ */
629 writel(INT_STATUS_D0_VS_BLANK, lcdif->base + LCDC_V8_INT_STATUS_D0);
630 writel(INT_ENABLE_D0_VS_BLANK_EN, lcdif->base + LCDC_V8_INT_ENABLE_D0);
631
632 return 0;
633 }
634
lcdif_crtc_disable_vblank(struct drm_crtc * crtc)635 static void lcdif_crtc_disable_vblank(struct drm_crtc *crtc)
636 {
637 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
638
639 /* Disable and clear VBLANK IRQ */
640 writel(0, lcdif->base + LCDC_V8_INT_ENABLE_D0);
641 writel(INT_STATUS_D0_VS_BLANK, lcdif->base + LCDC_V8_INT_STATUS_D0);
642 }
643
644 static const struct drm_crtc_helper_funcs lcdif_crtc_helper_funcs = {
645 .atomic_check = lcdif_crtc_atomic_check,
646 .atomic_flush = lcdif_crtc_atomic_flush,
647 .atomic_enable = lcdif_crtc_atomic_enable,
648 .atomic_disable = lcdif_crtc_atomic_disable,
649 };
650
651 static const struct drm_crtc_funcs lcdif_crtc_funcs = {
652 .reset = lcdif_crtc_reset,
653 .destroy = drm_crtc_cleanup,
654 .set_config = drm_atomic_helper_set_config,
655 .page_flip = drm_atomic_helper_page_flip,
656 .atomic_duplicate_state = lcdif_crtc_atomic_duplicate_state,
657 .atomic_destroy_state = lcdif_crtc_atomic_destroy_state,
658 .enable_vblank = lcdif_crtc_enable_vblank,
659 .disable_vblank = lcdif_crtc_disable_vblank,
660 };
661
662 /* -----------------------------------------------------------------------------
663 * Planes
664 */
665
lcdif_plane_atomic_check(struct drm_plane * plane,struct drm_atomic_state * state)666 static int lcdif_plane_atomic_check(struct drm_plane *plane,
667 struct drm_atomic_state *state)
668 {
669 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state,
670 plane);
671 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(plane->dev);
672 struct drm_crtc_state *crtc_state;
673
674 crtc_state = drm_atomic_get_new_crtc_state(state,
675 &lcdif->crtc);
676
677 return drm_atomic_helper_check_plane_state(plane_state, crtc_state,
678 DRM_PLANE_NO_SCALING,
679 DRM_PLANE_NO_SCALING,
680 false, true);
681 }
682
lcdif_plane_primary_atomic_update(struct drm_plane * plane,struct drm_atomic_state * state)683 static void lcdif_plane_primary_atomic_update(struct drm_plane *plane,
684 struct drm_atomic_state *state)
685 {
686 struct lcdif_drm_private *lcdif = to_lcdif_drm_private(plane->dev);
687 struct drm_plane_state *new_pstate = drm_atomic_get_new_plane_state(state,
688 plane);
689 dma_addr_t paddr;
690
691 paddr = drm_fb_dma_get_gem_addr(new_pstate->fb, new_pstate, 0);
692 if (paddr) {
693 writel(lower_32_bits(paddr),
694 lcdif->base + LCDC_V8_CTRLDESCL_LOW0_4);
695 writel(CTRLDESCL_HIGH0_4_ADDR_HIGH(upper_32_bits(paddr)),
696 lcdif->base + LCDC_V8_CTRLDESCL_HIGH0_4);
697 }
698 }
699
lcdif_format_mod_supported(struct drm_plane * plane,uint32_t format,uint64_t modifier)700 static bool lcdif_format_mod_supported(struct drm_plane *plane,
701 uint32_t format,
702 uint64_t modifier)
703 {
704 return modifier == DRM_FORMAT_MOD_LINEAR;
705 }
706
707 static const struct drm_plane_helper_funcs lcdif_plane_primary_helper_funcs = {
708 .atomic_check = lcdif_plane_atomic_check,
709 .atomic_update = lcdif_plane_primary_atomic_update,
710 };
711
712 static const struct drm_plane_funcs lcdif_plane_funcs = {
713 .format_mod_supported = lcdif_format_mod_supported,
714 .update_plane = drm_atomic_helper_update_plane,
715 .disable_plane = drm_atomic_helper_disable_plane,
716 .destroy = drm_plane_cleanup,
717 .reset = drm_atomic_helper_plane_reset,
718 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
719 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
720 };
721
722 static const u32 lcdif_primary_plane_formats[] = {
723 /* RGB */
724 DRM_FORMAT_RGB565,
725 DRM_FORMAT_RGB888,
726 DRM_FORMAT_XBGR8888,
727 DRM_FORMAT_XRGB1555,
728 DRM_FORMAT_XRGB4444,
729 DRM_FORMAT_XRGB8888,
730
731 /* Packed YCbCr */
732 DRM_FORMAT_YUYV,
733 DRM_FORMAT_YVYU,
734 DRM_FORMAT_UYVY,
735 DRM_FORMAT_VYUY,
736 };
737
738 static const u64 lcdif_modifiers[] = {
739 DRM_FORMAT_MOD_LINEAR,
740 DRM_FORMAT_MOD_INVALID
741 };
742
743 /* -----------------------------------------------------------------------------
744 * Initialization
745 */
746
lcdif_kms_init(struct lcdif_drm_private * lcdif)747 int lcdif_kms_init(struct lcdif_drm_private *lcdif)
748 {
749 const u32 supported_encodings = BIT(DRM_COLOR_YCBCR_BT601) |
750 BIT(DRM_COLOR_YCBCR_BT709) |
751 BIT(DRM_COLOR_YCBCR_BT2020);
752 const u32 supported_ranges = BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
753 BIT(DRM_COLOR_YCBCR_FULL_RANGE);
754 struct drm_crtc *crtc = &lcdif->crtc;
755 int ret;
756
757 drm_plane_helper_add(&lcdif->planes.primary,
758 &lcdif_plane_primary_helper_funcs);
759 ret = drm_universal_plane_init(lcdif->drm, &lcdif->planes.primary, 1,
760 &lcdif_plane_funcs,
761 lcdif_primary_plane_formats,
762 ARRAY_SIZE(lcdif_primary_plane_formats),
763 lcdif_modifiers, DRM_PLANE_TYPE_PRIMARY,
764 NULL);
765 if (ret)
766 return ret;
767
768 ret = drm_plane_create_color_properties(&lcdif->planes.primary,
769 supported_encodings,
770 supported_ranges,
771 DRM_COLOR_YCBCR_BT601,
772 DRM_COLOR_YCBCR_LIMITED_RANGE);
773 if (ret)
774 return ret;
775
776 drm_crtc_helper_add(crtc, &lcdif_crtc_helper_funcs);
777 return drm_crtc_init_with_planes(lcdif->drm, crtc,
778 &lcdif->planes.primary, NULL,
779 &lcdif_crtc_funcs, NULL);
780 }
781