diff --git a/drivers/gpu/drm/fbdevdrm/Makefile b/drivers/gpu/drm/fbdevdrm/Makefile
index 2ca906a3258b..5507152d8187 100644
--- a/drivers/gpu/drm/fbdevdrm/Makefile
+++ b/drivers/gpu/drm/fbdevdrm/Makefile
@@ -5,6 +5,7 @@ fbdevdrm-y := fbdevdrm_bo.o \
 	      fbdevdrm_format.o \
 	      fbdevdrm_modes.o \
 	      fbdevdrm_modeset.o \
+	      fbdevdrm_primary.o \
 	      fbdevdrm_ttm.o
 
 obj-$(CONFIG_DRM_FBDEVDRM) += fbdevdrm.o
diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c
index bd3ad691e7ce..8dea7ef369dc 100644
--- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c
+++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.c
@@ -11,8 +11,12 @@
  */
 
 #include "fbdevdrm_modes.h"
+#include <drm/drm.h>
+#include <linux/sched.h> /* for TASK_COMM_LEN in <drm/drm_framebuffer.h> */
+#include <drm/drm_framebuffer.h>
 #include <drm/drm_modes.h>
 #include <linux/fb.h>
+#include "fbdevdrm_format.h"
 
 void drm_mode_update_from_fb_videomode(struct drm_display_mode *mode,
 				       const struct fb_videomode *fb_mode)
@@ -151,3 +155,41 @@ fbdevdrm_init_fb_var_screeninfo_from_mode(struct fb_var_screeninfo *fb_var,
 	memset(fb_var, 0, sizeof(*fb_var));
 	fbdevdrm_update_fb_var_screeninfo_from_mode(fb_var, mode);
 }
+
+int fbdevdrm_update_fb_var_screeninfo_from_framebuffer(
+	struct fb_var_screeninfo *fb_var, struct drm_framebuffer *fb,
+	size_t vram_size)
+{
+	unsigned int width, pitch;
+	uint64_t cpp, lines;
+	int ret;
+
+	/* Our virtual screen covers all the graphics memory (sans some
+	 * trailing bytes). This allows for setting the scanout buffer's
+	 * address with fb_pan_display().
+	 */
+
+	width = fb->pitches[0];
+	cpp = drm_format_plane_cpp(fb->format[0].format, 0);
+	do_div(width, cpp);
+
+	if (width > (__u32)-1)
+		return -EINVAL; /* would overflow fb_var->xres_virtual */
+
+	pitch = fb->pitches[0];
+	lines = vram_size;
+	do_div(lines, pitch);
+
+	if (lines > (__u32)-1)
+		return -EINVAL; /* would overflow fb_var->yres_virtual */
+
+	fb_var->xres_virtual = width;
+	fb_var->yres_virtual = lines;
+
+	ret = fbdevdrm_update_fb_var_screeninfo_from_format(
+		fb_var, fb->format[0].format);
+	if (ret)
+		return ret;
+
+	return 0;
+}
diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h
index f88a86a83858..925eea78e3f0 100644
--- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h
+++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modes.h
@@ -13,8 +13,11 @@
 #ifndef FBDEVDRM_MODES_H
 #define FBDEVDRM_MODES_H
 
+#include <linux/types.h>
+
 struct drm_device;
 struct drm_display_mode;
+struct drm_framebuffer;
 struct fb_videomode;
 struct fb_var_screeninfo;
 
@@ -43,4 +46,8 @@ void
 fbdevdrm_init_fb_var_screeninfo_from_mode(struct fb_var_screeninfo *var,
 					  const struct drm_display_mode *mode);
 
+int fbdevdrm_update_fb_var_screeninfo_from_framebuffer(
+	struct fb_var_screeninfo *fb_var, struct drm_framebuffer *fb,
+	size_t vram_size);
+
 #endif
diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c
index 585f3478f190..3473b85acbf1 100644
--- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c
+++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.c
@@ -20,6 +20,7 @@
 #include <drm/drm_modeset_helper_vtables.h>
 #include <drm/drm_probe_helper.h>
 #include <linux/fb.h>
+#include "fbdevdrm_primary.h"
 
 /*
  * CRTC
@@ -376,7 +377,13 @@ int fbdevdrm_modeset_init(struct fbdevdrm_modeset *modeset,
 	 * connect them with each other.
 	 */
 
-	ret = drm_crtc_init_with_planes(dev, &modeset->crtc, NULL, NULL,
+	ret = fbdevdrm_init_primary_plane_from_fb_info(
+		&modeset->primary_plane, dev, 0, fb_info);
+	if (ret)
+		goto err_drm_mode_config_cleanup;
+
+	ret = drm_crtc_init_with_planes(dev, &modeset->crtc,
+					&modeset->primary_plane, NULL,
 					&fbdevdrm_crtc_funcs, NULL);
 	if (ret)
 		goto err_drm_mode_config_cleanup;
diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.h
index 21e87caa8196..ec753014aba1 100644
--- a/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.h
+++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_modeset.h
@@ -16,11 +16,13 @@
 #include <drm/drm_connector.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_encoder.h>
+#include <drm/drm_plane.h>
 
 struct drm_device;
 struct fb_info;
 
 struct fbdevdrm_modeset {
+	struct drm_plane primary_plane;
 	struct drm_crtc crtc;
 	struct drm_encoder encoder;
 	struct drm_connector connector;
diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_primary.c b/drivers/gpu/drm/fbdevdrm/fbdevdrm_primary.c
new file mode 100644
index 000000000000..8ba8e6bd1c14
--- /dev/null
+++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_primary.c
@@ -0,0 +1,498 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * One purpose of this driver is to allow for easy conversion of framebuffer
+ * drivers to DRM. As a special exception to the GNU GPL, you are allowed to
+ * relicense this file under the terms of a license of your choice if you're
+ * porting a framebuffer driver. In order to do so, update the SPDX license
+ * identifier to the new license and remove this exception.
+ *
+ * If you add code to this file, please ensure that it's compatible with the
+ * stated exception.
+ */
+
+#include "fbdevdrm_primary.h"
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_fourcc.h>
+#include <drm/drm_plane.h>
+#include <linux/fb.h>
+#include "fbdevdrm_bo.h"
+#include "fbdevdrm_format.h"
+#include "fbdevdrm_modes.h"
+#include "fbdevdrm_modeset.h"
+
+static struct fbdevdrm_modeset* fbdevdrm_modeset_of_primary_plane(
+	struct drm_plane *primary_plane)
+{
+	return container_of(primary_plane, struct fbdevdrm_modeset,
+			    primary_plane);
+}
+
+/*
+ * Primary plane
+ */
+
+static int primary_plane_helper_prepare_fb(struct drm_plane *plane,
+					   struct drm_plane_state *new_state)
+{
+        struct drm_gem_object *gem;
+        struct fbdevdrm_bo *fbo;
+	int ret;
+
+	if (!new_state->fb)
+		return 0;
+
+	gem = new_state->fb->obj[0];
+	fbo = fbdevdrm_bo_of_gem(gem);
+
+        ret = fbdevdrm_bo_pin(fbo, TTM_PL_FLAG_VRAM);
+        if (ret)
+                return ret;
+
+	return 0;
+}
+
+static void primary_plane_helper_cleanup_fb(struct drm_plane *plane,
+					    struct drm_plane_state *old_state)
+{
+        struct drm_gem_object *gem;
+        struct fbdevdrm_bo *fbo;
+
+	if (!old_state->fb)
+		return;
+
+	gem = old_state->fb->obj[0];
+	fbo = fbdevdrm_bo_of_gem(gem);
+
+	fbdevdrm_bo_unpin(fbo);
+}
+
+static void fbdevdrm_update_fb_var_screeninfo_from_crtc_state(
+	struct fb_var_screeninfo *fb_var, struct drm_crtc_state* crtc_state)
+{
+	fbdevdrm_update_fb_var_screeninfo_from_mode(fb_var, &crtc_state->adjusted_mode);
+}
+
+static int primary_plane_helper_atomic_check(struct drm_plane *plane,
+					     struct drm_plane_state *state)
+{
+	struct drm_crtc_state *new_crtc_state;
+	int ret;
+	struct fbdevdrm_modeset *modeset;
+	struct fb_var_screeninfo fb_var;
+
+	if (!state->crtc)
+		return 0;
+
+	new_crtc_state = drm_atomic_get_new_crtc_state(state->state,
+						       state->crtc);
+	if (!new_crtc_state)
+		return 0;
+
+	ret = drm_atomic_helper_check_plane_state(state, new_crtc_state,
+						  1 << 16, 1 << 16,
+						  false, true);
+	if (ret < 0) {
+		DRM_ERROR("fbdrmdev: %s:%d ret=%d:\n", __func__, __LINE__, ret);
+		return ret;
+	}
+
+	if (!state->visible || !state->fb)
+		return 0;
+
+	/* Virtual screen sizes are not supported.
+	 */
+
+	if (drm_rect_width(&state->dst) != state->fb->width ||
+	    drm_rect_height(&state->dst) != state->fb->height) {
+		DRM_ERROR("fbdevdrm: %s:%d: virtual screen sizes not supported\n", __func__, __LINE__);
+		return -EINVAL;
+	}
+	if (state->dst.x1 || state->dst.y1) {
+		DRM_ERROR("fbdevdrm: %s:%d: virtual screen offset not supported\n", __func__, __LINE__);
+		return -EINVAL;
+	}
+
+	/* Pixel formats have to be compatible with fbdev. This is
+	 * usually some variation of XRGB.
+	 */
+
+	if (!plane->state ||
+	    !plane->state->fb ||
+	    plane->state->fb->format[0].format != state->fb->format[0].format) {
+
+		modeset = fbdevdrm_modeset_of_primary_plane(plane);
+
+		if (modeset->fb_info->fbops->fb_check_var) {
+			memcpy(&fb_var, &modeset->fb_info->var,
+			       sizeof(fb_var));
+			fbdevdrm_update_fb_var_screeninfo_from_crtc_state(
+				&fb_var, new_crtc_state);
+			fbdevdrm_update_fb_var_screeninfo_from_framebuffer(
+				&fb_var, state->fb,
+				modeset->fb_info->fix.smem_len);
+			ret = modeset->fb_info->fbops->fb_check_var(
+				&fb_var, modeset->fb_info);
+			if (ret < 0)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
+static int set_palette_cmap(struct fb_info* fb_info)
+{
+	__u32 len;
+	const struct fb_cmap* default_cmap;
+	struct fb_cmap cmap;
+	int ret;
+	const __u32 gamma_len[3] = {
+		fb_info->var.red.length,
+		fb_info->var.green.length,
+		fb_info->var.blue.length
+	};
+
+	len = max3(gamma_len[0], gamma_len[1], gamma_len[2]);
+	if (!len || (len > 31)) {
+		DRM_ERROR("fbdevdrm: gamma LUT has invalid bit count"
+			  " of %u\n", (unsigned int)len);
+		return -EINVAL;
+	}
+
+	default_cmap = fb_default_cmap(1ul << len);
+	if (!default_cmap)
+		return -EINVAL;
+
+	memset(&cmap, 0, sizeof(cmap));
+	ret = fb_alloc_cmap(&cmap, default_cmap->len, 0);
+	if (ret)
+		return ret;
+	ret = fb_copy_cmap(default_cmap, &cmap);
+	if (ret)
+		goto err_fb_dealloc_cmap;
+	ret = fb_set_cmap(&cmap, fb_info);
+	if (ret)
+		return ret;
+	fb_dealloc_cmap(&cmap);
+
+	return 0;
+
+err_fb_dealloc_cmap:
+	fb_dealloc_cmap(&cmap);
+	return ret;
+}
+
+static int set_linear_cmap(struct fb_info* fb_info)
+{
+	struct fb_cmap cmap;
+	int ret;
+	size_t i;
+	unsigned int j;
+	u16 *lut;
+	u16 incr;
+	u16 *gamma_lut[3];
+	__u32 len;
+	const __u32 gamma_len[3] = {
+		fb_info->var.red.length,
+		fb_info->var.green.length,
+		fb_info->var.blue.length
+	};
+
+	len = max3(gamma_len[0], gamma_len[1], gamma_len[2]);
+	if (!len || (len > 8)) {
+		DRM_ERROR("fbdevdrm: gamma LUT has invalid bit count"
+			  " of %u\n", (unsigned int)len);
+		return -EINVAL;
+	}
+
+	memset(&cmap, 0, sizeof(cmap));
+	ret = fb_alloc_cmap(&cmap, 1ul << len, 0);
+	if (ret)
+		return ret;
+
+	gamma_lut[0] = cmap.red;
+	gamma_lut[1] = cmap.green;
+	gamma_lut[2] = cmap.blue;
+
+	for (i = 0; i < ARRAY_SIZE(gamma_lut); ++i) {
+		lut = gamma_lut[i];
+		len = 1ul << gamma_len[i];
+		incr = 0x10000u >> gamma_len[i];
+		for (j = 0; j < len; ++j, ++lut) {
+			*lut = incr * j;
+		}
+		/* In order to have no intensity at index 0 and full
+		 * intensity at the final index of the LUT, we fix-up the
+		 * table's final entries. The fix-up makes intensity grow
+		 * faster near the final entries of the gamma LUT. The human
+		 * eye is more sensitive to changes to the lower intensities,
+		 * so this is probably not directly perceivable.
+		 */
+		for (lut -= gamma_len[i], j = gamma_len[i]; j > 0; ++lut) {
+			--j;
+			*lut += (incr >> j) - 1; /* subtract 1 to not
+						  * overflow the LUT's
+						  * final entry */
+		}
+	}
+
+	ret = fb_set_cmap(&cmap, fb_info);
+	if (ret)
+		goto err_fb_dealloc_cmap;
+	fb_dealloc_cmap(&cmap);
+
+	return 0;
+
+err_fb_dealloc_cmap:
+	fb_dealloc_cmap(&cmap);
+	return -EINVAL;
+}
+
+static int set_cmap(struct fb_info *fb_info)
+{
+	int ret = 0;
+
+	switch (fb_info->fix.visual) {
+	case FB_VISUAL_PSEUDOCOLOR:
+		ret = set_palette_cmap(fb_info);
+		break;
+	case FB_VISUAL_DIRECTCOLOR:
+		ret = set_linear_cmap(fb_info);
+		break;
+	default:
+		break;
+	}
+
+	return ret;
+}
+
+static void primary_plane_helper_atomic_update(
+	struct drm_plane *plane, struct drm_plane_state *old_state)
+{
+	struct fbdevdrm_modeset *modeset;
+	uint32_t format;
+	struct fb_var_screeninfo fb_var;
+	int ret;
+        struct drm_gem_object *gem;
+        struct fbdevdrm_bo *fbo;
+	__u32 line_length;
+	uint64_t yoffset;
+	uint32_t xoffset;
+
+	modeset = fbdevdrm_modeset_of_primary_plane(plane);
+
+	format = fbdevdrm_format_of_fb_info(modeset->fb_info);
+
+	/* DRM porting notes: Some fbdev drivers report alpha channels for
+	 * their framebuffer, even though they don't support transparent
+	 * primary planes. For the format test below, we ignore the alpha
+	 * channel and use the non-transparent equivalent of the pixel format.
+	 * If you're porting an fbdev driver to DRM, remove this switch
+	 * statement and report the correct format instead.
+	 */
+	switch (format) {
+	case DRM_FORMAT_ARGB8888:
+		format = DRM_FORMAT_XRGB8888;
+		break;
+	case DRM_FORMAT_ABGR8888:
+		format = DRM_FORMAT_XBGR8888;
+		break;
+	case DRM_FORMAT_RGBA8888:
+		format = DRM_FORMAT_RGBX8888;
+		break;
+	case DRM_FORMAT_BGRA8888:
+		format = DRM_FORMAT_BGRX8888;
+		break;
+	default:
+		break;
+	}
+
+	if ((format != plane->state->fb->format[0].format) ||
+	    (modeset->fb_info->var.xres_virtual != plane->state->fb->width)) {
+
+		/* Pixel format changed, update fb_info accordingly
+		 */
+
+		memcpy(&fb_var, &modeset->fb_info->var, sizeof(fb_var));
+		ret = fbdevdrm_update_fb_var_screeninfo_from_framebuffer(
+			&fb_var, plane->state->fb,
+			modeset->fb_info->fix.smem_len);
+		if (ret)
+			return;
+
+		fb_var.activate = FB_ACTIVATE_NOW;
+
+		ret = fb_set_var(modeset->fb_info, &fb_var);
+		if (ret) {
+			DRM_ERROR("fbdevdrm: fb_set_var() failed: %d\n", ret);
+			return;
+		}
+	}
+
+	if (!old_state->fb || /* first-time update */
+	    (format != plane->state->fb->format[0].format)) {
+
+		/* DRM porting notes: Below we set the LUTs for palette and
+		 * gamma correction. This is required by some fbdev drivers,
+		 * such as nvidiafb and atyfb, which don't initialize the
+		 * table to pass-through the framebuffer values unchanged. This
+		 * is actually CRTC state, but the respective function
+		 * crtc_helper_mode_set_nofb() is only called when a CRTC
+		 * property changes, changes in color formats are not handled
+		 * there. When you're porting a fbdev driver to DRM, remove
+		 * the call. Gamma LUTs are CRTC properties and should be
+		 * handled there. Either remove gamma correction or set up
+		 * the respective CRTC properties for userspace.
+		 */
+		set_cmap(modeset->fb_info);
+	}
+
+	/* With the fb interface, we cannot directly program
+	 * the scanout buffer's address. Instead we use the
+	 * panning function to point the graphics card to the
+	 * buffer's location.
+	 */
+
+	gem = plane->state->fb->obj[0];
+	fbo = fbdevdrm_bo_of_gem(gem);
+
+	line_length = plane->state->fb->pitches[0];
+	yoffset = fbo->bo.offset;
+	xoffset = do_div(yoffset, line_length);
+	if (yoffset > (__u32)-1) {
+		/* The value of yoffset doesn't fit into a 32-bit value,
+		 * so we cannot use it for display panning. Either the
+		 * graphics card has GiBs of VRAM or this is a bug with
+		 * memory management. */
+		DRM_ERROR("fbdevdrm: buffer object is not aligned to a "
+			  "multiple of the scanline size.\n");
+		return;
+	} else if (xoffset) {
+		/* The buffer starts in the middle of a scanline. The
+		 * memory manager should have prevented this. This
+		 * problem indicates a bug with the buffer aligning. */
+		DRM_ERROR("fbdevdrm: buffer object is not aligned to a "
+			  "multiple of the scanline size.\n");
+		return;
+	}
+
+	memcpy(&fb_var, &modeset->fb_info->var, sizeof(fb_var));
+	fb_var.xoffset = xoffset;
+	fb_var.yoffset = yoffset;
+
+	ret = fb_pan_display(modeset->fb_info, &fb_var);
+	if (ret) {
+		DRM_ERROR("fbdevdrm: fb_pan_display() failed: %d\n", ret);
+		return;
+	}
+}
+
+static void primary_plane_helper_atomic_disable(
+	struct drm_plane *plane, struct drm_plane_state *old_state)
+{ }
+
+static int primary_plane_helper_atomic_async_check(
+	struct drm_plane *plane, struct drm_plane_state *state)
+{
+	return 0;
+}
+
+static void primary_plane_helper_atomic_async_update(
+	struct drm_plane *plane, struct drm_plane_state *new_state)
+{
+	drm_plane_cleanup(plane);
+}
+
+static const struct drm_plane_helper_funcs primary_plane_helper_funcs = {
+	.prepare_fb = primary_plane_helper_prepare_fb,
+	.cleanup_fb = primary_plane_helper_cleanup_fb,
+	.atomic_check = primary_plane_helper_atomic_check,
+	.atomic_update = primary_plane_helper_atomic_update,
+	.atomic_disable = primary_plane_helper_atomic_disable,
+	.atomic_async_check = primary_plane_helper_atomic_async_check,
+	.atomic_async_update = primary_plane_helper_atomic_async_update
+};
+
+static void primary_plane_destroy(struct drm_plane *plane)
+{
+	drm_plane_cleanup(plane);
+}
+
+static const struct drm_plane_funcs primary_plane_funcs = {
+	.update_plane = drm_atomic_helper_update_plane,
+	.disable_plane = drm_atomic_helper_disable_plane,
+	.destroy = primary_plane_destroy,
+	.reset = drm_atomic_helper_plane_reset,
+	.set_property = NULL, /* unused */
+	.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
+	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
+	.atomic_set_property = NULL, /* unused */
+	.atomic_get_property = NULL, /* unused */
+	.late_register = NULL, /* unused */
+	.early_unregister = NULL, /* unused */
+	.atomic_print_state = NULL, /* unused */
+	.format_mod_supported = NULL /* unused */
+};
+
+static const uint32_t*
+formats_from_fb_info(const struct fb_info* fb_info, unsigned int* format_count)
+{
+	/* TODO: Detect the actually supported formats or have some
+	 *       sort of whitelist for known hardware devices.
+	 */
+	static const uint32_t formats[] = {
+		DRM_FORMAT_XRGB8888,
+		DRM_FORMAT_RGB565
+	};
+
+	*format_count = ARRAY_SIZE(formats);
+
+	return formats;
+}
+
+int fbdevdrm_init_primary_plane_from_fb_info(struct drm_plane *plane,
+					     struct drm_device *dev,
+					     uint32_t possible_crtcs,
+					     struct fb_info *fb_info)
+{
+	uint32_t cur_format;
+	const uint32_t* format;
+	unsigned int format_count;
+	int ret;
+
+	/* We first try to find the supported pixel formats from the
+	 * fb_info's hardware settings. If that fails, we take the
+	 * current settings. */
+	format = formats_from_fb_info(fb_info, &format_count);
+	if (!format_count) {
+		cur_format = fbdevdrm_format_of_fb_info(fb_info);
+		format = &cur_format;
+		format_count = 1;
+	}
+	if (!format_count)
+		return -ENODEV;
+
+	ret = drm_universal_plane_init(dev, plane, possible_crtcs,
+				       &primary_plane_funcs,
+				       format, format_count,
+				       NULL, DRM_PLANE_TYPE_PRIMARY, NULL);
+	if (ret < 0)
+		return ret;
+	drm_plane_helper_add(plane, &primary_plane_helper_funcs);
+
+	ret = drm_plane_create_rotation_property(plane, DRM_MODE_ROTATE_0,
+						 DRM_MODE_ROTATE_0);
+	if (ret < 0)
+		goto err_drm_plane_cleanup;
+
+	ret = drm_plane_create_zpos_immutable_property(plane, 0);
+	if (ret < 0)
+		goto err_drm_plane_cleanup;
+
+	return 0;
+
+err_drm_plane_cleanup:
+	drm_plane_cleanup(plane);
+	return ret;
+}
diff --git a/drivers/gpu/drm/fbdevdrm/fbdevdrm_primary.h b/drivers/gpu/drm/fbdevdrm/fbdevdrm_primary.h
new file mode 100644
index 000000000000..529c272c6e0b
--- /dev/null
+++ b/drivers/gpu/drm/fbdevdrm/fbdevdrm_primary.h
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * One purpose of this driver is to allow for easy conversion of framebuffer
+ * drivers to DRM. As a special exception to the GNU GPL, you are allowed to
+ * relicense this file under the terms of a license of your choice if you're
+ * porting a framebuffer driver. In order to do so, update the SPDX license
+ * identifier to the new license and remove this exception.
+ *
+ * If you add code to this file, please ensure that it's compatible with the
+ * stated exception.
+ */
+
+#ifndef FBDEVDRM_PRIMARY_H
+#define FBDEVDRM_PRIMARY_H
+
+#include <linux/types.h>
+
+struct drm_device;
+struct drm_plane;
+struct fb_info;
+
+int fbdevdrm_init_primary_plane_from_fb_info(struct drm_plane *plane,
+					     struct drm_device *dev,
+					     uint32_t possible_crtcs,
+					     struct fb_info *fb_info);
+
+#endif
