1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Hisilicon Hibmc SoC drm driver
3  *
4  * Based on the bochs drm driver.
5  *
6  * Copyright (c) 2016 Huawei Limited.
7  *
8  * Author:
9  *	Rongrong Zou <zourongrong@huawei.com>
10  *	Rongrong Zou <zourongrong@gmail.com>
11  *	Jianhua Li <lijianhua@huawei.com>
12  */
13 
14 #include <linux/delay.h>
15 
16 #include <drm/drm_atomic.h>
17 #include <drm/drm_atomic_helper.h>
18 #include <drm/drm_fourcc.h>
19 #include <drm/drm_gem_vram_helper.h>
20 #include <drm/drm_vblank.h>
21 
22 #include "hibmc_drm_drv.h"
23 #include "hibmc_drm_regs.h"
24 
25 struct hibmc_display_panel_pll {
26 	unsigned long M;
27 	unsigned long N;
28 	unsigned long OD;
29 	unsigned long POD;
30 };
31 
32 struct hibmc_dislay_pll_config {
33 	unsigned long hdisplay;
34 	unsigned long vdisplay;
35 	u32 pll1_config_value;
36 	u32 pll2_config_value;
37 };
38 
39 static const struct hibmc_dislay_pll_config hibmc_pll_table[] = {
40 	{640, 480, CRT_PLL1_HS_25MHZ, CRT_PLL2_HS_25MHZ},
41 	{800, 600, CRT_PLL1_HS_40MHZ, CRT_PLL2_HS_40MHZ},
42 	{1024, 768, CRT_PLL1_HS_65MHZ, CRT_PLL2_HS_65MHZ},
43 	{1152, 864, CRT_PLL1_HS_80MHZ_1152, CRT_PLL2_HS_80MHZ},
44 	{1280, 768, CRT_PLL1_HS_80MHZ, CRT_PLL2_HS_80MHZ},
45 	{1280, 720, CRT_PLL1_HS_74MHZ, CRT_PLL2_HS_74MHZ},
46 	{1280, 960, CRT_PLL1_HS_108MHZ, CRT_PLL2_HS_108MHZ},
47 	{1280, 1024, CRT_PLL1_HS_108MHZ, CRT_PLL2_HS_108MHZ},
48 	{1440, 900, CRT_PLL1_HS_106MHZ, CRT_PLL2_HS_106MHZ},
49 	{1600, 900, CRT_PLL1_HS_108MHZ, CRT_PLL2_HS_108MHZ},
50 	{1600, 1200, CRT_PLL1_HS_162MHZ, CRT_PLL2_HS_162MHZ},
51 	{1920, 1080, CRT_PLL1_HS_148MHZ, CRT_PLL2_HS_148MHZ},
52 	{1920, 1200, CRT_PLL1_HS_193MHZ, CRT_PLL2_HS_193MHZ},
53 };
54 
55 #define PADDING(align, data) (((data) + (align) - 1) & (~((align) - 1)))
56 
hibmc_plane_atomic_check(struct drm_plane * plane,struct drm_plane_state * state)57 static int hibmc_plane_atomic_check(struct drm_plane *plane,
58 				    struct drm_plane_state *state)
59 {
60 	struct drm_framebuffer *fb = state->fb;
61 	struct drm_crtc *crtc = state->crtc;
62 	struct drm_crtc_state *crtc_state;
63 	u32 src_w = state->src_w >> 16;
64 	u32 src_h = state->src_h >> 16;
65 
66 	if (!crtc || !fb)
67 		return 0;
68 
69 	crtc_state = drm_atomic_get_crtc_state(state->state, crtc);
70 	if (IS_ERR(crtc_state))
71 		return PTR_ERR(crtc_state);
72 
73 	if (src_w != state->crtc_w || src_h != state->crtc_h) {
74 		drm_dbg_atomic(plane->dev, "scale not support\n");
75 		return -EINVAL;
76 	}
77 
78 	if (state->crtc_x < 0 || state->crtc_y < 0) {
79 		drm_dbg_atomic(plane->dev, "crtc_x/y of drm_plane state is invalid\n");
80 		return -EINVAL;
81 	}
82 
83 	if (!crtc_state->enable)
84 		return 0;
85 
86 	if (state->crtc_x + state->crtc_w >
87 	    crtc_state->adjusted_mode.hdisplay ||
88 	    state->crtc_y + state->crtc_h >
89 	    crtc_state->adjusted_mode.vdisplay) {
90 		drm_dbg_atomic(plane->dev, "visible portion of plane is invalid\n");
91 		return -EINVAL;
92 	}
93 
94 	if (state->fb->pitches[0] % 128 != 0) {
95 		drm_dbg_atomic(plane->dev, "wrong stride with 128-byte aligned\n");
96 		return -EINVAL;
97 	}
98 	return 0;
99 }
100 
hibmc_plane_atomic_update(struct drm_plane * plane,struct drm_plane_state * old_state)101 static void hibmc_plane_atomic_update(struct drm_plane *plane,
102 				      struct drm_plane_state *old_state)
103 {
104 	struct drm_plane_state	*state	= plane->state;
105 	u32 reg;
106 	s64 gpu_addr = 0;
107 	unsigned int line_l;
108 	struct hibmc_drm_private *priv = plane->dev->dev_private;
109 	struct drm_gem_vram_object *gbo;
110 
111 	if (!state->fb)
112 		return;
113 
114 	gbo = drm_gem_vram_of_gem(state->fb->obj[0]);
115 
116 	gpu_addr = drm_gem_vram_offset(gbo);
117 	if (WARN_ON_ONCE(gpu_addr < 0))
118 		return; /* Bug: we didn't pin the BO to VRAM in prepare_fb. */
119 
120 	writel(gpu_addr, priv->mmio + HIBMC_CRT_FB_ADDRESS);
121 
122 	reg = state->fb->width * (state->fb->format->cpp[0]);
123 
124 	line_l = state->fb->pitches[0];
125 	writel(HIBMC_FIELD(HIBMC_CRT_FB_WIDTH_WIDTH, reg) |
126 	       HIBMC_FIELD(HIBMC_CRT_FB_WIDTH_OFFS, line_l),
127 	       priv->mmio + HIBMC_CRT_FB_WIDTH);
128 
129 	/* SET PIXEL FORMAT */
130 	reg = readl(priv->mmio + HIBMC_CRT_DISP_CTL);
131 	reg &= ~HIBMC_CRT_DISP_CTL_FORMAT_MASK;
132 	reg |= HIBMC_FIELD(HIBMC_CRT_DISP_CTL_FORMAT,
133 			   state->fb->format->cpp[0] * 8 / 16);
134 	writel(reg, priv->mmio + HIBMC_CRT_DISP_CTL);
135 }
136 
137 static const u32 channel_formats1[] = {
138 	DRM_FORMAT_RGB565, DRM_FORMAT_BGR565, DRM_FORMAT_RGB888,
139 	DRM_FORMAT_BGR888, DRM_FORMAT_XRGB8888, DRM_FORMAT_XBGR8888,
140 	DRM_FORMAT_RGBA8888, DRM_FORMAT_BGRA8888, DRM_FORMAT_ARGB8888,
141 	DRM_FORMAT_ABGR8888
142 };
143 
144 static struct drm_plane_funcs hibmc_plane_funcs = {
145 	.update_plane	= drm_atomic_helper_update_plane,
146 	.disable_plane	= drm_atomic_helper_disable_plane,
147 	.destroy = drm_plane_cleanup,
148 	.reset = drm_atomic_helper_plane_reset,
149 	.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
150 	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
151 };
152 
153 static const struct drm_plane_helper_funcs hibmc_plane_helper_funcs = {
154 	.prepare_fb	= drm_gem_vram_plane_helper_prepare_fb,
155 	.cleanup_fb	= drm_gem_vram_plane_helper_cleanup_fb,
156 	.atomic_check = hibmc_plane_atomic_check,
157 	.atomic_update = hibmc_plane_atomic_update,
158 };
159 
hibmc_crtc_dpms(struct drm_crtc * crtc,int dpms)160 static void hibmc_crtc_dpms(struct drm_crtc *crtc, int dpms)
161 {
162 	struct hibmc_drm_private *priv = crtc->dev->dev_private;
163 	unsigned int reg;
164 
165 	reg = readl(priv->mmio + HIBMC_CRT_DISP_CTL);
166 	reg &= ~HIBMC_CRT_DISP_CTL_DPMS_MASK;
167 	reg |= HIBMC_FIELD(HIBMC_CRT_DISP_CTL_DPMS, dpms);
168 	reg &= ~HIBMC_CRT_DISP_CTL_TIMING_MASK;
169 	if (dpms == HIBMC_CRT_DPMS_ON)
170 		reg |= HIBMC_CRT_DISP_CTL_TIMING(1);
171 	writel(reg, priv->mmio + HIBMC_CRT_DISP_CTL);
172 }
173 
hibmc_crtc_atomic_enable(struct drm_crtc * crtc,struct drm_crtc_state * old_state)174 static void hibmc_crtc_atomic_enable(struct drm_crtc *crtc,
175 				     struct drm_crtc_state *old_state)
176 {
177 	unsigned int reg;
178 	struct hibmc_drm_private *priv = crtc->dev->dev_private;
179 
180 	hibmc_set_power_mode(priv, HIBMC_PW_MODE_CTL_MODE_MODE0);
181 
182 	/* Enable display power gate & LOCALMEM power gate*/
183 	reg = readl(priv->mmio + HIBMC_CURRENT_GATE);
184 	reg &= ~HIBMC_CURR_GATE_LOCALMEM_MASK;
185 	reg &= ~HIBMC_CURR_GATE_DISPLAY_MASK;
186 	reg |= HIBMC_CURR_GATE_LOCALMEM(1);
187 	reg |= HIBMC_CURR_GATE_DISPLAY(1);
188 	hibmc_set_current_gate(priv, reg);
189 	drm_crtc_vblank_on(crtc);
190 	hibmc_crtc_dpms(crtc, HIBMC_CRT_DPMS_ON);
191 }
192 
hibmc_crtc_atomic_disable(struct drm_crtc * crtc,struct drm_crtc_state * old_state)193 static void hibmc_crtc_atomic_disable(struct drm_crtc *crtc,
194 				      struct drm_crtc_state *old_state)
195 {
196 	unsigned int reg;
197 	struct hibmc_drm_private *priv = crtc->dev->dev_private;
198 
199 	hibmc_crtc_dpms(crtc, HIBMC_CRT_DPMS_OFF);
200 	drm_crtc_vblank_off(crtc);
201 
202 	hibmc_set_power_mode(priv, HIBMC_PW_MODE_CTL_MODE_SLEEP);
203 
204 	/* Enable display power gate & LOCALMEM power gate*/
205 	reg = readl(priv->mmio + HIBMC_CURRENT_GATE);
206 	reg &= ~HIBMC_CURR_GATE_LOCALMEM_MASK;
207 	reg &= ~HIBMC_CURR_GATE_DISPLAY_MASK;
208 	reg |= HIBMC_CURR_GATE_LOCALMEM(0);
209 	reg |= HIBMC_CURR_GATE_DISPLAY(0);
210 	hibmc_set_current_gate(priv, reg);
211 }
212 
213 static enum drm_mode_status
hibmc_crtc_mode_valid(struct drm_crtc * crtc,const struct drm_display_mode * mode)214 hibmc_crtc_mode_valid(struct drm_crtc *crtc,
215 		      const struct drm_display_mode *mode)
216 {
217 	int i = 0;
218 	int vrefresh = drm_mode_vrefresh(mode);
219 
220 	if (vrefresh < 59 || vrefresh > 61)
221 		return MODE_NOCLOCK;
222 
223 	for (i = 0; i < ARRAY_SIZE(hibmc_pll_table); i++) {
224 		if (hibmc_pll_table[i].hdisplay == mode->hdisplay &&
225 		    hibmc_pll_table[i].vdisplay == mode->vdisplay)
226 			return MODE_OK;
227 	}
228 
229 	return MODE_BAD;
230 }
231 
format_pll_reg(void)232 static unsigned int format_pll_reg(void)
233 {
234 	unsigned int pllreg = 0;
235 	struct hibmc_display_panel_pll pll = {0};
236 
237 	/*
238 	 * Note that all PLL's have the same format. Here,
239 	 * we just use Panel PLL parameter to work out the bit
240 	 * fields in the register.On returning a 32 bit number, the value can
241 	 * be applied to any PLL in the calling function.
242 	 */
243 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_BYPASS, 0);
244 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_POWER, 1);
245 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_INPUT, 0);
246 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_POD, pll.POD);
247 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_OD, pll.OD);
248 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_N, pll.N);
249 	pllreg |= HIBMC_FIELD(HIBMC_PLL_CTRL_M, pll.M);
250 
251 	return pllreg;
252 }
253 
set_vclock_hisilicon(struct drm_device * dev,unsigned long pll)254 static void set_vclock_hisilicon(struct drm_device *dev, unsigned long pll)
255 {
256 	u32 val;
257 	struct hibmc_drm_private *priv = dev->dev_private;
258 
259 	val = readl(priv->mmio + CRT_PLL1_HS);
260 	val &= ~(CRT_PLL1_HS_OUTER_BYPASS(1));
261 	writel(val, priv->mmio + CRT_PLL1_HS);
262 
263 	val = CRT_PLL1_HS_INTER_BYPASS(1) | CRT_PLL1_HS_POWERON(1);
264 	writel(val, priv->mmio + CRT_PLL1_HS);
265 
266 	writel(pll, priv->mmio + CRT_PLL1_HS);
267 
268 	usleep_range(1000, 2000);
269 
270 	val = pll & ~(CRT_PLL1_HS_POWERON(1));
271 	writel(val, priv->mmio + CRT_PLL1_HS);
272 
273 	usleep_range(1000, 2000);
274 
275 	val &= ~(CRT_PLL1_HS_INTER_BYPASS(1));
276 	writel(val, priv->mmio + CRT_PLL1_HS);
277 
278 	usleep_range(1000, 2000);
279 
280 	val |= CRT_PLL1_HS_OUTER_BYPASS(1);
281 	writel(val, priv->mmio + CRT_PLL1_HS);
282 }
283 
get_pll_config(unsigned long x,unsigned long y,u32 * pll1,u32 * pll2)284 static void get_pll_config(unsigned long x, unsigned long y,
285 			   u32 *pll1, u32 *pll2)
286 {
287 	int i;
288 	int count = ARRAY_SIZE(hibmc_pll_table);
289 
290 	for (i = 0; i < count; i++) {
291 		if (hibmc_pll_table[i].hdisplay == x &&
292 		    hibmc_pll_table[i].vdisplay == y) {
293 			*pll1 = hibmc_pll_table[i].pll1_config_value;
294 			*pll2 = hibmc_pll_table[i].pll2_config_value;
295 			return;
296 		}
297 	}
298 
299 	/* if found none, we use default value */
300 	*pll1 = CRT_PLL1_HS_25MHZ;
301 	*pll2 = CRT_PLL2_HS_25MHZ;
302 }
303 
304 /*
305  * This function takes care the extra registers and bit fields required to
306  * setup a mode in board.
307  * Explanation about Display Control register:
308  * FPGA only supports 7 predefined pixel clocks, and clock select is
309  * in bit 4:0 of new register 0x802a8.
310  */
display_ctrl_adjust(struct drm_device * dev,struct drm_display_mode * mode,unsigned int ctrl)311 static unsigned int display_ctrl_adjust(struct drm_device *dev,
312 					struct drm_display_mode *mode,
313 					unsigned int ctrl)
314 {
315 	unsigned long x, y;
316 	u32 pll1; /* bit[31:0] of PLL */
317 	u32 pll2; /* bit[63:32] of PLL */
318 	struct hibmc_drm_private *priv = dev->dev_private;
319 
320 	x = mode->hdisplay;
321 	y = mode->vdisplay;
322 
323 	get_pll_config(x, y, &pll1, &pll2);
324 	writel(pll2, priv->mmio + CRT_PLL2_HS);
325 	set_vclock_hisilicon(dev, pll1);
326 
327 	/*
328 	 * Hisilicon has to set up the top-left and bottom-right
329 	 * registers as well.
330 	 * Note that normal chip only use those two register for
331 	 * auto-centering mode.
332 	 */
333 	writel(HIBMC_FIELD(HIBMC_CRT_AUTO_CENTERING_TL_TOP, 0) |
334 	       HIBMC_FIELD(HIBMC_CRT_AUTO_CENTERING_TL_LEFT, 0),
335 	       priv->mmio + HIBMC_CRT_AUTO_CENTERING_TL);
336 
337 	writel(HIBMC_FIELD(HIBMC_CRT_AUTO_CENTERING_BR_BOTTOM, y - 1) |
338 	       HIBMC_FIELD(HIBMC_CRT_AUTO_CENTERING_BR_RIGHT, x - 1),
339 	       priv->mmio + HIBMC_CRT_AUTO_CENTERING_BR);
340 
341 	/*
342 	 * Assume common fields in ctrl have been properly set before
343 	 * calling this function.
344 	 * This function only sets the extra fields in ctrl.
345 	 */
346 
347 	/* Set bit 25 of display controller: Select CRT or VGA clock */
348 	ctrl &= ~HIBMC_CRT_DISP_CTL_CRTSELECT_MASK;
349 	ctrl &= ~HIBMC_CRT_DISP_CTL_CLOCK_PHASE_MASK;
350 
351 	ctrl |= HIBMC_CRT_DISP_CTL_CRTSELECT(HIBMC_CRTSELECT_CRT);
352 
353 	/* clock_phase_polarity is 0 */
354 	ctrl |= HIBMC_CRT_DISP_CTL_CLOCK_PHASE(0);
355 
356 	writel(ctrl, priv->mmio + HIBMC_CRT_DISP_CTL);
357 
358 	return ctrl;
359 }
360 
hibmc_crtc_mode_set_nofb(struct drm_crtc * crtc)361 static void hibmc_crtc_mode_set_nofb(struct drm_crtc *crtc)
362 {
363 	unsigned int val;
364 	struct drm_display_mode *mode = &crtc->state->mode;
365 	struct drm_device *dev = crtc->dev;
366 	struct hibmc_drm_private *priv = dev->dev_private;
367 	int width = mode->hsync_end - mode->hsync_start;
368 	int height = mode->vsync_end - mode->vsync_start;
369 
370 	writel(format_pll_reg(), priv->mmio + HIBMC_CRT_PLL_CTRL);
371 	writel(HIBMC_FIELD(HIBMC_CRT_HORZ_TOTAL_TOTAL, mode->htotal - 1) |
372 	       HIBMC_FIELD(HIBMC_CRT_HORZ_TOTAL_DISP_END, mode->hdisplay - 1),
373 	       priv->mmio + HIBMC_CRT_HORZ_TOTAL);
374 
375 	writel(HIBMC_FIELD(HIBMC_CRT_HORZ_SYNC_WIDTH, width) |
376 	       HIBMC_FIELD(HIBMC_CRT_HORZ_SYNC_START, mode->hsync_start - 1),
377 	       priv->mmio + HIBMC_CRT_HORZ_SYNC);
378 
379 	writel(HIBMC_FIELD(HIBMC_CRT_VERT_TOTAL_TOTAL, mode->vtotal - 1) |
380 	       HIBMC_FIELD(HIBMC_CRT_VERT_TOTAL_DISP_END, mode->vdisplay - 1),
381 	       priv->mmio + HIBMC_CRT_VERT_TOTAL);
382 
383 	writel(HIBMC_FIELD(HIBMC_CRT_VERT_SYNC_HEIGHT, height) |
384 	       HIBMC_FIELD(HIBMC_CRT_VERT_SYNC_START, mode->vsync_start - 1),
385 	       priv->mmio + HIBMC_CRT_VERT_SYNC);
386 
387 	val = HIBMC_FIELD(HIBMC_CRT_DISP_CTL_VSYNC_PHASE, 0);
388 	val |= HIBMC_FIELD(HIBMC_CRT_DISP_CTL_HSYNC_PHASE, 0);
389 	val |= HIBMC_CRT_DISP_CTL_TIMING(1);
390 	val |= HIBMC_CRT_DISP_CTL_PLANE(1);
391 
392 	display_ctrl_adjust(dev, mode, val);
393 }
394 
hibmc_crtc_atomic_begin(struct drm_crtc * crtc,struct drm_crtc_state * old_state)395 static void hibmc_crtc_atomic_begin(struct drm_crtc *crtc,
396 				    struct drm_crtc_state *old_state)
397 {
398 	unsigned int reg;
399 	struct drm_device *dev = crtc->dev;
400 	struct hibmc_drm_private *priv = dev->dev_private;
401 
402 	hibmc_set_power_mode(priv, HIBMC_PW_MODE_CTL_MODE_MODE0);
403 
404 	/* Enable display power gate & LOCALMEM power gate*/
405 	reg = readl(priv->mmio + HIBMC_CURRENT_GATE);
406 	reg &= ~HIBMC_CURR_GATE_DISPLAY_MASK;
407 	reg &= ~HIBMC_CURR_GATE_LOCALMEM_MASK;
408 	reg |= HIBMC_CURR_GATE_DISPLAY(1);
409 	reg |= HIBMC_CURR_GATE_LOCALMEM(1);
410 	hibmc_set_current_gate(priv, reg);
411 
412 	/* We can add more initialization as needed. */
413 }
414 
hibmc_crtc_atomic_flush(struct drm_crtc * crtc,struct drm_crtc_state * old_state)415 static void hibmc_crtc_atomic_flush(struct drm_crtc *crtc,
416 				    struct drm_crtc_state *old_state)
417 
418 {
419 	unsigned long flags;
420 
421 	spin_lock_irqsave(&crtc->dev->event_lock, flags);
422 	if (crtc->state->event)
423 		drm_crtc_send_vblank_event(crtc, crtc->state->event);
424 	crtc->state->event = NULL;
425 	spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
426 }
427 
hibmc_crtc_enable_vblank(struct drm_crtc * crtc)428 static int hibmc_crtc_enable_vblank(struct drm_crtc *crtc)
429 {
430 	struct hibmc_drm_private *priv = crtc->dev->dev_private;
431 
432 	writel(HIBMC_RAW_INTERRUPT_EN_VBLANK(1),
433 	       priv->mmio + HIBMC_RAW_INTERRUPT_EN);
434 
435 	return 0;
436 }
437 
hibmc_crtc_disable_vblank(struct drm_crtc * crtc)438 static void hibmc_crtc_disable_vblank(struct drm_crtc *crtc)
439 {
440 	struct hibmc_drm_private *priv = crtc->dev->dev_private;
441 
442 	writel(HIBMC_RAW_INTERRUPT_EN_VBLANK(0),
443 	       priv->mmio + HIBMC_RAW_INTERRUPT_EN);
444 }
445 
hibmc_crtc_load_lut(struct drm_crtc * crtc)446 static void hibmc_crtc_load_lut(struct drm_crtc *crtc)
447 {
448 	struct hibmc_drm_private *priv = crtc->dev->dev_private;
449 	void __iomem   *mmio = priv->mmio;
450 	u16 *r, *g, *b;
451 	unsigned int reg;
452 	int i;
453 
454 	r = crtc->gamma_store;
455 	g = r + crtc->gamma_size;
456 	b = g + crtc->gamma_size;
457 
458 	for (i = 0; i < crtc->gamma_size; i++) {
459 		unsigned int offset = i << 2;
460 		u8 red = *r++ >> 8;
461 		u8 green = *g++ >> 8;
462 		u8 blue = *b++ >> 8;
463 		u32 rgb = (red << 16) | (green << 8) | blue;
464 
465 		writel(rgb, mmio + HIBMC_CRT_PALETTE + offset);
466 	}
467 
468 	reg = readl(priv->mmio + HIBMC_CRT_DISP_CTL);
469 	reg |= HIBMC_FIELD(HIBMC_CTL_DISP_CTL_GAMMA, 1);
470 	writel(reg, priv->mmio + HIBMC_CRT_DISP_CTL);
471 }
472 
hibmc_crtc_gamma_set(struct drm_crtc * crtc,u16 * red,u16 * green,u16 * blue,uint32_t size,struct drm_modeset_acquire_ctx * ctx)473 static int hibmc_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green,
474 				u16 *blue, uint32_t size,
475 				struct drm_modeset_acquire_ctx *ctx)
476 {
477 	hibmc_crtc_load_lut(crtc);
478 
479 	return 0;
480 }
481 
482 static const struct drm_crtc_funcs hibmc_crtc_funcs = {
483 	.page_flip = drm_atomic_helper_page_flip,
484 	.set_config = drm_atomic_helper_set_config,
485 	.destroy = drm_crtc_cleanup,
486 	.reset = drm_atomic_helper_crtc_reset,
487 	.atomic_duplicate_state =  drm_atomic_helper_crtc_duplicate_state,
488 	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
489 	.enable_vblank = hibmc_crtc_enable_vblank,
490 	.disable_vblank = hibmc_crtc_disable_vblank,
491 	.gamma_set = hibmc_crtc_gamma_set,
492 };
493 
494 static const struct drm_crtc_helper_funcs hibmc_crtc_helper_funcs = {
495 	.mode_set_nofb	= hibmc_crtc_mode_set_nofb,
496 	.atomic_begin	= hibmc_crtc_atomic_begin,
497 	.atomic_flush	= hibmc_crtc_atomic_flush,
498 	.atomic_enable	= hibmc_crtc_atomic_enable,
499 	.atomic_disable	= hibmc_crtc_atomic_disable,
500 	.mode_valid = hibmc_crtc_mode_valid,
501 };
502 
hibmc_de_init(struct hibmc_drm_private * priv)503 int hibmc_de_init(struct hibmc_drm_private *priv)
504 {
505 	struct drm_device *dev = priv->dev;
506 	struct drm_crtc *crtc = &priv->crtc;
507 	struct drm_plane *plane = &priv->primary_plane;
508 	int ret;
509 
510 	ret = drm_universal_plane_init(dev, plane, 1, &hibmc_plane_funcs,
511 				       channel_formats1,
512 				       ARRAY_SIZE(channel_formats1),
513 				       NULL,
514 				       DRM_PLANE_TYPE_PRIMARY,
515 				       NULL);
516 
517 	if (ret) {
518 		drm_err(dev, "failed to init plane: %d\n", ret);
519 		return ret;
520 	}
521 
522 	drm_plane_helper_add(plane, &hibmc_plane_helper_funcs);
523 
524 	ret = drm_crtc_init_with_planes(dev, crtc, plane,
525 					NULL, &hibmc_crtc_funcs, NULL);
526 	if (ret) {
527 		drm_err(dev, "failed to init crtc: %d\n", ret);
528 		return ret;
529 	}
530 
531 	ret = drm_mode_crtc_set_gamma_size(crtc, 256);
532 	if (ret) {
533 		drm_err(dev, "failed to set gamma size: %d\n", ret);
534 		return ret;
535 	}
536 	drm_crtc_helper_add(crtc, &hibmc_crtc_helper_funcs);
537 
538 	return 0;
539 }
540