xref: /linux/drivers/gpu/drm/sysfb/drm_sysfb_modeset.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 // SPDX-License-Identifier: GPL-2.0-only
2 
3 #include <linux/export.h>
4 #include <linux/slab.h>
5 
6 #include <drm/drm_atomic.h>
7 #include <drm/drm_atomic_helper.h>
8 #include <drm/drm_atomic_state_helper.h>
9 #include <drm/drm_damage_helper.h>
10 #include <drm/drm_drv.h>
11 #include <drm/drm_edid.h>
12 #include <drm/drm_fourcc.h>
13 #include <drm/drm_framebuffer.h>
14 #include <drm/drm_gem_framebuffer_helper.h>
15 #include <drm/drm_panic.h>
16 #include <drm/drm_print.h>
17 #include <drm/drm_probe_helper.h>
18 
19 #include "drm_sysfb_helper.h"
20 
21 struct drm_display_mode drm_sysfb_mode(unsigned int width,
22 				       unsigned int height,
23 				       unsigned int width_mm,
24 				       unsigned int height_mm)
25 {
26 	/*
27 	 * Assume a monitor resolution of 96 dpi to
28 	 * get a somewhat reasonable screen size.
29 	 */
30 	if (!width_mm)
31 		width_mm = DRM_MODE_RES_MM(width, 96ul);
32 	if (!height_mm)
33 		height_mm = DRM_MODE_RES_MM(height, 96ul);
34 
35 	{
36 		const struct drm_display_mode mode = {
37 			DRM_MODE_INIT(60, width, height, width_mm, height_mm)
38 		};
39 
40 		return mode;
41 	}
42 }
43 EXPORT_SYMBOL(drm_sysfb_mode);
44 
45 /*
46  * Plane
47  */
48 
49 static u32 to_nonalpha_fourcc(u32 fourcc)
50 {
51 	/* only handle formats with depth != 0 and alpha channel */
52 	switch (fourcc) {
53 	case DRM_FORMAT_ARGB1555:
54 		return DRM_FORMAT_XRGB1555;
55 	case DRM_FORMAT_ABGR1555:
56 		return DRM_FORMAT_XBGR1555;
57 	case DRM_FORMAT_RGBA5551:
58 		return DRM_FORMAT_RGBX5551;
59 	case DRM_FORMAT_BGRA5551:
60 		return DRM_FORMAT_BGRX5551;
61 	case DRM_FORMAT_ARGB8888:
62 		return DRM_FORMAT_XRGB8888;
63 	case DRM_FORMAT_ABGR8888:
64 		return DRM_FORMAT_XBGR8888;
65 	case DRM_FORMAT_RGBA8888:
66 		return DRM_FORMAT_RGBX8888;
67 	case DRM_FORMAT_BGRA8888:
68 		return DRM_FORMAT_BGRX8888;
69 	case DRM_FORMAT_ARGB2101010:
70 		return DRM_FORMAT_XRGB2101010;
71 	case DRM_FORMAT_ABGR2101010:
72 		return DRM_FORMAT_XBGR2101010;
73 	case DRM_FORMAT_RGBA1010102:
74 		return DRM_FORMAT_RGBX1010102;
75 	case DRM_FORMAT_BGRA1010102:
76 		return DRM_FORMAT_BGRX1010102;
77 	}
78 
79 	return fourcc;
80 }
81 
82 static bool is_listed_fourcc(const u32 *fourccs, size_t nfourccs, u32 fourcc)
83 {
84 	const u32 *fourccs_end = fourccs + nfourccs;
85 
86 	while (fourccs < fourccs_end) {
87 		if (*fourccs == fourcc)
88 			return true;
89 		++fourccs;
90 	}
91 	return false;
92 }
93 
94 /**
95  * drm_sysfb_build_fourcc_list - Filters a list of supported color formats against
96  *                               the device's native formats
97  * @dev: DRM device
98  * @native_fourccs: 4CC codes of natively supported color formats
99  * @native_nfourccs: The number of entries in @native_fourccs
100  * @fourccs_out: Returns 4CC codes of supported color formats
101  * @nfourccs_out: The number of available entries in @fourccs_out
102  *
103  * This function create a list of supported color format from natively
104  * supported formats and additional emulated formats.
105  * At a minimum, most userspace programs expect at least support for
106  * XRGB8888 on the primary plane. Sysfb devices that have to emulate
107  * the format should use drm_sysfb_build_fourcc_list() to create a list
108  * of supported color formats. The returned list can be handed over to
109  * drm_universal_plane_init() et al. Native formats will go before
110  * emulated formats. Native formats with alpha channel will be replaced
111  * by equal formats without alpha channel, as primary planes usually
112  * don't support alpha. Other heuristics might be applied to optimize
113  * the sorting order. Formats near the beginning of the list are usually
114  * preferred over formats near the end of the list.
115  *
116  * Returns:
117  * The number of color-formats 4CC codes returned in @fourccs_out.
118  */
119 size_t drm_sysfb_build_fourcc_list(struct drm_device *dev,
120 				   const u32 *native_fourccs, size_t native_nfourccs,
121 				   u32 *fourccs_out, size_t nfourccs_out)
122 {
123 	/*
124 	 * XRGB8888 is the default fallback format for most of userspace
125 	 * and it's currently the only format that should be emulated for
126 	 * the primary plane. Only if there's ever another default fallback,
127 	 * it should be added here.
128 	 */
129 	static const u32 extra_fourccs[] = {
130 		DRM_FORMAT_XRGB8888,
131 	};
132 	static const size_t extra_nfourccs = ARRAY_SIZE(extra_fourccs);
133 
134 	u32 *fourccs = fourccs_out;
135 	const u32 *fourccs_end = fourccs_out + nfourccs_out;
136 	size_t i;
137 
138 	/*
139 	 * The device's native formats go first.
140 	 */
141 
142 	for (i = 0; i < native_nfourccs; ++i) {
143 		/*
144 		 * Several DTs, boot loaders and firmware report native
145 		 * alpha formats that are non-alpha formats instead. So
146 		 * replace alpha formats by non-alpha formats.
147 		 */
148 		u32 fourcc = to_nonalpha_fourcc(native_fourccs[i]);
149 
150 		if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
151 			continue; /* skip duplicate entries */
152 		} else if (fourccs == fourccs_end) {
153 			drm_warn(dev, "Ignoring native format %p4cc\n", &fourcc);
154 			continue; /* end of available output buffer */
155 		}
156 
157 		drm_dbg_kms(dev, "adding native format %p4cc\n", &fourcc);
158 
159 		*fourccs = fourcc;
160 		++fourccs;
161 	}
162 
163 	/*
164 	 * The extra formats, emulated by the driver, go second.
165 	 */
166 
167 	for (i = 0; (i < extra_nfourccs) && (fourccs < fourccs_end); ++i) {
168 		u32 fourcc = extra_fourccs[i];
169 
170 		if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
171 			continue; /* skip duplicate and native entries */
172 		} else if (fourccs == fourccs_end) {
173 			drm_warn(dev, "Ignoring emulated format %p4cc\n", &fourcc);
174 			continue; /* end of available output buffer */
175 		}
176 
177 		drm_dbg_kms(dev, "adding emulated format %p4cc\n", &fourcc);
178 
179 		*fourccs = fourcc;
180 		++fourccs;
181 	}
182 
183 	return fourccs - fourccs_out;
184 }
185 EXPORT_SYMBOL(drm_sysfb_build_fourcc_list);
186 
187 static void drm_sysfb_plane_state_destroy(struct drm_sysfb_plane_state *sysfb_plane_state)
188 {
189 	__drm_gem_destroy_shadow_plane_state(&sysfb_plane_state->base);
190 
191 	kfree(sysfb_plane_state);
192 }
193 
194 static void drm_sysfb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,
195 			     const struct iosys_map *src, const struct drm_framebuffer *fb,
196 			     const struct drm_rect *clip, struct drm_format_conv_state *state)
197 {
198 	drm_fb_memcpy(dst, dst_pitch, src, fb, clip);
199 }
200 
201 static drm_sysfb_blit_func drm_sysfb_get_blit_func(u32 dst_format, u32 src_format)
202 {
203 	if (src_format == dst_format) {
204 		return drm_sysfb_memcpy;
205 	} else if (src_format == DRM_FORMAT_XRGB8888) {
206 		switch (dst_format) {
207 		case DRM_FORMAT_RGB565:
208 			return drm_fb_xrgb8888_to_rgb565;
209 		case DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN:
210 			return drm_fb_xrgb8888_to_rgb565be;
211 		case DRM_FORMAT_XRGB1555:
212 			return drm_fb_xrgb8888_to_xrgb1555;
213 		case DRM_FORMAT_ARGB1555:
214 			return drm_fb_xrgb8888_to_argb1555;
215 		case DRM_FORMAT_RGBA5551:
216 			return drm_fb_xrgb8888_to_rgba5551;
217 		case DRM_FORMAT_RGB888:
218 			return drm_fb_xrgb8888_to_rgb888;
219 		case DRM_FORMAT_BGR888:
220 			return drm_fb_xrgb8888_to_bgr888;
221 		case DRM_FORMAT_ARGB8888:
222 			return drm_fb_xrgb8888_to_argb8888;
223 		case DRM_FORMAT_XBGR8888:
224 			return drm_fb_xrgb8888_to_xbgr8888;
225 		case DRM_FORMAT_ABGR8888:
226 			return drm_fb_xrgb8888_to_abgr8888;
227 		case DRM_FORMAT_XRGB2101010:
228 			return drm_fb_xrgb8888_to_xrgb2101010;
229 		case DRM_FORMAT_ARGB2101010:
230 			return drm_fb_xrgb8888_to_argb2101010;
231 		case DRM_FORMAT_BGRX8888:
232 			return drm_fb_xrgb8888_to_bgrx8888;
233 		case DRM_FORMAT_RGB332:
234 			return drm_fb_xrgb8888_to_rgb332;
235 		}
236 	}
237 
238 	return NULL;
239 }
240 
241 int drm_sysfb_plane_helper_begin_fb_access(struct drm_plane *plane,
242 					   struct drm_plane_state *plane_state)
243 {
244 	struct drm_device *dev = plane->dev;
245 	struct drm_sysfb_plane_state *sysfb_plane_state = to_drm_sysfb_plane_state(plane_state);
246 	struct drm_framebuffer *fb = plane_state->fb;
247 	struct drm_crtc_state *crtc_state;
248 	struct drm_sysfb_crtc_state *sysfb_crtc_state;
249 	drm_sysfb_blit_func blit_to_crtc;
250 	int ret;
251 
252 	ret = drm_gem_begin_shadow_fb_access(plane, plane_state);
253 	if (ret)
254 		return ret;
255 
256 	if (!fb)
257 		return 0;
258 
259 	ret = -EINVAL;
260 
261 	crtc_state = drm_atomic_get_new_crtc_state(plane_state->state, plane_state->crtc);
262 	if (drm_WARN_ON_ONCE(dev, !crtc_state))
263 		goto err_drm_gem_end_shadow_fb_access;
264 	sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state);
265 
266 	if (drm_WARN_ON_ONCE(dev, !sysfb_crtc_state->format))
267 		goto err_drm_gem_end_shadow_fb_access;
268 	blit_to_crtc = drm_sysfb_get_blit_func(sysfb_crtc_state->format->format,
269 					       fb->format->format);
270 	if (!blit_to_crtc) {
271 		drm_warn_once(dev, "No blit helper from %p4cc to %p4cc found.\n",
272 			      &fb->format->format, &sysfb_crtc_state->format->format);
273 		goto err_drm_gem_end_shadow_fb_access;
274 	}
275 	sysfb_plane_state->blit_to_crtc = blit_to_crtc;
276 
277 	return 0;
278 
279 err_drm_gem_end_shadow_fb_access:
280 	drm_gem_end_shadow_fb_access(plane, plane_state);
281 	return ret;
282 }
283 EXPORT_SYMBOL(drm_sysfb_plane_helper_begin_fb_access);
284 
285 int drm_sysfb_plane_helper_atomic_check(struct drm_plane *plane,
286 					struct drm_atomic_commit *new_state)
287 {
288 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(plane->dev);
289 	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane);
290 	struct drm_shadow_plane_state *new_shadow_plane_state =
291 		to_drm_shadow_plane_state(new_plane_state);
292 	struct drm_framebuffer *new_fb = new_plane_state->fb;
293 	struct drm_crtc *new_crtc = new_plane_state->crtc;
294 	struct drm_crtc_state *new_crtc_state = NULL;
295 	struct drm_sysfb_crtc_state *new_sysfb_crtc_state;
296 	int ret;
297 
298 	if (new_crtc)
299 		new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc);
300 
301 	ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state,
302 						  DRM_PLANE_NO_SCALING,
303 						  DRM_PLANE_NO_SCALING,
304 						  false, false);
305 	if (ret)
306 		return ret;
307 	else if (!new_plane_state->visible)
308 		return 0;
309 
310 	new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc);
311 
312 	new_sysfb_crtc_state = to_drm_sysfb_crtc_state(new_crtc_state);
313 	new_sysfb_crtc_state->format = sysfb->fb_format;
314 
315 	if (new_fb->format != new_sysfb_crtc_state->format) {
316 		void *buf;
317 
318 		/* format conversion necessary; reserve buffer */
319 		buf = drm_format_conv_state_reserve(&new_shadow_plane_state->fmtcnv_state,
320 						    sysfb->fb_pitch, GFP_KERNEL);
321 		if (!buf)
322 			return -ENOMEM;
323 	}
324 
325 	return 0;
326 }
327 EXPORT_SYMBOL(drm_sysfb_plane_helper_atomic_check);
328 
329 void drm_sysfb_plane_helper_atomic_update(struct drm_plane *plane, struct drm_atomic_commit *state)
330 {
331 	struct drm_device *dev = plane->dev;
332 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
333 	struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
334 	struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
335 	struct drm_sysfb_plane_state *sysfb_plane_state = to_drm_sysfb_plane_state(plane_state);
336 	struct drm_shadow_plane_state *shadow_plane_state = &sysfb_plane_state->base;
337 	struct drm_framebuffer *fb = plane_state->fb;
338 	unsigned int dst_pitch = sysfb->fb_pitch;
339 	struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc);
340 	struct drm_sysfb_crtc_state *sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state);
341 	const struct drm_format_info *dst_format = sysfb_crtc_state->format;
342 	drm_sysfb_blit_func blit_to_crtc = sysfb_plane_state->blit_to_crtc;
343 	struct drm_atomic_helper_damage_iter iter;
344 	struct drm_rect damage;
345 	int ret, idx;
346 
347 	ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
348 	if (ret)
349 		return;
350 
351 	if (!drm_dev_enter(dev, &idx))
352 		goto out_drm_gem_fb_end_cpu_access;
353 
354 	drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);
355 	drm_atomic_for_each_plane_damage(&iter, &damage) {
356 		struct iosys_map dst = sysfb->fb_addr;
357 		struct drm_rect dst_clip = plane_state->dst;
358 
359 		if (!drm_rect_intersect(&dst_clip, &damage))
360 			continue;
361 
362 		iosys_map_incr(&dst, drm_fb_clip_offset(dst_pitch, dst_format, &dst_clip));
363 		blit_to_crtc(&dst, &dst_pitch, shadow_plane_state->data, fb, &damage,
364 			     &shadow_plane_state->fmtcnv_state);
365 	}
366 
367 	drm_dev_exit(idx);
368 out_drm_gem_fb_end_cpu_access:
369 	drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
370 }
371 EXPORT_SYMBOL(drm_sysfb_plane_helper_atomic_update);
372 
373 void drm_sysfb_plane_helper_atomic_disable(struct drm_plane *plane,
374 					   struct drm_atomic_commit *state)
375 {
376 	struct drm_device *dev = plane->dev;
377 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
378 	unsigned int dst_pitch = sysfb->fb_pitch;
379 	const struct drm_format_info *dst_format = sysfb->fb_format;
380 	struct drm_rect dst_clip;
381 	unsigned long lines, linepixels, dst_size, i;
382 	int idx;
383 
384 	drm_rect_init(&dst_clip, 0, 0,
385 		      sysfb->fb_mode.hdisplay, sysfb->fb_mode.vdisplay);
386 
387 	lines = drm_rect_height(&dst_clip);
388 	linepixels = drm_rect_width(&dst_clip);
389 	dst_size = min_t(unsigned long,
390 			 drm_format_info_min_pitch(dst_format, 0, linepixels),
391 			 dst_pitch);
392 
393 	if (!drm_dev_enter(dev, &idx))
394 		return;
395 
396 	/* Clear buffer to black if disabled */
397 	for (i = 0; i < lines; ++i)
398 		iosys_map_memset(&sysfb->fb_addr, dst_pitch * i, 0, dst_size);
399 
400 	drm_dev_exit(idx);
401 }
402 EXPORT_SYMBOL(drm_sysfb_plane_helper_atomic_disable);
403 
404 int drm_sysfb_plane_helper_get_scanout_buffer(struct drm_plane *plane,
405 					      struct drm_scanout_buffer *sb)
406 {
407 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(plane->dev);
408 
409 	sb->width = sysfb->fb_mode.hdisplay;
410 	sb->height = sysfb->fb_mode.vdisplay;
411 	sb->format = sysfb->fb_format;
412 	sb->pitch[0] = sysfb->fb_pitch;
413 	sb->map[0] = sysfb->fb_addr;
414 
415 	return 0;
416 }
417 EXPORT_SYMBOL(drm_sysfb_plane_helper_get_scanout_buffer);
418 
419 /**
420  * drm_sysfb_plane_atomic_create_state - creates sysfb plane state
421  * @plane: the plane
422  *
423  * This function implements struct &drm_plane_funcs.atomic_create_state for
424  * sysfb planes. It allocates the plane state of type
425  * struct drm_sysfb_plane_state.
426  *
427  * Returns:
428  * A pointer to a new plane state on success, or an ERR_PTR()-encoded
429  * error code otherwise.
430  */
431 struct drm_plane_state *
432 drm_sysfb_plane_atomic_create_state(struct drm_plane *plane)
433 {
434 	struct drm_sysfb_plane_state *sysfb_plane_state;
435 
436 	sysfb_plane_state = kzalloc_obj(*sysfb_plane_state);
437 	if (!sysfb_plane_state)
438 		return ERR_PTR(-ENOMEM);
439 
440 	__drm_gem_shadow_plane_state_init(plane, &sysfb_plane_state->base);
441 
442 	return &sysfb_plane_state->base.base;
443 }
444 EXPORT_SYMBOL(drm_sysfb_plane_atomic_create_state);
445 
446 struct drm_plane_state *drm_sysfb_plane_atomic_duplicate_state(struct drm_plane *plane)
447 {
448 	struct drm_device *dev = plane->dev;
449 	struct drm_plane_state *plane_state = plane->state;
450 	struct drm_sysfb_plane_state *sysfb_plane_state;
451 	struct drm_sysfb_plane_state *new_sysfb_plane_state;
452 	struct drm_shadow_plane_state *new_shadow_plane_state;
453 
454 	if (drm_WARN_ON(dev, !plane_state))
455 		return NULL;
456 	sysfb_plane_state = to_drm_sysfb_plane_state(plane_state);
457 
458 	new_sysfb_plane_state = kzalloc_obj(*new_sysfb_plane_state);
459 	if (!new_sysfb_plane_state)
460 		return NULL;
461 	new_shadow_plane_state = &new_sysfb_plane_state->base;
462 
463 	__drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state);
464 	new_sysfb_plane_state->blit_to_crtc = sysfb_plane_state->blit_to_crtc;
465 
466 	return &new_shadow_plane_state->base;
467 }
468 EXPORT_SYMBOL(drm_sysfb_plane_atomic_duplicate_state);
469 
470 void drm_sysfb_plane_atomic_destroy_state(struct drm_plane *plane,
471 					  struct drm_plane_state *plane_state)
472 {
473 	drm_sysfb_plane_state_destroy(to_drm_sysfb_plane_state(plane_state));
474 }
475 EXPORT_SYMBOL(drm_sysfb_plane_atomic_destroy_state);
476 
477 /*
478  * CRTC
479  */
480 
481 static void drm_sysfb_crtc_state_destroy(struct drm_sysfb_crtc_state *sysfb_crtc_state)
482 {
483 	__drm_atomic_helper_crtc_destroy_state(&sysfb_crtc_state->base);
484 
485 	kfree(sysfb_crtc_state);
486 }
487 
488 enum drm_mode_status drm_sysfb_crtc_helper_mode_valid(struct drm_crtc *crtc,
489 						      const struct drm_display_mode *mode)
490 {
491 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(crtc->dev);
492 
493 	return drm_crtc_helper_mode_valid_fixed(crtc, mode, &sysfb->fb_mode);
494 }
495 EXPORT_SYMBOL(drm_sysfb_crtc_helper_mode_valid);
496 
497 int drm_sysfb_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *new_state)
498 {
499 	struct drm_device *dev = crtc->dev;
500 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
501 	struct drm_crtc_state *new_crtc_state = drm_atomic_get_new_crtc_state(new_state, crtc);
502 	int ret;
503 
504 	if (!new_crtc_state->enable)
505 		return 0;
506 
507 	ret = drm_atomic_helper_check_crtc_primary_plane(new_crtc_state);
508 	if (ret)
509 		return ret;
510 
511 	if (new_crtc_state->color_mgmt_changed) {
512 		const size_t gamma_lut_length =
513 			sysfb->fb_gamma_lut_size * sizeof(struct drm_color_lut);
514 		const struct drm_property_blob *gamma_lut = new_crtc_state->gamma_lut;
515 
516 		if (gamma_lut && (gamma_lut->length != gamma_lut_length)) {
517 			drm_dbg(dev, "Incorrect gamma_lut length %zu\n", gamma_lut->length);
518 			return -EINVAL;
519 		}
520 	}
521 
522 	return 0;
523 }
524 EXPORT_SYMBOL(drm_sysfb_crtc_helper_atomic_check);
525 
526 struct drm_crtc_state *drm_sysfb_crtc_create_state(struct drm_crtc *crtc)
527 {
528 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(crtc->dev);
529 	struct drm_sysfb_crtc_state *sysfb_crtc_state;
530 
531 	sysfb_crtc_state = kzalloc_obj(*sysfb_crtc_state);
532 	if (!sysfb_crtc_state)
533 		return ERR_PTR(-ENOMEM);
534 
535 	sysfb_crtc_state->format = sysfb->fb_format;
536 	__drm_atomic_helper_crtc_state_init(&sysfb_crtc_state->base, crtc);
537 
538 	return &sysfb_crtc_state->base;
539 }
540 EXPORT_SYMBOL(drm_sysfb_crtc_create_state);
541 
542 struct drm_crtc_state *drm_sysfb_crtc_atomic_duplicate_state(struct drm_crtc *crtc)
543 {
544 	struct drm_device *dev = crtc->dev;
545 	struct drm_crtc_state *crtc_state = crtc->state;
546 	struct drm_sysfb_crtc_state *new_sysfb_crtc_state;
547 	struct drm_sysfb_crtc_state *sysfb_crtc_state;
548 
549 	if (drm_WARN_ON(dev, !crtc_state))
550 		return NULL;
551 
552 	new_sysfb_crtc_state = kzalloc_obj(*new_sysfb_crtc_state);
553 	if (!new_sysfb_crtc_state)
554 		return NULL;
555 
556 	sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state);
557 
558 	__drm_atomic_helper_crtc_duplicate_state(crtc, &new_sysfb_crtc_state->base);
559 	new_sysfb_crtc_state->format = sysfb_crtc_state->format;
560 
561 	return &new_sysfb_crtc_state->base;
562 }
563 EXPORT_SYMBOL(drm_sysfb_crtc_atomic_duplicate_state);
564 
565 void drm_sysfb_crtc_atomic_destroy_state(struct drm_crtc *crtc, struct drm_crtc_state *crtc_state)
566 {
567 	drm_sysfb_crtc_state_destroy(to_drm_sysfb_crtc_state(crtc_state));
568 }
569 EXPORT_SYMBOL(drm_sysfb_crtc_atomic_destroy_state);
570 
571 /*
572  * Connector
573  */
574 
575 static int drm_sysfb_get_edid_block(void *data, u8 *buf, unsigned int block, size_t len)
576 {
577 	struct drm_sysfb_device *sysfb = data;
578 	const u8 *edid = sysfb->edid;
579 	size_t off = block * EDID_LENGTH;
580 	size_t end = off + len;
581 
582 	if (!edid)
583 		return -EINVAL;
584 	if (end > EDID_LENGTH)
585 		return -EINVAL;
586 	memcpy(buf, &edid[off], len);
587 
588 	/*
589 	 * We don't have EDID extensions available and reporting them
590 	 * will upset DRM helpers. Thus clear the extension field and
591 	 * update the checksum. Adding the extension flag to the checksum
592 	 * does this.
593 	 */
594 	buf[127] += buf[126];
595 	buf[126] = 0;
596 
597 	return 0;
598 }
599 
600 int drm_sysfb_connector_helper_get_modes(struct drm_connector *connector)
601 {
602 	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(connector->dev);
603 	const struct drm_edid *drm_edid;
604 
605 	if (sysfb->edid) {
606 		drm_edid = drm_edid_read_custom(connector, drm_sysfb_get_edid_block, sysfb);
607 		drm_edid_connector_update(connector, drm_edid);
608 		drm_edid_free(drm_edid);
609 	}
610 
611 	/* Return the fixed mode even with EDID */
612 	return drm_connector_helper_get_modes_fixed(connector, &sysfb->fb_mode);
613 }
614 EXPORT_SYMBOL(drm_sysfb_connector_helper_get_modes);
615