xref: /linux/drivers/gpu/drm/mcde/mcde_display.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2018 Linus Walleij <linus.walleij@linaro.org>
4  * Parts of this file were based on the MCDE driver by Marcus Lorentzon
5  * (C) ST-Ericsson SA 2013
6  */
7 #include <linux/clk.h>
8 #include <linux/delay.h>
9 #include <linux/dma-buf.h>
10 #include <linux/regulator/consumer.h>
11 #include <linux/media-bus-format.h>
12 
13 #include <drm/drm_atomic_helper.h>
14 #include <drm/drm_device.h>
15 #include <drm/drm_fb_dma_helper.h>
16 #include <drm/drm_fourcc.h>
17 #include <drm/drm_framebuffer.h>
18 #include <drm/drm_gem_atomic_helper.h>
19 #include <drm/drm_gem_dma_helper.h>
20 #include <drm/drm_mipi_dsi.h>
21 #include <drm/drm_panel.h>
22 #include <drm/drm_print.h>
23 #include <drm/drm_bridge.h>
24 #include <drm/drm_vblank.h>
25 #include <video/mipi_display.h>
26 
27 #include "mcde_drm.h"
28 #include "mcde_display_regs.h"
29 
30 enum mcde_fifo {
31 	MCDE_FIFO_A,
32 	MCDE_FIFO_B,
33 	/* TODO: implement FIFO C0 and FIFO C1 */
34 };
35 
36 enum mcde_channel {
37 	MCDE_CHANNEL_0 = 0,
38 	MCDE_CHANNEL_1,
39 	MCDE_CHANNEL_2,
40 	MCDE_CHANNEL_3,
41 };
42 
43 enum mcde_extsrc {
44 	MCDE_EXTSRC_0 = 0,
45 	MCDE_EXTSRC_1,
46 	MCDE_EXTSRC_2,
47 	MCDE_EXTSRC_3,
48 	MCDE_EXTSRC_4,
49 	MCDE_EXTSRC_5,
50 	MCDE_EXTSRC_6,
51 	MCDE_EXTSRC_7,
52 	MCDE_EXTSRC_8,
53 	MCDE_EXTSRC_9,
54 };
55 
56 enum mcde_overlay {
57 	MCDE_OVERLAY_0 = 0,
58 	MCDE_OVERLAY_1,
59 	MCDE_OVERLAY_2,
60 	MCDE_OVERLAY_3,
61 	MCDE_OVERLAY_4,
62 	MCDE_OVERLAY_5,
63 };
64 
65 enum mcde_formatter {
66 	MCDE_DSI_FORMATTER_0 = 0,
67 	MCDE_DSI_FORMATTER_1,
68 	MCDE_DSI_FORMATTER_2,
69 	MCDE_DSI_FORMATTER_3,
70 	MCDE_DSI_FORMATTER_4,
71 	MCDE_DSI_FORMATTER_5,
72 	MCDE_DPI_FORMATTER_0,
73 	MCDE_DPI_FORMATTER_1,
74 };
75 
76 void mcde_display_irq(struct mcde *mcde)
77 {
78 	u32 mispp, misovl, mischnl;
79 	bool vblank = false;
80 
81 	/* Handle display IRQs */
82 	mispp = readl(mcde->regs + MCDE_MISPP);
83 	misovl = readl(mcde->regs + MCDE_MISOVL);
84 	mischnl = readl(mcde->regs + MCDE_MISCHNL);
85 
86 	/*
87 	 * Handle IRQs from the DSI link. All IRQs from the DSI links
88 	 * are just latched onto the MCDE IRQ line, so we need to traverse
89 	 * any active DSI masters and check if an IRQ is originating from
90 	 * them.
91 	 *
92 	 * TODO: Currently only one DSI link is supported.
93 	 */
94 	if (!mcde->dpi_output && mcde_dsi_irq(mcde->mdsi)) {
95 		u32 val;
96 
97 		/*
98 		 * In oneshot mode we do not send continuous updates
99 		 * to the display, instead we only push out updates when
100 		 * the update function is called, then we disable the
101 		 * flow on the channel once we get the TE IRQ.
102 		 */
103 		if (mcde->flow_mode == MCDE_COMMAND_ONESHOT_FLOW) {
104 			spin_lock(&mcde->flow_lock);
105 			if (--mcde->flow_active == 0) {
106 				dev_dbg(mcde->dev, "TE0 IRQ\n");
107 				/* Disable FIFO A flow */
108 				val = readl(mcde->regs + MCDE_CRA0);
109 				val &= ~MCDE_CRX0_FLOEN;
110 				writel(val, mcde->regs + MCDE_CRA0);
111 			}
112 			spin_unlock(&mcde->flow_lock);
113 		}
114 	}
115 
116 	/* Vblank from one of the channels */
117 	if (mispp & MCDE_PP_VCMPA) {
118 		dev_dbg(mcde->dev, "chnl A vblank IRQ\n");
119 		vblank = true;
120 	}
121 	if (mispp & MCDE_PP_VCMPB) {
122 		dev_dbg(mcde->dev, "chnl B vblank IRQ\n");
123 		vblank = true;
124 	}
125 	if (mispp & MCDE_PP_VCMPC0)
126 		dev_dbg(mcde->dev, "chnl C0 vblank IRQ\n");
127 	if (mispp & MCDE_PP_VCMPC1)
128 		dev_dbg(mcde->dev, "chnl C1 vblank IRQ\n");
129 	if (mispp & MCDE_PP_VSCC0)
130 		dev_dbg(mcde->dev, "chnl C0 TE IRQ\n");
131 	if (mispp & MCDE_PP_VSCC1)
132 		dev_dbg(mcde->dev, "chnl C1 TE IRQ\n");
133 	writel(mispp, mcde->regs + MCDE_RISPP);
134 
135 	if (vblank)
136 		drm_crtc_handle_vblank(&mcde->crtc);
137 
138 	if (misovl)
139 		dev_info(mcde->dev, "some stray overlay IRQ %08x\n", misovl);
140 	writel(misovl, mcde->regs + MCDE_RISOVL);
141 
142 	if (mischnl)
143 		dev_info(mcde->dev, "some stray channel error IRQ %08x\n",
144 			 mischnl);
145 	writel(mischnl, mcde->regs + MCDE_RISCHNL);
146 }
147 
148 void mcde_display_disable_irqs(struct mcde *mcde)
149 {
150 	/* Disable all IRQs */
151 	writel(0, mcde->regs + MCDE_IMSCPP);
152 	writel(0, mcde->regs + MCDE_IMSCOVL);
153 	writel(0, mcde->regs + MCDE_IMSCCHNL);
154 
155 	/* Clear any pending IRQs */
156 	writel(0xFFFFFFFF, mcde->regs + MCDE_RISPP);
157 	writel(0xFFFFFFFF, mcde->regs + MCDE_RISOVL);
158 	writel(0xFFFFFFFF, mcde->regs + MCDE_RISCHNL);
159 }
160 
161 static int mcde_plane_helper_atomic_check(struct drm_plane *plane,
162 					  struct drm_atomic_commit *commit)
163 {
164 	struct drm_plane_state *pstate = drm_atomic_get_new_plane_state(commit, plane);
165 	struct drm_plane_state *old_pstate = drm_atomic_get_old_plane_state(commit, plane);
166 	struct drm_crtc_state *cstate = NULL;
167 	const struct drm_display_mode *mode;
168 	struct drm_framebuffer *old_fb = old_pstate->fb;
169 	struct drm_framebuffer *fb = pstate->fb;
170 	int ret;
171 
172 	if (pstate->crtc) {
173 		cstate = drm_atomic_get_crtc_state(commit, pstate->crtc);
174 		if (IS_ERR(cstate))
175 			return PTR_ERR(cstate);
176 	}
177 
178 	ret = drm_atomic_helper_check_plane_state(pstate, cstate,
179 						  DRM_PLANE_NO_SCALING,
180 						  DRM_PLANE_NO_SCALING,
181 						  false, false);
182 	if (ret)
183 		return ret;
184 
185 	if (!pstate->visible || !fb)
186 		return 0;
187 
188 	mode = &cstate->mode;
189 
190 	u32 offset = drm_fb_dma_get_gem_addr(fb, pstate, 0);
191 
192 	/* FB base address must be dword aligned. */
193 	if (offset & 3) {
194 		DRM_DEBUG_KMS("FB not 32-bit aligned\n");
195 		return -EINVAL;
196 	}
197 
198 	/*
199 	 * There's no pitch register, the mode's hdisplay
200 	 * controls this.
201 	 */
202 	if (fb->pitches[0] != mode->hdisplay * fb->format->cpp[0]) {
203 		DRM_DEBUG_KMS("can't handle pitches\n");
204 		return -EINVAL;
205 	}
206 
207 	/*
208 	 * We can't change the FB format in a flicker-free
209 	 * manner (and only update it during CRTC enable).
210 	 */
211 	if (old_fb && old_fb->format != fb->format)
212 		cstate->mode_changed = true;
213 
214 	return 0;
215 }
216 
217 static int mcde_configure_extsrc(struct mcde *mcde, enum mcde_extsrc src,
218 				 u32 format)
219 {
220 	u32 val;
221 	u32 conf;
222 	u32 cr;
223 
224 	switch (src) {
225 	case MCDE_EXTSRC_0:
226 		conf = MCDE_EXTSRC0CONF;
227 		cr = MCDE_EXTSRC0CR;
228 		break;
229 	case MCDE_EXTSRC_1:
230 		conf = MCDE_EXTSRC1CONF;
231 		cr = MCDE_EXTSRC1CR;
232 		break;
233 	case MCDE_EXTSRC_2:
234 		conf = MCDE_EXTSRC2CONF;
235 		cr = MCDE_EXTSRC2CR;
236 		break;
237 	case MCDE_EXTSRC_3:
238 		conf = MCDE_EXTSRC3CONF;
239 		cr = MCDE_EXTSRC3CR;
240 		break;
241 	case MCDE_EXTSRC_4:
242 		conf = MCDE_EXTSRC4CONF;
243 		cr = MCDE_EXTSRC4CR;
244 		break;
245 	case MCDE_EXTSRC_5:
246 		conf = MCDE_EXTSRC5CONF;
247 		cr = MCDE_EXTSRC5CR;
248 		break;
249 	case MCDE_EXTSRC_6:
250 		conf = MCDE_EXTSRC6CONF;
251 		cr = MCDE_EXTSRC6CR;
252 		break;
253 	case MCDE_EXTSRC_7:
254 		conf = MCDE_EXTSRC7CONF;
255 		cr = MCDE_EXTSRC7CR;
256 		break;
257 	case MCDE_EXTSRC_8:
258 		conf = MCDE_EXTSRC8CONF;
259 		cr = MCDE_EXTSRC8CR;
260 		break;
261 	case MCDE_EXTSRC_9:
262 		conf = MCDE_EXTSRC9CONF;
263 		cr = MCDE_EXTSRC9CR;
264 		break;
265 	}
266 
267 	/*
268 	 * Configure external source 0 one buffer (buffer 0)
269 	 * primary overlay ID 0.
270 	 * From mcde_hw.c ovly_update_registers() in the vendor tree
271 	 */
272 	val = 0 << MCDE_EXTSRCXCONF_BUF_ID_SHIFT;
273 	val |= 1 << MCDE_EXTSRCXCONF_BUF_NB_SHIFT;
274 	val |= 0 << MCDE_EXTSRCXCONF_PRI_OVLID_SHIFT;
275 
276 	switch (format) {
277 	case DRM_FORMAT_ARGB8888:
278 		val |= MCDE_EXTSRCXCONF_BPP_ARGB8888 <<
279 			MCDE_EXTSRCXCONF_BPP_SHIFT;
280 		break;
281 	case DRM_FORMAT_ABGR8888:
282 		val |= MCDE_EXTSRCXCONF_BPP_ARGB8888 <<
283 			MCDE_EXTSRCXCONF_BPP_SHIFT;
284 		val |= MCDE_EXTSRCXCONF_BGR;
285 		break;
286 	case DRM_FORMAT_XRGB8888:
287 		val |= MCDE_EXTSRCXCONF_BPP_XRGB8888 <<
288 			MCDE_EXTSRCXCONF_BPP_SHIFT;
289 		break;
290 	case DRM_FORMAT_XBGR8888:
291 		val |= MCDE_EXTSRCXCONF_BPP_XRGB8888 <<
292 			MCDE_EXTSRCXCONF_BPP_SHIFT;
293 		val |= MCDE_EXTSRCXCONF_BGR;
294 		break;
295 	case DRM_FORMAT_RGB888:
296 		val |= MCDE_EXTSRCXCONF_BPP_RGB888 <<
297 			MCDE_EXTSRCXCONF_BPP_SHIFT;
298 		break;
299 	case DRM_FORMAT_BGR888:
300 		val |= MCDE_EXTSRCXCONF_BPP_RGB888 <<
301 			MCDE_EXTSRCXCONF_BPP_SHIFT;
302 		val |= MCDE_EXTSRCXCONF_BGR;
303 		break;
304 	case DRM_FORMAT_ARGB4444:
305 		val |= MCDE_EXTSRCXCONF_BPP_ARGB4444 <<
306 			MCDE_EXTSRCXCONF_BPP_SHIFT;
307 		break;
308 	case DRM_FORMAT_ABGR4444:
309 		val |= MCDE_EXTSRCXCONF_BPP_ARGB4444 <<
310 			MCDE_EXTSRCXCONF_BPP_SHIFT;
311 		val |= MCDE_EXTSRCXCONF_BGR;
312 		break;
313 	case DRM_FORMAT_XRGB4444:
314 		val |= MCDE_EXTSRCXCONF_BPP_RGB444 <<
315 			MCDE_EXTSRCXCONF_BPP_SHIFT;
316 		break;
317 	case DRM_FORMAT_XBGR4444:
318 		val |= MCDE_EXTSRCXCONF_BPP_RGB444 <<
319 			MCDE_EXTSRCXCONF_BPP_SHIFT;
320 		val |= MCDE_EXTSRCXCONF_BGR;
321 		break;
322 	case DRM_FORMAT_XRGB1555:
323 		val |= MCDE_EXTSRCXCONF_BPP_IRGB1555 <<
324 			MCDE_EXTSRCXCONF_BPP_SHIFT;
325 		break;
326 	case DRM_FORMAT_XBGR1555:
327 		val |= MCDE_EXTSRCXCONF_BPP_IRGB1555 <<
328 			MCDE_EXTSRCXCONF_BPP_SHIFT;
329 		val |= MCDE_EXTSRCXCONF_BGR;
330 		break;
331 	case DRM_FORMAT_RGB565:
332 		val |= MCDE_EXTSRCXCONF_BPP_RGB565 <<
333 			MCDE_EXTSRCXCONF_BPP_SHIFT;
334 		break;
335 	case DRM_FORMAT_BGR565:
336 		val |= MCDE_EXTSRCXCONF_BPP_RGB565 <<
337 			MCDE_EXTSRCXCONF_BPP_SHIFT;
338 		val |= MCDE_EXTSRCXCONF_BGR;
339 		break;
340 	case DRM_FORMAT_YUV422:
341 		val |= MCDE_EXTSRCXCONF_BPP_YCBCR422 <<
342 			MCDE_EXTSRCXCONF_BPP_SHIFT;
343 		break;
344 	default:
345 		dev_err(mcde->dev, "Unknown pixel format 0x%08x\n",
346 			format);
347 		return -EINVAL;
348 	}
349 	writel(val, mcde->regs + conf);
350 
351 	/* Software select, primary */
352 	val = MCDE_EXTSRCXCR_SEL_MOD_SOFTWARE_SEL;
353 	val |= MCDE_EXTSRCXCR_MULTIOVL_CTRL_PRIMARY;
354 	writel(val, mcde->regs + cr);
355 
356 	return 0;
357 }
358 
359 static void mcde_configure_overlay(struct mcde *mcde, enum mcde_overlay ovl,
360 				   enum mcde_extsrc src,
361 				   enum mcde_channel ch,
362 				   const struct drm_display_mode *mode,
363 				   u32 format, int cpp)
364 {
365 	u32 val;
366 	u32 conf1;
367 	u32 conf2;
368 	u32 crop;
369 	u32 ljinc;
370 	u32 cr;
371 	u32 comp;
372 	u32 pixel_fetcher_watermark;
373 
374 	switch (ovl) {
375 	case MCDE_OVERLAY_0:
376 		conf1 = MCDE_OVL0CONF;
377 		conf2 = MCDE_OVL0CONF2;
378 		crop = MCDE_OVL0CROP;
379 		ljinc = MCDE_OVL0LJINC;
380 		cr = MCDE_OVL0CR;
381 		comp = MCDE_OVL0COMP;
382 		break;
383 	case MCDE_OVERLAY_1:
384 		conf1 = MCDE_OVL1CONF;
385 		conf2 = MCDE_OVL1CONF2;
386 		crop = MCDE_OVL1CROP;
387 		ljinc = MCDE_OVL1LJINC;
388 		cr = MCDE_OVL1CR;
389 		comp = MCDE_OVL1COMP;
390 		break;
391 	case MCDE_OVERLAY_2:
392 		conf1 = MCDE_OVL2CONF;
393 		conf2 = MCDE_OVL2CONF2;
394 		crop = MCDE_OVL2CROP;
395 		ljinc = MCDE_OVL2LJINC;
396 		cr = MCDE_OVL2CR;
397 		comp = MCDE_OVL2COMP;
398 		break;
399 	case MCDE_OVERLAY_3:
400 		conf1 = MCDE_OVL3CONF;
401 		conf2 = MCDE_OVL3CONF2;
402 		crop = MCDE_OVL3CROP;
403 		ljinc = MCDE_OVL3LJINC;
404 		cr = MCDE_OVL3CR;
405 		comp = MCDE_OVL3COMP;
406 		break;
407 	case MCDE_OVERLAY_4:
408 		conf1 = MCDE_OVL4CONF;
409 		conf2 = MCDE_OVL4CONF2;
410 		crop = MCDE_OVL4CROP;
411 		ljinc = MCDE_OVL4LJINC;
412 		cr = MCDE_OVL4CR;
413 		comp = MCDE_OVL4COMP;
414 		break;
415 	case MCDE_OVERLAY_5:
416 		conf1 = MCDE_OVL5CONF;
417 		conf2 = MCDE_OVL5CONF2;
418 		crop = MCDE_OVL5CROP;
419 		ljinc = MCDE_OVL5LJINC;
420 		cr = MCDE_OVL5CR;
421 		comp = MCDE_OVL5COMP;
422 		break;
423 	}
424 
425 	val = mode->hdisplay << MCDE_OVLXCONF_PPL_SHIFT;
426 	val |= mode->vdisplay << MCDE_OVLXCONF_LPF_SHIFT;
427 	/* Use external source 0 that we just configured */
428 	val |= src << MCDE_OVLXCONF_EXTSRC_ID_SHIFT;
429 	writel(val, mcde->regs + conf1);
430 
431 	val = MCDE_OVLXCONF2_BP_PER_PIXEL_ALPHA;
432 	val |= 0xff << MCDE_OVLXCONF2_ALPHAVALUE_SHIFT;
433 	/* OPQ: overlay is opaque */
434 	switch (format) {
435 	case DRM_FORMAT_ARGB8888:
436 	case DRM_FORMAT_ABGR8888:
437 	case DRM_FORMAT_ARGB4444:
438 	case DRM_FORMAT_ABGR4444:
439 	case DRM_FORMAT_XRGB1555:
440 	case DRM_FORMAT_XBGR1555:
441 		/* No OPQ */
442 		break;
443 	case DRM_FORMAT_XRGB8888:
444 	case DRM_FORMAT_XBGR8888:
445 	case DRM_FORMAT_RGB888:
446 	case DRM_FORMAT_BGR888:
447 	case DRM_FORMAT_RGB565:
448 	case DRM_FORMAT_BGR565:
449 	case DRM_FORMAT_YUV422:
450 		val |= MCDE_OVLXCONF2_OPQ;
451 		break;
452 	default:
453 		dev_err(mcde->dev, "Unknown pixel format 0x%08x\n",
454 			format);
455 		break;
456 	}
457 
458 	/*
459 	 * Pixel fetch watermark level is max 0x1FFF pixels.
460 	 * Two basic rules should be followed:
461 	 * 1. The value should be at least 256 bits.
462 	 * 2. The sum of all active overlays pixelfetch watermark level
463 	 *    multiplied with bits per pixel, should be lower than the
464 	 *    size of input_fifo_size in bits.
465 	 * 3. The value should be a multiple of a line (256 bits).
466 	 */
467 	switch (cpp) {
468 	case 2:
469 		pixel_fetcher_watermark = 128;
470 		break;
471 	case 3:
472 		pixel_fetcher_watermark = 96;
473 		break;
474 	case 4:
475 		pixel_fetcher_watermark = 48;
476 		break;
477 	default:
478 		pixel_fetcher_watermark = 48;
479 		break;
480 	}
481 	dev_dbg(mcde->dev, "pixel fetcher watermark level %d pixels\n",
482 		pixel_fetcher_watermark);
483 	val |= pixel_fetcher_watermark << MCDE_OVLXCONF2_PIXELFETCHERWATERMARKLEVEL_SHIFT;
484 	writel(val, mcde->regs + conf2);
485 
486 	/* Number of bytes to fetch per line */
487 	writel(mcde->stride, mcde->regs + ljinc);
488 	/* No cropping */
489 	writel(0, mcde->regs + crop);
490 
491 	/* Set up overlay control register */
492 	val = MCDE_OVLXCR_OVLEN;
493 	val |= MCDE_OVLXCR_COLCCTRL_DISABLED;
494 	val |= MCDE_OVLXCR_BURSTSIZE_8W <<
495 		MCDE_OVLXCR_BURSTSIZE_SHIFT;
496 	val |= MCDE_OVLXCR_MAXOUTSTANDING_8_REQ <<
497 		MCDE_OVLXCR_MAXOUTSTANDING_SHIFT;
498 	/* Not using rotation but set it up anyways */
499 	val |= MCDE_OVLXCR_ROTBURSTSIZE_8W <<
500 		MCDE_OVLXCR_ROTBURSTSIZE_SHIFT;
501 	writel(val, mcde->regs + cr);
502 
503 	/*
504 	 * Set up the overlay compositor to route the overlay out to
505 	 * the desired channel
506 	 */
507 	val = ch << MCDE_OVLXCOMP_CH_ID_SHIFT;
508 	writel(val, mcde->regs + comp);
509 }
510 
511 static void mcde_configure_channel(struct mcde *mcde, enum mcde_channel ch,
512 				   enum mcde_fifo fifo,
513 				   const struct drm_display_mode *mode)
514 {
515 	u32 val;
516 	u32 conf;
517 	u32 sync;
518 	u32 stat;
519 	u32 bgcol;
520 	u32 mux;
521 
522 	switch (ch) {
523 	case MCDE_CHANNEL_0:
524 		conf = MCDE_CHNL0CONF;
525 		sync = MCDE_CHNL0SYNCHMOD;
526 		stat = MCDE_CHNL0STAT;
527 		bgcol = MCDE_CHNL0BCKGNDCOL;
528 		mux = MCDE_CHNL0MUXING;
529 		break;
530 	case MCDE_CHANNEL_1:
531 		conf = MCDE_CHNL1CONF;
532 		sync = MCDE_CHNL1SYNCHMOD;
533 		stat = MCDE_CHNL1STAT;
534 		bgcol = MCDE_CHNL1BCKGNDCOL;
535 		mux = MCDE_CHNL1MUXING;
536 		break;
537 	case MCDE_CHANNEL_2:
538 		conf = MCDE_CHNL2CONF;
539 		sync = MCDE_CHNL2SYNCHMOD;
540 		stat = MCDE_CHNL2STAT;
541 		bgcol = MCDE_CHNL2BCKGNDCOL;
542 		mux = MCDE_CHNL2MUXING;
543 		break;
544 	case MCDE_CHANNEL_3:
545 		conf = MCDE_CHNL3CONF;
546 		sync = MCDE_CHNL3SYNCHMOD;
547 		stat = MCDE_CHNL3STAT;
548 		bgcol = MCDE_CHNL3BCKGNDCOL;
549 		mux = MCDE_CHNL3MUXING;
550 		return;
551 	}
552 
553 	/* Set up channel 0 sync (based on chnl_update_registers()) */
554 	switch (mcde->flow_mode) {
555 	case MCDE_COMMAND_ONESHOT_FLOW:
556 		/* Oneshot is achieved with software sync */
557 		val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SOFTWARE
558 			<< MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
559 		break;
560 	case MCDE_COMMAND_TE_FLOW:
561 		val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE
562 			<< MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
563 		val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_TE0
564 			<< MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT;
565 		break;
566 	case MCDE_COMMAND_BTA_TE_FLOW:
567 		val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE
568 			<< MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
569 		/*
570 		 * TODO:
571 		 * The vendor driver uses the formatter as sync source
572 		 * for BTA TE mode. Test to use TE if you have a panel
573 		 * that uses this mode.
574 		 */
575 		val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_FORMATTER
576 			<< MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT;
577 		break;
578 	case MCDE_VIDEO_TE_FLOW:
579 		val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE
580 			<< MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
581 		val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_TE0
582 			<< MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT;
583 		break;
584 	case MCDE_VIDEO_FORMATTER_FLOW:
585 	case MCDE_DPI_FORMATTER_FLOW:
586 		val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE
587 			<< MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
588 		val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_FORMATTER
589 			<< MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT;
590 		break;
591 	default:
592 		dev_err(mcde->dev, "unknown flow mode %d\n",
593 			mcde->flow_mode);
594 		return;
595 	}
596 
597 	writel(val, mcde->regs + sync);
598 
599 	/* Set up pixels per line and lines per frame */
600 	val = (mode->hdisplay - 1) << MCDE_CHNLXCONF_PPL_SHIFT;
601 	val |= (mode->vdisplay - 1) << MCDE_CHNLXCONF_LPF_SHIFT;
602 	writel(val, mcde->regs + conf);
603 
604 	/*
605 	 * Normalize color conversion:
606 	 * black background, OLED conversion disable on channel
607 	 */
608 	val = MCDE_CHNLXSTAT_CHNLBLBCKGND_EN |
609 		MCDE_CHNLXSTAT_CHNLRD;
610 	writel(val, mcde->regs + stat);
611 	writel(0, mcde->regs + bgcol);
612 
613 	/* Set up muxing: connect the channel to the desired FIFO */
614 	switch (fifo) {
615 	case MCDE_FIFO_A:
616 		writel(MCDE_CHNLXMUXING_FIFO_ID_FIFO_A,
617 		       mcde->regs + mux);
618 		break;
619 	case MCDE_FIFO_B:
620 		writel(MCDE_CHNLXMUXING_FIFO_ID_FIFO_B,
621 		       mcde->regs + mux);
622 		break;
623 	}
624 
625 	/*
626 	 * If using DPI configure the sync event.
627 	 * TODO: this is for LCD only, it does not cover TV out.
628 	 */
629 	if (mcde->dpi_output) {
630 		u32 stripwidth;
631 
632 		stripwidth = 0xF000 / (mode->vdisplay * 4);
633 		dev_info(mcde->dev, "stripwidth: %d\n", stripwidth);
634 
635 		val = MCDE_SYNCHCONF_HWREQVEVENT_ACTIVE_VIDEO |
636 			(mode->hdisplay - 1 - stripwidth) << MCDE_SYNCHCONF_HWREQVCNT_SHIFT |
637 			MCDE_SYNCHCONF_SWINTVEVENT_ACTIVE_VIDEO |
638 			(mode->hdisplay - 1 - stripwidth) << MCDE_SYNCHCONF_SWINTVCNT_SHIFT;
639 
640 		switch (fifo) {
641 		case MCDE_FIFO_A:
642 			writel(val, mcde->regs + MCDE_SYNCHCONFA);
643 			break;
644 		case MCDE_FIFO_B:
645 			writel(val, mcde->regs + MCDE_SYNCHCONFB);
646 			break;
647 		}
648 	}
649 }
650 
651 static void mcde_configure_fifo(struct mcde *mcde, enum mcde_fifo fifo,
652 				enum mcde_formatter fmt,
653 				int fifo_wtrmrk)
654 {
655 	u32 val;
656 	u32 ctrl;
657 	u32 cr0, cr1;
658 
659 	switch (fifo) {
660 	case MCDE_FIFO_A:
661 		ctrl = MCDE_CTRLA;
662 		cr0 = MCDE_CRA0;
663 		cr1 = MCDE_CRA1;
664 		break;
665 	case MCDE_FIFO_B:
666 		ctrl = MCDE_CTRLB;
667 		cr0 = MCDE_CRB0;
668 		cr1 = MCDE_CRB1;
669 		break;
670 	}
671 
672 	val = fifo_wtrmrk << MCDE_CTRLX_FIFOWTRMRK_SHIFT;
673 
674 	/*
675 	 * Select the formatter to use for this FIFO
676 	 *
677 	 * The register definitions imply that different IDs should be used
678 	 * by the DSI formatters depending on if they are in VID or CMD
679 	 * mode, and the manual says they are dedicated but identical.
680 	 * The vendor code uses them as it seems fit.
681 	 */
682 	switch (fmt) {
683 	case MCDE_DSI_FORMATTER_0:
684 		val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT;
685 		val |= MCDE_CTRLX_FORMID_DSI0VID << MCDE_CTRLX_FORMID_SHIFT;
686 		break;
687 	case MCDE_DSI_FORMATTER_1:
688 		val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT;
689 		val |= MCDE_CTRLX_FORMID_DSI0CMD << MCDE_CTRLX_FORMID_SHIFT;
690 		break;
691 	case MCDE_DSI_FORMATTER_2:
692 		val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT;
693 		val |= MCDE_CTRLX_FORMID_DSI1VID << MCDE_CTRLX_FORMID_SHIFT;
694 		break;
695 	case MCDE_DSI_FORMATTER_3:
696 		val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT;
697 		val |= MCDE_CTRLX_FORMID_DSI1CMD << MCDE_CTRLX_FORMID_SHIFT;
698 		break;
699 	case MCDE_DSI_FORMATTER_4:
700 		val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT;
701 		val |= MCDE_CTRLX_FORMID_DSI2VID << MCDE_CTRLX_FORMID_SHIFT;
702 		break;
703 	case MCDE_DSI_FORMATTER_5:
704 		val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT;
705 		val |= MCDE_CTRLX_FORMID_DSI2CMD << MCDE_CTRLX_FORMID_SHIFT;
706 		break;
707 	case MCDE_DPI_FORMATTER_0:
708 		val |= MCDE_CTRLX_FORMTYPE_DPITV << MCDE_CTRLX_FORMTYPE_SHIFT;
709 		val |= MCDE_CTRLX_FORMID_DPIA << MCDE_CTRLX_FORMID_SHIFT;
710 		break;
711 	case MCDE_DPI_FORMATTER_1:
712 		val |= MCDE_CTRLX_FORMTYPE_DPITV << MCDE_CTRLX_FORMTYPE_SHIFT;
713 		val |= MCDE_CTRLX_FORMID_DPIB << MCDE_CTRLX_FORMID_SHIFT;
714 		break;
715 	}
716 	writel(val, mcde->regs + ctrl);
717 
718 	/* Blend source with Alpha 0xff on FIFO */
719 	val = MCDE_CRX0_BLENDEN |
720 		0xff << MCDE_CRX0_ALPHABLEND_SHIFT;
721 	writel(val, mcde->regs + cr0);
722 
723 	spin_lock(&mcde->fifo_crx1_lock);
724 	val = readl(mcde->regs + cr1);
725 	/*
726 	 * Set-up from mcde_fmtr_dsi.c, fmtr_dsi_enable_video()
727 	 * FIXME: a different clock needs to be selected for TV out.
728 	 */
729 	if (mcde->dpi_output) {
730 		struct drm_connector *connector = drm_panel_bridge_connector(mcde->bridge);
731 		u32 bus_format;
732 
733 		/* Assume RGB888 24 bit if we have no further info */
734 		if (!connector->display_info.num_bus_formats) {
735 			dev_info(mcde->dev, "panel does not specify bus format, assume RGB888\n");
736 			bus_format = MEDIA_BUS_FMT_RGB888_1X24;
737 		} else {
738 			bus_format = connector->display_info.bus_formats[0];
739 		}
740 
741 		/*
742 		 * Set up the CDWIN and OUTBPP for the LCD
743 		 *
744 		 * FIXME: fill this in if you know the correspondance between the MIPI
745 		 * DPI specification and the media bus formats.
746 		 */
747 		val &= ~MCDE_CRX1_CDWIN_MASK;
748 		val &= ~MCDE_CRX1_OUTBPP_MASK;
749 		switch (bus_format) {
750 		case MEDIA_BUS_FMT_RGB888_1X24:
751 			val |= MCDE_CRX1_CDWIN_24BPP << MCDE_CRX1_CDWIN_SHIFT;
752 			val |= MCDE_CRX1_OUTBPP_24BPP << MCDE_CRX1_OUTBPP_SHIFT;
753 			break;
754 		default:
755 			dev_err(mcde->dev, "unknown bus format, assume RGB888\n");
756 			val |= MCDE_CRX1_CDWIN_24BPP << MCDE_CRX1_CDWIN_SHIFT;
757 			val |= MCDE_CRX1_OUTBPP_24BPP << MCDE_CRX1_OUTBPP_SHIFT;
758 			break;
759 		}
760 	} else {
761 		/* Use the MCDE clock for DSI */
762 		val &= ~MCDE_CRX1_CLKSEL_MASK;
763 		val |= MCDE_CRX1_CLKSEL_MCDECLK << MCDE_CRX1_CLKSEL_SHIFT;
764 	}
765 	writel(val, mcde->regs + cr1);
766 	spin_unlock(&mcde->fifo_crx1_lock);
767 };
768 
769 static void mcde_configure_dsi_formatter(struct mcde *mcde,
770 					 enum mcde_formatter fmt,
771 					 u32 formatter_frame,
772 					 int pkt_size)
773 {
774 	u32 val;
775 	u32 conf0;
776 	u32 frame;
777 	u32 pkt;
778 	u32 sync;
779 	u32 cmdw;
780 	u32 delay0, delay1;
781 
782 	switch (fmt) {
783 	case MCDE_DSI_FORMATTER_0:
784 		conf0 = MCDE_DSIVID0CONF0;
785 		frame = MCDE_DSIVID0FRAME;
786 		pkt = MCDE_DSIVID0PKT;
787 		sync = MCDE_DSIVID0SYNC;
788 		cmdw = MCDE_DSIVID0CMDW;
789 		delay0 = MCDE_DSIVID0DELAY0;
790 		delay1 = MCDE_DSIVID0DELAY1;
791 		break;
792 	case MCDE_DSI_FORMATTER_1:
793 		conf0 = MCDE_DSIVID1CONF0;
794 		frame = MCDE_DSIVID1FRAME;
795 		pkt = MCDE_DSIVID1PKT;
796 		sync = MCDE_DSIVID1SYNC;
797 		cmdw = MCDE_DSIVID1CMDW;
798 		delay0 = MCDE_DSIVID1DELAY0;
799 		delay1 = MCDE_DSIVID1DELAY1;
800 		break;
801 	case MCDE_DSI_FORMATTER_2:
802 		conf0 = MCDE_DSIVID2CONF0;
803 		frame = MCDE_DSIVID2FRAME;
804 		pkt = MCDE_DSIVID2PKT;
805 		sync = MCDE_DSIVID2SYNC;
806 		cmdw = MCDE_DSIVID2CMDW;
807 		delay0 = MCDE_DSIVID2DELAY0;
808 		delay1 = MCDE_DSIVID2DELAY1;
809 		break;
810 	default:
811 		dev_err(mcde->dev, "tried to configure a non-DSI formatter as DSI\n");
812 		return;
813 	}
814 
815 	/*
816 	 * Enable formatter
817 	 * 8 bit commands and DCS commands (notgen = not generic)
818 	 */
819 	val = MCDE_DSICONF0_CMD8 | MCDE_DSICONF0_DCSVID_NOTGEN;
820 	if (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO)
821 		val |= MCDE_DSICONF0_VID_MODE_VID;
822 	switch (mcde->mdsi->format) {
823 	case MIPI_DSI_FMT_RGB888:
824 		val |= MCDE_DSICONF0_PACKING_RGB888 <<
825 			MCDE_DSICONF0_PACKING_SHIFT;
826 		break;
827 	case MIPI_DSI_FMT_RGB666:
828 		val |= MCDE_DSICONF0_PACKING_RGB666 <<
829 			MCDE_DSICONF0_PACKING_SHIFT;
830 		break;
831 	case MIPI_DSI_FMT_RGB666_PACKED:
832 		dev_err(mcde->dev,
833 			"we cannot handle the packed RGB666 format\n");
834 		val |= MCDE_DSICONF0_PACKING_RGB666 <<
835 			MCDE_DSICONF0_PACKING_SHIFT;
836 		break;
837 	case MIPI_DSI_FMT_RGB565:
838 		val |= MCDE_DSICONF0_PACKING_RGB565 <<
839 			MCDE_DSICONF0_PACKING_SHIFT;
840 		break;
841 	default:
842 		dev_err(mcde->dev, "unknown DSI format\n");
843 		return;
844 	}
845 	writel(val, mcde->regs + conf0);
846 
847 	writel(formatter_frame, mcde->regs + frame);
848 	writel(pkt_size, mcde->regs + pkt);
849 	writel(0, mcde->regs + sync);
850 	/* Define the MIPI command: we want to write into display memory */
851 	val = MIPI_DCS_WRITE_MEMORY_CONTINUE <<
852 		MCDE_DSIVIDXCMDW_CMDW_CONTINUE_SHIFT;
853 	val |= MIPI_DCS_WRITE_MEMORY_START <<
854 		MCDE_DSIVIDXCMDW_CMDW_START_SHIFT;
855 	writel(val, mcde->regs + cmdw);
856 
857 	/*
858 	 * FIXME: the vendor driver has some hack around this value in
859 	 * CMD mode with autotrig.
860 	 */
861 	writel(0, mcde->regs + delay0);
862 	writel(0, mcde->regs + delay1);
863 }
864 
865 static void mcde_enable_fifo(struct mcde *mcde, enum mcde_fifo fifo)
866 {
867 	u32 val;
868 	u32 cr;
869 
870 	switch (fifo) {
871 	case MCDE_FIFO_A:
872 		cr = MCDE_CRA0;
873 		break;
874 	case MCDE_FIFO_B:
875 		cr = MCDE_CRB0;
876 		break;
877 	default:
878 		dev_err(mcde->dev, "cannot enable FIFO %c\n",
879 			'A' + fifo);
880 		return;
881 	}
882 
883 	spin_lock(&mcde->flow_lock);
884 	val = readl(mcde->regs + cr);
885 	val |= MCDE_CRX0_FLOEN;
886 	writel(val, mcde->regs + cr);
887 	mcde->flow_active++;
888 	spin_unlock(&mcde->flow_lock);
889 }
890 
891 static void mcde_disable_fifo(struct mcde *mcde, enum mcde_fifo fifo,
892 			      bool wait_for_drain)
893 {
894 	int timeout = 100;
895 	u32 val;
896 	u32 cr;
897 
898 	switch (fifo) {
899 	case MCDE_FIFO_A:
900 		cr = MCDE_CRA0;
901 		break;
902 	case MCDE_FIFO_B:
903 		cr = MCDE_CRB0;
904 		break;
905 	default:
906 		dev_err(mcde->dev, "cannot disable FIFO %c\n",
907 			'A' + fifo);
908 		return;
909 	}
910 
911 	spin_lock(&mcde->flow_lock);
912 	val = readl(mcde->regs + cr);
913 	val &= ~MCDE_CRX0_FLOEN;
914 	writel(val, mcde->regs + cr);
915 	mcde->flow_active = 0;
916 	spin_unlock(&mcde->flow_lock);
917 
918 	if (!wait_for_drain)
919 		return;
920 
921 	/* Check that we really drained and stopped the flow */
922 	while (readl(mcde->regs + cr) & MCDE_CRX0_FLOEN) {
923 		usleep_range(1000, 1500);
924 		if (!--timeout) {
925 			dev_err(mcde->dev,
926 				"FIFO timeout while clearing FIFO %c\n",
927 				'A' + fifo);
928 			return;
929 		}
930 	}
931 }
932 
933 /*
934  * This drains a pipe i.e. a FIFO connected to a certain channel
935  */
936 static void mcde_drain_pipe(struct mcde *mcde, enum mcde_fifo fifo,
937 			    enum mcde_channel ch)
938 {
939 	u32 val;
940 	u32 ctrl;
941 	u32 synsw;
942 
943 	switch (fifo) {
944 	case MCDE_FIFO_A:
945 		ctrl = MCDE_CTRLA;
946 		break;
947 	case MCDE_FIFO_B:
948 		ctrl = MCDE_CTRLB;
949 		break;
950 	}
951 
952 	switch (ch) {
953 	case MCDE_CHANNEL_0:
954 		synsw = MCDE_CHNL0SYNCHSW;
955 		break;
956 	case MCDE_CHANNEL_1:
957 		synsw = MCDE_CHNL1SYNCHSW;
958 		break;
959 	case MCDE_CHANNEL_2:
960 		synsw = MCDE_CHNL2SYNCHSW;
961 		break;
962 	case MCDE_CHANNEL_3:
963 		synsw = MCDE_CHNL3SYNCHSW;
964 		return;
965 	}
966 
967 	val = readl(mcde->regs + ctrl);
968 	if (!(val & MCDE_CTRLX_FIFOEMPTY)) {
969 		dev_err(mcde->dev, "Channel A FIFO not empty (handover)\n");
970 		/* Attempt to clear the FIFO */
971 		mcde_enable_fifo(mcde, fifo);
972 		/* Trigger a software sync out on respective channel (0-3) */
973 		writel(MCDE_CHNLXSYNCHSW_SW_TRIG, mcde->regs + synsw);
974 		/* Disable FIFO A flow again */
975 		mcde_disable_fifo(mcde, fifo, true);
976 	}
977 }
978 
979 static int mcde_dsi_get_pkt_div(int ppl, int fifo_size)
980 {
981 	/*
982 	 * DSI command mode line packets should be split into an even number of
983 	 * packets smaller than or equal to the fifo size.
984 	 */
985 	int div;
986 	const int max_div = DIV_ROUND_UP(MCDE_MAX_WIDTH, fifo_size);
987 
988 	for (div = 1; div < max_div; div++)
989 		if (ppl % div == 0 && ppl / div <= fifo_size)
990 			return div;
991 	return 1;
992 }
993 
994 static void mcde_setup_dpi(struct mcde *mcde, const struct drm_display_mode *mode,
995 			   int *fifo_wtrmrk_lvl)
996 {
997 	struct drm_connector *connector = drm_panel_bridge_connector(mcde->bridge);
998 	u32 hsw, hfp, hbp;
999 	u32 vsw, vfp, vbp;
1000 	u32 val;
1001 
1002 	/* FIXME: we only support LCD, implement TV out */
1003 	hsw = mode->hsync_end - mode->hsync_start;
1004 	hfp = mode->hsync_start - mode->hdisplay;
1005 	hbp = mode->htotal - mode->hsync_end;
1006 	vsw = mode->vsync_end - mode->vsync_start;
1007 	vfp = mode->vsync_start - mode->vdisplay;
1008 	vbp = mode->vtotal - mode->vsync_end;
1009 
1010 	dev_info(mcde->dev, "output on DPI LCD from channel A\n");
1011 	/* Display actual values */
1012 	dev_info(mcde->dev, "HSW: %d, HFP: %d, HBP: %d, VSW: %d, VFP: %d, VBP: %d\n",
1013 		 hsw, hfp, hbp, vsw, vfp, vbp);
1014 
1015 	/*
1016 	 * The pixel fetcher is 128 64-bit words deep = 1024 bytes.
1017 	 * One overlay of 32bpp (4 cpp) assumed, fetch 160 pixels.
1018 	 * 160 * 4 = 640 bytes.
1019 	 */
1020 	*fifo_wtrmrk_lvl = 640;
1021 
1022 	/* Set up the main control, watermark level at 7 */
1023 	val = 7 << MCDE_CONF0_IFIFOCTRLWTRMRKLVL_SHIFT;
1024 
1025 	/*
1026 	 * This sets up the internal silicon muxing of the DPI
1027 	 * lines. This is how the silicon connects out to the
1028 	 * external pins, then the pins need to be further
1029 	 * configured into "alternate functions" using pin control
1030 	 * to actually get the signals out.
1031 	 *
1032 	 * FIXME: this is hardcoded to the only setting found in
1033 	 * the wild. If we need to use different settings for
1034 	 * different DPI displays, make this parameterizable from
1035 	 * the device tree.
1036 	 */
1037 	/* 24 bits DPI: connect Ch A LSB to D[0:7] */
1038 	val |= 0 << MCDE_CONF0_OUTMUX0_SHIFT;
1039 	/* 24 bits DPI: connect Ch A MID to D[8:15] */
1040 	val |= 1 << MCDE_CONF0_OUTMUX1_SHIFT;
1041 	/* Don't care about this muxing */
1042 	val |= 0 << MCDE_CONF0_OUTMUX2_SHIFT;
1043 	/* Don't care about this muxing */
1044 	val |= 0 << MCDE_CONF0_OUTMUX3_SHIFT;
1045 	/* 24 bits DPI: connect Ch A MSB to D[32:39] */
1046 	val |= 2 << MCDE_CONF0_OUTMUX4_SHIFT;
1047 	/* Syncmux bits zero: DPI channel A */
1048 	writel(val, mcde->regs + MCDE_CONF0);
1049 
1050 	/* This hammers us into LCD mode */
1051 	writel(0, mcde->regs + MCDE_TVCRA);
1052 
1053 	/* Front porch and sync width */
1054 	val = (vsw << MCDE_TVBL1_BEL1_SHIFT);
1055 	val |= (vfp << MCDE_TVBL1_BSL1_SHIFT);
1056 	writel(val, mcde->regs + MCDE_TVBL1A);
1057 	/* The vendor driver sets the same value into TVBL2A */
1058 	writel(val, mcde->regs + MCDE_TVBL2A);
1059 
1060 	/* Vertical back porch */
1061 	val = (vbp << MCDE_TVDVO_DVO1_SHIFT);
1062 	/* The vendor drivers sets the same value into TVDVOA */
1063 	val |= (vbp << MCDE_TVDVO_DVO2_SHIFT);
1064 	writel(val, mcde->regs + MCDE_TVDVOA);
1065 
1066 	/* Horizontal back porch, as 0 = 1 cycle we need to subtract 1 */
1067 	writel((hbp - 1), mcde->regs + MCDE_TVTIM1A);
1068 
1069 	/* Horizongal sync width and horizonal front porch, 0 = 1 cycle */
1070 	val = ((hsw - 1) << MCDE_TVLBALW_LBW_SHIFT);
1071 	val |= ((hfp - 1) << MCDE_TVLBALW_ALW_SHIFT);
1072 	writel(val, mcde->regs + MCDE_TVLBALWA);
1073 
1074 	/* Blank some TV registers we don't use */
1075 	writel(0, mcde->regs + MCDE_TVISLA);
1076 	writel(0, mcde->regs + MCDE_TVBLUA);
1077 
1078 	/* Set up sync inversion etc */
1079 	val = 0;
1080 	if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1081 		val |= MCDE_LCDTIM1B_IHS;
1082 	if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1083 		val |= MCDE_LCDTIM1B_IVS;
1084 	if (connector->display_info.bus_flags & DRM_BUS_FLAG_DE_LOW)
1085 		val |= MCDE_LCDTIM1B_IOE;
1086 	if (connector->display_info.bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE)
1087 		val |= MCDE_LCDTIM1B_IPC;
1088 	writel(val, mcde->regs + MCDE_LCDTIM1A);
1089 }
1090 
1091 static void mcde_setup_dsi(struct mcde *mcde, const struct drm_display_mode *mode,
1092 			   int cpp, int *fifo_wtrmrk_lvl, int *dsi_formatter_frame,
1093 			   int *dsi_pkt_size)
1094 {
1095 	u32 formatter_ppl = mode->hdisplay; /* pixels per line */
1096 	u32 formatter_lpf = mode->vdisplay; /* lines per frame */
1097 	int formatter_frame;
1098 	int formatter_cpp;
1099 	int fifo_wtrmrk;
1100 	u32 pkt_div;
1101 	int pkt_size;
1102 	u32 val;
1103 
1104 	dev_info(mcde->dev, "output in %s mode, format %dbpp\n",
1105 		 (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) ?
1106 		 "VIDEO" : "CMD",
1107 		 mipi_dsi_pixel_format_to_bpp(mcde->mdsi->format));
1108 	formatter_cpp =
1109 		mipi_dsi_pixel_format_to_bpp(mcde->mdsi->format) / 8;
1110 	dev_info(mcde->dev, "Overlay CPP: %d bytes, DSI formatter CPP %d bytes\n",
1111 		 cpp, formatter_cpp);
1112 
1113 	/* Set up the main control, watermark level at 7 */
1114 	val = 7 << MCDE_CONF0_IFIFOCTRLWTRMRKLVL_SHIFT;
1115 
1116 	/*
1117 	 * This is the internal silicon muxing of the DPI
1118 	 * (parallell display) lines. Since we are not using
1119 	 * this at all (we are using DSI) these are just
1120 	 * dummy values from the vendor tree.
1121 	 */
1122 	val |= 3 << MCDE_CONF0_OUTMUX0_SHIFT;
1123 	val |= 3 << MCDE_CONF0_OUTMUX1_SHIFT;
1124 	val |= 0 << MCDE_CONF0_OUTMUX2_SHIFT;
1125 	val |= 4 << MCDE_CONF0_OUTMUX3_SHIFT;
1126 	val |= 5 << MCDE_CONF0_OUTMUX4_SHIFT;
1127 	writel(val, mcde->regs + MCDE_CONF0);
1128 
1129 	/* Calculations from mcde_fmtr_dsi.c, fmtr_dsi_enable_video() */
1130 
1131 	/*
1132 	 * Set up FIFO A watermark level:
1133 	 * 128 for LCD 32bpp video mode
1134 	 * 48  for LCD 32bpp command mode
1135 	 * 128 for LCD 16bpp video mode
1136 	 * 64  for LCD 16bpp command mode
1137 	 * 128 for HDMI 32bpp
1138 	 * 192 for HDMI 16bpp
1139 	 */
1140 	fifo_wtrmrk = mode->hdisplay;
1141 	if (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) {
1142 		fifo_wtrmrk = min(fifo_wtrmrk, 128);
1143 		pkt_div = 1;
1144 	} else {
1145 		fifo_wtrmrk = min(fifo_wtrmrk, 48);
1146 		/* The FIFO is 640 entries deep on this v3 hardware */
1147 		pkt_div = mcde_dsi_get_pkt_div(mode->hdisplay, 640);
1148 	}
1149 	dev_dbg(mcde->dev, "FIFO watermark after flooring: %d bytes\n",
1150 		fifo_wtrmrk);
1151 	dev_dbg(mcde->dev, "Packet divisor: %d bytes\n", pkt_div);
1152 
1153 	/* NOTE: pkt_div is 1 for video mode */
1154 	pkt_size = (formatter_ppl * formatter_cpp) / pkt_div;
1155 	/* Commands CMD8 need one extra byte */
1156 	if (!(mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO))
1157 		pkt_size++;
1158 
1159 	dev_dbg(mcde->dev, "DSI packet size: %d * %d bytes per line\n",
1160 		pkt_size, pkt_div);
1161 	dev_dbg(mcde->dev, "Overlay frame size: %u bytes\n",
1162 		mode->hdisplay * mode->vdisplay * cpp);
1163 	/* NOTE: pkt_div is 1 for video mode */
1164 	formatter_frame = pkt_size * pkt_div * formatter_lpf;
1165 	dev_dbg(mcde->dev, "Formatter frame size: %u bytes\n", formatter_frame);
1166 
1167 	*fifo_wtrmrk_lvl = fifo_wtrmrk;
1168 	*dsi_pkt_size = pkt_size;
1169 	*dsi_formatter_frame = formatter_frame;
1170 }
1171 
1172 static void mcde_crtc_helper_atomic_enable(struct drm_crtc *crtc,
1173 					   struct drm_atomic_commit *commit)
1174 {
1175 	struct drm_device *drm = crtc->dev;
1176 	struct mcde *mcde = to_mcde(drm);
1177 	struct drm_crtc_state *cstate = drm_atomic_get_new_crtc_state(commit, crtc);
1178 	struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(commit, &mcde->plane);
1179 	const struct drm_display_mode *mode = &cstate->mode;
1180 	struct drm_framebuffer *fb = plane_state->fb;
1181 	u32 format = fb->format->format;
1182 	int dsi_pkt_size;
1183 	int fifo_wtrmrk;
1184 	int cpp = fb->format->cpp[0];
1185 	u32 dsi_formatter_frame;
1186 	u32 val;
1187 	int ret;
1188 
1189 	/* This powers up the entire MCDE block and the DSI hardware */
1190 	ret = regulator_enable(mcde->epod);
1191 	if (ret) {
1192 		dev_err(drm->dev, "can't re-enable EPOD regulator\n");
1193 		return;
1194 	}
1195 
1196 	dev_info(drm->dev, "enable MCDE, %d x %d format %p4cc\n",
1197 		 mode->hdisplay, mode->vdisplay, &format);
1198 
1199 
1200 	/* Clear any pending interrupts */
1201 	mcde_display_disable_irqs(mcde);
1202 	writel(0, mcde->regs + MCDE_IMSCERR);
1203 	writel(0xFFFFFFFF, mcde->regs + MCDE_RISERR);
1204 
1205 	if (mcde->dpi_output)
1206 		mcde_setup_dpi(mcde, mode, &fifo_wtrmrk);
1207 	else
1208 		mcde_setup_dsi(mcde, mode, cpp, &fifo_wtrmrk,
1209 			       &dsi_formatter_frame, &dsi_pkt_size);
1210 
1211 	mcde->stride = mode->hdisplay * cpp;
1212 	dev_dbg(drm->dev, "Overlay line stride: %u bytes\n",
1213 		 mcde->stride);
1214 
1215 	/* Drain the FIFO A + channel 0 pipe so we have a clean slate */
1216 	mcde_drain_pipe(mcde, MCDE_FIFO_A, MCDE_CHANNEL_0);
1217 
1218 	/*
1219 	 * We set up our display pipeline:
1220 	 * EXTSRC 0 -> OVERLAY 0 -> CHANNEL 0 -> FIFO A -> DSI FORMATTER 0
1221 	 *
1222 	 * First configure the external source (memory) on external source 0
1223 	 * using the desired bitstream/bitmap format
1224 	 */
1225 	mcde_configure_extsrc(mcde, MCDE_EXTSRC_0, format);
1226 
1227 	/*
1228 	 * Configure overlay 0 according to format and mode and take input
1229 	 * from external source 0 and route the output of this overlay to
1230 	 * channel 0
1231 	 */
1232 	mcde_configure_overlay(mcde, MCDE_OVERLAY_0, MCDE_EXTSRC_0,
1233 			       MCDE_CHANNEL_0, mode, format, cpp);
1234 
1235 	/*
1236 	 * Configure pixel-per-line and line-per-frame for channel 0 and then
1237 	 * route channel 0 to FIFO A
1238 	 */
1239 	mcde_configure_channel(mcde, MCDE_CHANNEL_0, MCDE_FIFO_A, mode);
1240 
1241 	if (mcde->dpi_output) {
1242 		unsigned long lcd_freq;
1243 
1244 		/* Configure FIFO A to use DPI formatter 0 */
1245 		mcde_configure_fifo(mcde, MCDE_FIFO_A, MCDE_DPI_FORMATTER_0,
1246 				    fifo_wtrmrk);
1247 
1248 		/* Set up and enable the LCD clock */
1249 		lcd_freq = clk_round_rate(mcde->fifoa_clk, mode->clock * 1000);
1250 		ret = clk_set_rate(mcde->fifoa_clk, lcd_freq);
1251 		if (ret)
1252 			dev_err(mcde->dev, "failed to set LCD clock rate %lu Hz\n",
1253 				lcd_freq);
1254 		ret = clk_prepare_enable(mcde->fifoa_clk);
1255 		if (ret) {
1256 			dev_err(mcde->dev, "failed to enable FIFO A DPI clock\n");
1257 			return;
1258 		}
1259 		dev_info(mcde->dev, "LCD FIFO A clk rate %lu Hz\n",
1260 			 clk_get_rate(mcde->fifoa_clk));
1261 	} else {
1262 		/* Configure FIFO A to use DSI formatter 0 */
1263 		mcde_configure_fifo(mcde, MCDE_FIFO_A, MCDE_DSI_FORMATTER_0,
1264 				    fifo_wtrmrk);
1265 
1266 		/*
1267 		 * This brings up the DSI bridge which is tightly connected
1268 		 * to the MCDE DSI formatter.
1269 		 */
1270 		mcde_dsi_enable(mcde->bridge);
1271 
1272 		/* Configure the DSI formatter 0 for the DSI panel output */
1273 		mcde_configure_dsi_formatter(mcde, MCDE_DSI_FORMATTER_0,
1274 					     dsi_formatter_frame, dsi_pkt_size);
1275 	}
1276 
1277 	switch (mcde->flow_mode) {
1278 	case MCDE_COMMAND_TE_FLOW:
1279 	case MCDE_COMMAND_BTA_TE_FLOW:
1280 	case MCDE_VIDEO_TE_FLOW:
1281 		/* We are using TE in some combination */
1282 		if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1283 			val = MCDE_VSCRC_VSPOL;
1284 		else
1285 			val = 0;
1286 		writel(val, mcde->regs + MCDE_VSCRC0);
1287 		/* Enable VSYNC capture on TE0 */
1288 		val = readl(mcde->regs + MCDE_CRC);
1289 		val |= MCDE_CRC_SYCEN0;
1290 		writel(val, mcde->regs + MCDE_CRC);
1291 		break;
1292 	default:
1293 		/* No TE capture */
1294 		break;
1295 	}
1296 
1297 	drm_crtc_vblank_on(crtc);
1298 
1299 	/*
1300 	 * If we're using oneshot mode we don't start the flow
1301 	 * until each time the display is given an update, and
1302 	 * then we disable it immediately after. For all other
1303 	 * modes (command or video) we start the FIFO flow
1304 	 * right here. This is necessary for the hardware to
1305 	 * behave right.
1306 	 */
1307 	if (mcde->flow_mode != MCDE_COMMAND_ONESHOT_FLOW) {
1308 		mcde_enable_fifo(mcde, MCDE_FIFO_A);
1309 		dev_dbg(mcde->dev, "started MCDE video FIFO flow\n");
1310 	}
1311 
1312 	/* Enable MCDE with automatic clock gating */
1313 	val = readl(mcde->regs + MCDE_CR);
1314 	val |= MCDE_CR_MCDEEN | MCDE_CR_AUTOCLKG_EN;
1315 	writel(val, mcde->regs + MCDE_CR);
1316 
1317 	dev_info(drm->dev, "MCDE display is enabled\n");
1318 }
1319 
1320 static void mcde_crtc_helper_atomic_disable(struct drm_crtc *crtc,
1321 					    struct drm_atomic_commit *commit)
1322 {
1323 	struct drm_crtc_state *cstate = drm_atomic_get_new_crtc_state(commit, crtc);
1324 	struct drm_device *drm = crtc->dev;
1325 	struct mcde *mcde = to_mcde(drm);
1326 	struct drm_pending_vblank_event *event;
1327 	int ret;
1328 
1329 	drm_crtc_vblank_off(crtc);
1330 
1331 	/* Disable FIFO A flow */
1332 	mcde_disable_fifo(mcde, MCDE_FIFO_A, true);
1333 
1334 	if (mcde->dpi_output) {
1335 		clk_disable_unprepare(mcde->fifoa_clk);
1336 	} else {
1337 		/* This disables the DSI bridge */
1338 		mcde_dsi_disable(mcde->bridge);
1339 	}
1340 
1341 	event = cstate->event;
1342 	if (event) {
1343 		cstate->event = NULL;
1344 
1345 		spin_lock_irq(&crtc->dev->event_lock);
1346 		drm_crtc_send_vblank_event(crtc, event);
1347 		spin_unlock_irq(&crtc->dev->event_lock);
1348 	}
1349 
1350 	ret = regulator_disable(mcde->epod);
1351 	if (ret)
1352 		dev_err(drm->dev, "can't disable EPOD regulator\n");
1353 	/* Make sure we are powered down (before we may power up again) */
1354 	usleep_range(50000, 70000);
1355 
1356 	dev_info(drm->dev, "MCDE display is disabled\n");
1357 }
1358 
1359 static void mcde_start_flow(struct mcde *mcde)
1360 {
1361 	/* Request a TE ACK only in TE+BTA mode */
1362 	if (mcde->flow_mode == MCDE_COMMAND_BTA_TE_FLOW)
1363 		mcde_dsi_te_request(mcde->mdsi);
1364 
1365 	/* Enable FIFO A flow */
1366 	mcde_enable_fifo(mcde, MCDE_FIFO_A);
1367 
1368 	/*
1369 	 * If oneshot mode is enabled, the flow will be disabled
1370 	 * when the TE0 IRQ arrives in the interrupt handler. Otherwise
1371 	 * updates are continuously streamed to the display after this
1372 	 * point.
1373 	 */
1374 
1375 	if (mcde->flow_mode == MCDE_COMMAND_ONESHOT_FLOW) {
1376 		/* Trigger a software sync out on channel 0 */
1377 		writel(MCDE_CHNLXSYNCHSW_SW_TRIG,
1378 		       mcde->regs + MCDE_CHNL0SYNCHSW);
1379 
1380 		/*
1381 		 * Disable FIFO A flow again: since we are using TE sync we
1382 		 * need to wait for the FIFO to drain before we continue
1383 		 * so repeated calls to this function will not cause a mess
1384 		 * in the hardware by pushing updates will updates are going
1385 		 * on already.
1386 		 */
1387 		mcde_disable_fifo(mcde, MCDE_FIFO_A, true);
1388 	}
1389 
1390 	dev_dbg(mcde->dev, "started MCDE FIFO flow\n");
1391 }
1392 
1393 static void mcde_set_extsrc(struct mcde *mcde, u32 buffer_address)
1394 {
1395 	/* Write bitmap base address to register */
1396 	writel(buffer_address, mcde->regs + MCDE_EXTSRCXA0);
1397 	/*
1398 	 * Base address for next line this is probably only used
1399 	 * in interlace modes.
1400 	 */
1401 	writel(buffer_address + mcde->stride, mcde->regs + MCDE_EXTSRCXA1);
1402 }
1403 
1404 static void mcde_plane_helper_atomic_update(struct drm_plane *plane,
1405 					    struct drm_atomic_commit *commit)
1406 {
1407 	struct drm_plane_state *pstate = drm_atomic_get_new_plane_state(commit, plane);
1408 	struct mcde *mcde = to_mcde(plane->dev);
1409 	struct drm_framebuffer *fb = pstate->fb;
1410 
1411 	/*
1412 	 * We do not start sending framebuffer updates before the
1413 	 * display is enabled. Update events will however be dispatched
1414 	 * from the DRM core before the display is enabled.
1415 	 */
1416 	if (fb) {
1417 		mcde_set_extsrc(mcde, drm_fb_dma_get_gem_addr(fb, pstate, 0));
1418 		dev_info_once(mcde->dev, "first update of display contents\n");
1419 	} else {
1420 		/*
1421 		 * If an update is receieved before the MCDE is enabled
1422 		 * (before mcde_display_enable() is called) we can't really
1423 		 * do much with that buffer.
1424 		 */
1425 		dev_info(mcde->dev, "ignored a display update\n");
1426 	}
1427 }
1428 
1429 static void mcde_crtc_helper_atomic_flush(struct drm_crtc *crtc,
1430 					  struct drm_atomic_commit *commit)
1431 {
1432 	struct mcde *mcde = to_mcde(crtc->dev);
1433 	struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(commit, &mcde->plane);
1434 	struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(commit, crtc);
1435 	struct drm_pending_vblank_event *event = crtc_state->event;
1436 
1437 	/*
1438 	 * Handle any pending event first, we need to arm the vblank
1439 	 * interrupt before sending any update to the display so we don't
1440 	 * miss the interrupt.
1441 	 */
1442 	if (event) {
1443 		crtc_state->event = NULL;
1444 
1445 		spin_lock_irq(&crtc->dev->event_lock);
1446 		/*
1447 		 * Hardware must be on before we can arm any vblank event,
1448 		 * this is not a scanout controller where there is always
1449 		 * some periodic update going on, it is completely frozen
1450 		 * until we get an update. If MCDE output isn't yet enabled,
1451 		 * we just send a vblank dummy event back.
1452 		 */
1453 		if (crtc_state->active && drm_crtc_vblank_get(crtc) == 0) {
1454 			dev_dbg(mcde->dev, "arm vblank event\n");
1455 			drm_crtc_arm_vblank_event(crtc, event);
1456 		} else {
1457 			dev_dbg(mcde->dev, "insert fake vblank event\n");
1458 			drm_crtc_send_vblank_event(crtc, event);
1459 		}
1460 
1461 		spin_unlock_irq(&crtc->dev->event_lock);
1462 	}
1463 
1464 	if (crtc_state->active && plane_state && plane_state->fb && mcde->flow_active == 0)
1465 		mcde_start_flow(mcde);
1466 }
1467 
1468 static int mcde_crtc_enable_vblank(struct drm_crtc *crtc)
1469 {
1470 	struct drm_device *drm = crtc->dev;
1471 	struct mcde *mcde = to_mcde(drm);
1472 	u32 val;
1473 
1474 	/* Enable all VBLANK IRQs */
1475 	val = MCDE_PP_VCMPA |
1476 		MCDE_PP_VCMPB |
1477 		MCDE_PP_VSCC0 |
1478 		MCDE_PP_VSCC1 |
1479 		MCDE_PP_VCMPC0 |
1480 		MCDE_PP_VCMPC1;
1481 	writel(val, mcde->regs + MCDE_IMSCPP);
1482 
1483 	return 0;
1484 }
1485 
1486 static void mcde_crtc_disable_vblank(struct drm_crtc *crtc)
1487 {
1488 	struct drm_device *drm = crtc->dev;
1489 	struct mcde *mcde = to_mcde(drm);
1490 
1491 	/* Disable all VBLANK IRQs */
1492 	writel(0, mcde->regs + MCDE_IMSCPP);
1493 	/* Clear any pending IRQs */
1494 	writel(0xFFFFFFFF, mcde->regs + MCDE_RISPP);
1495 }
1496 
1497 static int mcde_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *commit)
1498 {
1499 	struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(commit, crtc);
1500 	int ret;
1501 
1502 	if (crtc_state->enable) {
1503 		ret = drm_atomic_helper_check_crtc_primary_plane(crtc_state);
1504 		if (ret)
1505 			return ret;
1506 	}
1507 
1508 	return drm_atomic_add_affected_planes(commit, crtc);
1509 }
1510 
1511 static const struct drm_crtc_funcs mcde_crtc_funcs = {
1512 	.atomic_create_state	= drm_atomic_helper_crtc_create_state,
1513 	.destroy		= drm_crtc_cleanup,
1514 	.set_config		= drm_atomic_helper_set_config,
1515 	.page_flip		= drm_atomic_helper_page_flip,
1516 	.atomic_duplicate_state	= drm_atomic_helper_crtc_duplicate_state,
1517 	.atomic_destroy_state	= drm_atomic_helper_crtc_destroy_state,
1518 	.enable_vblank		= mcde_crtc_enable_vblank,
1519 	.disable_vblank		= mcde_crtc_disable_vblank,
1520 };
1521 
1522 static const struct drm_crtc_helper_funcs mcde_crtc_helper_funcs = {
1523 	.atomic_check	= mcde_crtc_helper_atomic_check,
1524 	.atomic_enable	= mcde_crtc_helper_atomic_enable,
1525 	.atomic_disable	= mcde_crtc_helper_atomic_disable,
1526 	.atomic_flush	= mcde_crtc_helper_atomic_flush,
1527 };
1528 
1529 static const struct drm_plane_funcs mcde_plane_funcs = {
1530 	.update_plane		= drm_atomic_helper_update_plane,
1531 	.disable_plane		= drm_atomic_helper_disable_plane,
1532 	.atomic_create_state	= drm_atomic_helper_plane_create_state,
1533 	.destroy		= drm_plane_cleanup,
1534 	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
1535 	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
1536 };
1537 
1538 static const struct drm_plane_helper_funcs mcde_plane_helper_funcs = {
1539 	.prepare_fb	= drm_gem_plane_helper_prepare_fb,
1540 	.atomic_check	= mcde_plane_helper_atomic_check,
1541 	.atomic_update	= mcde_plane_helper_atomic_update,
1542 };
1543 
1544 static const struct drm_encoder_funcs mcde_encoder_funcs = {
1545 	.destroy = drm_encoder_cleanup,
1546 };
1547 
1548 int mcde_display_init(struct drm_device *drm)
1549 {
1550 	struct mcde *mcde = to_mcde(drm);
1551 	int ret;
1552 	static const u32 formats[] = {
1553 		DRM_FORMAT_ARGB8888,
1554 		DRM_FORMAT_ABGR8888,
1555 		DRM_FORMAT_XRGB8888,
1556 		DRM_FORMAT_XBGR8888,
1557 		DRM_FORMAT_RGB888,
1558 		DRM_FORMAT_BGR888,
1559 		DRM_FORMAT_ARGB4444,
1560 		DRM_FORMAT_ABGR4444,
1561 		DRM_FORMAT_XRGB4444,
1562 		DRM_FORMAT_XBGR4444,
1563 		/* These are actually IRGB1555 so intensity bit is lost */
1564 		DRM_FORMAT_XRGB1555,
1565 		DRM_FORMAT_XBGR1555,
1566 		DRM_FORMAT_RGB565,
1567 		DRM_FORMAT_BGR565,
1568 		DRM_FORMAT_YUV422,
1569 	};
1570 
1571 	ret = mcde_init_clock_divider(mcde);
1572 	if (ret)
1573 		return ret;
1574 
1575 	ret = drm_universal_plane_init(drm, &mcde->plane, 0,
1576 				       &mcde_plane_funcs,
1577 				       formats, ARRAY_SIZE(formats),
1578 				       NULL, DRM_PLANE_TYPE_PRIMARY, NULL);
1579 	if (ret)
1580 		return ret;
1581 
1582 	drm_plane_helper_add(&mcde->plane, &mcde_plane_helper_funcs);
1583 
1584 	ret = drm_crtc_init_with_planes(drm, &mcde->crtc, &mcde->plane,
1585 					NULL, &mcde_crtc_funcs, NULL);
1586 	if (ret)
1587 		return ret;
1588 
1589 	drm_crtc_helper_add(&mcde->crtc, &mcde_crtc_helper_funcs);
1590 
1591 	ret = drm_encoder_init(drm, &mcde->encoder, &mcde_encoder_funcs,
1592 			       DRM_MODE_ENCODER_NONE, NULL);
1593 	if (ret)
1594 		return ret;
1595 
1596 	mcde->encoder.possible_crtcs = drm_crtc_mask(&mcde->crtc);
1597 
1598 	return 0;
1599 }
1600 EXPORT_SYMBOL_GPL(mcde_display_init);
1601