#include <drm/drm_device.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_panel.h>
 #include <drm/drm_simple_kms_helper.h>
 #include <drm/drm_vblank.h>
        .enable         = aspeed_gfx_pipe_enable,
        .disable        = aspeed_gfx_pipe_disable,
        .update         = aspeed_gfx_pipe_update,
-       .prepare_fb     = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb     = drm_gem_simple_display_pipe_prepare_fb,
        .enable_vblank  = aspeed_gfx_enable_vblank,
        .disable_vblank = aspeed_gfx_disable_vblank,
 };
 
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <linux/dma-resv.h>
+
 #include <drm/drm_atomic_state_helper.h>
+#include <drm/drm_atomic_uapi.h>
+#include <drm/drm_gem.h>
 #include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_simple_kms_helper.h>
  *
  * The GEM atomic helpers library implements generic atomic-commit
  * functions for drivers that use GEM objects. Currently, it provides
- * plane state and framebuffer BO mappings for planes with shadow
- * buffers.
+ * synchronization helpers, and plane state and framebuffer BO mappings
+ * for planes with shadow buffers.
+ *
+ * Before scanout, a plane's framebuffer needs to be synchronized with
+ * possible writers that draw into the framebuffer. All drivers should
+ * call drm_gem_plane_helper_prepare_fb() from their implementation of
+ * struct &drm_plane_helper.prepare_fb . It sets the plane's fence from
+ * the framebuffer so that the DRM core can synchronize access automatically.
+ *
+ * drm_gem_plane_helper_prepare_fb() can also be used directly as
+ * implementation of prepare_fb. For drivers based on
+ * struct drm_simple_display_pipe, drm_gem_simple_display_pipe_prepare_fb()
+ * provides equivalent functionality.
+ *
+ * .. code-block:: c
+ *
+ *     #include <drm/drm_gem_atomic_helper.h>
+ *
+ *     struct drm_plane_helper_funcs driver_plane_helper_funcs = {
+ *             ...,
+ *             . prepare_fb = drm_gem_plane_helper_prepare_fb,
+ *     };
+ *
+ *     struct drm_simple_display_pipe_funcs driver_pipe_funcs = {
+ *             ...,
+ *             . prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
+ *     };
  *
  * A driver using a shadow buffer copies the content of the shadow buffers
  * into the HW's framebuffer memory during an atomic update. This requires
  *
  * .. code-block:: c
  *
- *     #include <drm/drm/gem_atomic_helper.h>
+ *     #include <drm/drm_gem_atomic_helper.h>
  *
  *     struct drm_plane_funcs driver_plane_funcs = {
  *             ...,
  *     }
  */
 
+/*
+ * Plane Helpers
+ */
+
+/**
+ * drm_gem_plane_helper_prepare_fb() - Prepare a GEM backed framebuffer
+ * @plane: Plane
+ * @state: Plane state the fence will be attached to
+ *
+ * This function extracts the exclusive fence from &drm_gem_object.resv and
+ * attaches it to plane state for the atomic helper to wait on. This is
+ * necessary to correctly implement implicit synchronization for any buffers
+ * shared as a struct &dma_buf. This function can be used as the
+ * &drm_plane_helper_funcs.prepare_fb callback.
+ *
+ * There is no need for &drm_plane_helper_funcs.cleanup_fb hook for simple
+ * GEM based framebuffer drivers which have their buffers always pinned in
+ * memory.
+ *
+ * See drm_atomic_set_fence_for_plane() for a discussion of implicit and
+ * explicit fencing in atomic modeset updates.
+ */
+int drm_gem_plane_helper_prepare_fb(struct drm_plane *plane, struct drm_plane_state *state)
+{
+       struct drm_gem_object *obj;
+       struct dma_fence *fence;
+
+       if (!state->fb)
+               return 0;
+
+       obj = drm_gem_fb_get_obj(state->fb, 0);
+       fence = dma_resv_get_excl_rcu(obj->resv);
+       drm_atomic_set_fence_for_plane(state, fence);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(drm_gem_plane_helper_prepare_fb);
+
+/**
+ * drm_gem_simple_display_pipe_prepare_fb - prepare_fb helper for &drm_simple_display_pipe
+ * @pipe: Simple display pipe
+ * @plane_state: Plane state
+ *
+ * This function uses drm_gem_plane_helper_prepare_fb() to extract the exclusive fence
+ * from &drm_gem_object.resv and attaches it to plane state for the atomic
+ * helper to wait on. This is necessary to correctly implement implicit
+ * synchronization for any buffers shared as a struct &dma_buf. Drivers can use
+ * this as their &drm_simple_display_pipe_funcs.prepare_fb callback.
+ *
+ * See drm_atomic_set_fence_for_plane() for a discussion of implicit and
+ * explicit fencing in atomic modeset updates.
+ */
+int drm_gem_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe,
+                                          struct drm_plane_state *plane_state)
+{
+       return drm_gem_plane_helper_prepare_fb(&pipe->plane, plane_state);
+}
+EXPORT_SYMBOL(drm_gem_simple_display_pipe_prepare_fb);
+
 /*
  * Shadow-buffered Planes
  */
        if (!fb)
                return 0;
 
-       ret = drm_gem_fb_prepare_fb(plane, plane_state);
+       ret = drm_gem_plane_helper_prepare_fb(plane, plane_state);
        if (ret)
                return ret;
 
 
  * Copyright (C) 2017 Noralf Trønnes
  */
 
-#include <linux/dma-buf.h>
-#include <linux/dma-fence.h>
-#include <linux/dma-resv.h>
 #include <linux/slab.h>
 
-#include <drm/drm_atomic.h>
-#include <drm/drm_atomic_uapi.h>
 #include <drm/drm_damage_helper.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_gem.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_modeset_helper.h>
-#include <drm/drm_simple_kms_helper.h>
 
 #define AFBC_HEADER_SIZE               16
 #define AFBC_TH_LAYOUT_ALIGNMENT       8
        return 0;
 }
 EXPORT_SYMBOL_GPL(drm_gem_fb_afbc_init);
-
-/**
- * drm_gem_fb_prepare_fb() - Prepare a GEM backed framebuffer
- * @plane: Plane
- * @state: Plane state the fence will be attached to
- *
- * This function extracts the exclusive fence from &drm_gem_object.resv and
- * attaches it to plane state for the atomic helper to wait on. This is
- * necessary to correctly implement implicit synchronization for any buffers
- * shared as a struct &dma_buf. This function can be used as the
- * &drm_plane_helper_funcs.prepare_fb callback.
- *
- * There is no need for &drm_plane_helper_funcs.cleanup_fb hook for simple
- * gem based framebuffer drivers which have their buffers always pinned in
- * memory.
- *
- * See drm_atomic_set_fence_for_plane() for a discussion of implicit and
- * explicit fencing in atomic modeset updates.
- */
-int drm_gem_fb_prepare_fb(struct drm_plane *plane,
-                         struct drm_plane_state *state)
-{
-       struct drm_gem_object *obj;
-       struct dma_fence *fence;
-
-       if (!state->fb)
-               return 0;
-
-       obj = drm_gem_fb_get_obj(state->fb, 0);
-       fence = dma_resv_get_excl_rcu(obj->resv);
-       drm_atomic_set_fence_for_plane(state, fence);
-
-       return 0;
-}
-EXPORT_SYMBOL_GPL(drm_gem_fb_prepare_fb);
-
-/**
- * drm_gem_fb_simple_display_pipe_prepare_fb - prepare_fb helper for
- *     &drm_simple_display_pipe
- * @pipe: Simple display pipe
- * @plane_state: Plane state
- *
- * This function uses drm_gem_fb_prepare_fb() to extract the exclusive fence
- * from &drm_gem_object.resv and attaches it to plane state for the atomic
- * helper to wait on. This is necessary to correctly implement implicit
- * synchronization for any buffers shared as a struct &dma_buf. Drivers can use
- * this as their &drm_simple_display_pipe_funcs.prepare_fb callback.
- *
- * See drm_atomic_set_fence_for_plane() for a discussion of implicit and
- * explicit fencing in atomic modeset updates.
- */
-int drm_gem_fb_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe,
-                                             struct drm_plane_state *plane_state)
-{
-       return drm_gem_fb_prepare_fb(&pipe->plane, plane_state);
-}
-EXPORT_SYMBOL(drm_gem_fb_simple_display_pipe_prepare_fb);
 
 #include <drm/drm_drv.h>
 #include <drm/drm_file.h>
 #include <drm/drm_framebuffer.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_ttm_helper.h>
 #include <drm/drm_gem_vram_helper.h>
 #include <drm/drm_managed.h>
                        goto err_drm_gem_vram_unpin;
        }
 
-       ret = drm_gem_fb_prepare_fb(plane, new_state);
+       ret = drm_gem_plane_helper_prepare_fb(plane, new_state);
        if (ret)
                goto err_drm_gem_vram_unpin;
 
 
 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_fb_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
 
 #include "dcss-dev.h"
 }
 
 static const struct drm_plane_helper_funcs dcss_plane_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = dcss_plane_atomic_check,
        .atomic_update = dcss_plane_atomic_update,
        .atomic_disable = dcss_plane_atomic_disable,
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_plane_helper.h>
 
 }
 
 static const struct drm_plane_helper_funcs ipu_plane_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = ipu_plane_atomic_check,
        .atomic_disable = ipu_plane_atomic_disable,
        .atomic_update = ipu_plane_atomic_update,
 
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_irq.h>
 #include <drm/drm_managed.h>
        .atomic_update          = ingenic_drm_plane_atomic_update,
        .atomic_check           = ingenic_drm_plane_atomic_check,
        .atomic_disable         = ingenic_drm_plane_atomic_disable,
-       .prepare_fb             = drm_gem_fb_prepare_fb,
+       .prepare_fb             = drm_gem_plane_helper_prepare_fb,
 };
 
 static const struct drm_crtc_helper_funcs ingenic_drm_crtc_helper_funcs = {
 
 #include <drm/drm_drv.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_plane.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_property.h>
        .atomic_update          = ingenic_ipu_plane_atomic_update,
        .atomic_check           = ingenic_ipu_plane_atomic_check,
        .atomic_disable         = ingenic_ipu_plane_atomic_disable,
-       .prepare_fb             = drm_gem_fb_prepare_fb,
+       .prepare_fb             = drm_gem_plane_helper_prepare_fb,
 };
 
 static int
 
 #include <drm/drm_device.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_mipi_dsi.h>
 #include <drm/drm_simple_kms_helper.h>
 #include <drm/drm_bridge.h>
        .update = mcde_display_update,
        .enable_vblank = mcde_display_enable_vblank,
        .disable_vblank = mcde_display_disable_vblank,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 int mcde_display_init(struct drm_device *drm)
 
 
 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
-#include <drm/drm_fourcc.h>
 #include <drm/drm_atomic_uapi.h>
+#include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_plane_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 
 #include "mtk_drm_crtc.h"
 #include "mtk_drm_ddp_comp.h"
 }
 
 static const struct drm_plane_helper_funcs mtk_plane_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = mtk_plane_atomic_check,
        .atomic_update = mtk_plane_atomic_update,
        .atomic_disable = mtk_plane_atomic_disable,
 
 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_device.h>
+#include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
-#include <drm/drm_plane_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_fb_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_plane_helper.h>
 
 #include "meson_overlay.h"
 #include "meson_registers.h"
        .atomic_check   = meson_overlay_atomic_check,
        .atomic_disable = meson_overlay_atomic_disable,
        .atomic_update  = meson_overlay_atomic_update,
-       .prepare_fb     = drm_gem_fb_prepare_fb,
+       .prepare_fb     = drm_gem_plane_helper_prepare_fb,
 };
 
 static bool meson_overlay_format_mod_supported(struct drm_plane *plane,
 
 #include <drm/drm_device.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_plane_helper.h>
 
 #include "meson_plane.h"
        .atomic_check   = meson_plane_atomic_check,
        .atomic_disable = meson_plane_atomic_disable,
        .atomic_update  = meson_plane_atomic_update,
-       .prepare_fb     = drm_gem_fb_prepare_fb,
+       .prepare_fb     = drm_gem_plane_helper_prepare_fb,
 };
 
 static bool meson_plane_format_mod_supported(struct drm_plane *plane,
 
 #include <drm/drm_atomic_uapi.h>
 #include <drm/drm_damage_helper.h>
 #include <drm/drm_file.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 
 #include "msm_drv.h"
 #include "dpu_kms.h"
         *       we can use msm_atomic_prepare_fb() instead of doing the
         *       implicit fence and fb prepare by hand here.
         */
-       drm_gem_fb_prepare_fb(plane, new_state);
+       drm_gem_plane_helper_prepare_fb(plane, new_state);
 
        if (pstate->aspace) {
                ret = msm_framebuffer_prepare(new_state->fb,
 
  */
 
 #include <drm/drm_atomic_uapi.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_vblank.h>
 
 #include "msm_atomic_trace.h"
        if (!new_state->fb)
                return 0;
 
-       drm_gem_fb_prepare_fb(plane, new_state);
+       drm_gem_plane_helper_prepare_fb(plane, new_state);
 
        return msm_framebuffer_prepare(new_state->fb, kms->aspace);
 }
 
 #include <drm/drm_encoder.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_plane.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_vblank.h>
 }
 
 static const struct drm_plane_helper_funcs mxsfb_plane_primary_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = mxsfb_plane_atomic_check,
        .atomic_update = mxsfb_plane_primary_atomic_update,
 };
 
 static const struct drm_plane_helper_funcs mxsfb_plane_overlay_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = mxsfb_plane_atomic_check,
        .atomic_update = mxsfb_plane_overlay_atomic_update,
 };
 
 
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_vblank.h>
 
 #include "pl111_drm.h"
        .enable = pl111_display_enable,
        .disable = pl111_display_disable,
        .update = pl111_display_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static int pl111_clk_div_choose_div(struct clk_hw *hw, unsigned long rate,
 
 #include <drm/drm_crtc.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_vblank.h>
        if (ret < 0)
                return ret;
 
-       return drm_gem_fb_prepare_fb(plane, state);
+       return drm_gem_plane_helper_prepare_fb(plane, state);
 }
 
 void rcar_du_vsp_unmap_fb(struct rcar_du_vsp *vsp, struct drm_framebuffer *fb,
 
 #include <drm/drm_crtc.h>
 #include <drm/drm_flip_work.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_probe_helper.h>
        .atomic_disable = vop_plane_atomic_disable,
        .atomic_async_check = vop_plane_atomic_async_check,
        .atomic_async_update = vop_plane_atomic_async_update,
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
 };
 
 static const struct drm_plane_funcs vop_plane_funcs = {
 
 #include <drm/drm_device.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_of.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_probe_helper.h>
 };
 
 static const struct drm_plane_helper_funcs ltdc_plane_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = ltdc_plane_atomic_check,
        .atomic_update = ltdc_plane_atomic_update,
        .atomic_disable = ltdc_plane_atomic_disable,
 
  */
 
 #include <drm/drm_atomic_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_plane_helper.h>
 
 #include "sun4i_backend.h"
 }
 
 static const struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = {
-       .prepare_fb     = drm_gem_fb_prepare_fb,
+       .prepare_fb     = drm_gem_plane_helper_prepare_fb,
        .atomic_disable = sun4i_backend_layer_atomic_disable,
        .atomic_update  = sun4i_backend_layer_atomic_update,
 };
 
 #include <drm/drm_crtc.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_probe_helper.h>
 
 }
 
 static const struct drm_plane_helper_funcs sun8i_ui_layer_helper_funcs = {
-       .prepare_fb     = drm_gem_fb_prepare_fb,
+       .prepare_fb     = drm_gem_plane_helper_prepare_fb,
        .atomic_check   = sun8i_ui_layer_atomic_check,
        .atomic_disable = sun8i_ui_layer_atomic_disable,
        .atomic_update  = sun8i_ui_layer_atomic_update,
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_fb_cma_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_probe_helper.h>
 
 }
 
 static const struct drm_plane_helper_funcs sun8i_vi_layer_helper_funcs = {
-       .prepare_fb     = drm_gem_fb_prepare_fb,
+       .prepare_fb     = drm_gem_plane_helper_prepare_fb,
        .atomic_check   = sun8i_vi_layer_atomic_check,
        .atomic_disable = sun8i_vi_layer_atomic_disable,
        .atomic_update  = sun8i_vi_layer_atomic_update,
 
 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_fourcc.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_plane_helper.h>
 
 #include "dc.h"
        if (!state->fb)
                return 0;
 
-       drm_gem_fb_prepare_fb(plane, state);
+       drm_gem_plane_helper_prepare_fb(plane, state);
 
        return tegra_dc_pin(dc, to_tegra_plane_state(state));
 }
 
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_fb_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 
 #include "tidss_crtc.h"
 #include "tidss_dispc.h"
 }
 
 static const struct drm_plane_helper_funcs tidss_plane_helper_funcs = {
-       .prepare_fb = drm_gem_fb_prepare_fb,
+       .prepare_fb = drm_gem_plane_helper_prepare_fb,
        .atomic_check = tidss_plane_atomic_check,
        .atomic_update = tidss_plane_atomic_update,
        .atomic_disable = tidss_plane_atomic_disable,
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 #include <drm/drm_modeset_helper.h>
        .enable = yx240qv29_enable,
        .disable = mipi_dbi_pipe_disable,
        .update = mipi_dbi_pipe_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct drm_display_mode yx350hv15_mode = {
 
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 #include <drm/drm_rect.h>
        .enable         = ili9225_pipe_enable,
        .disable        = ili9225_pipe_disable,
        .update         = ili9225_pipe_update,
-       .prepare_fb     = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb     = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct drm_display_mode ili9225_mode = {
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 #include <drm/drm_modeset_helper.h>
        .enable = yx240qv29_enable,
        .disable = mipi_dbi_pipe_disable,
        .update = mipi_dbi_pipe_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct drm_display_mode yx240qv29_mode = {
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 #include <drm/drm_modeset_helper.h>
        .enable = waveshare_enable,
        .disable = mipi_dbi_pipe_disable,
        .update = mipi_dbi_pipe_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct drm_display_mode waveshare_mode = {
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 #include <drm/drm_modeset_helper.h>
        .enable = mi0283qt_enable,
        .disable = mipi_dbi_pipe_disable,
        .update = mipi_dbi_pipe_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct drm_display_mode mi0283qt_mode = {
 
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_format_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
        .enable = repaper_pipe_enable,
        .disable = repaper_pipe_disable,
        .update = repaper_pipe_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static int repaper_connector_get_modes(struct drm_connector *connector)
 
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_format_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 #include <drm/drm_rect.h>
        .enable         = st7586_pipe_enable,
        .disable        = st7586_pipe_disable,
        .update         = st7586_pipe_update,
-       .prepare_fb     = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb     = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct drm_display_mode st7586_mode = {
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_mipi_dbi.h>
 
        .enable         = st7735r_pipe_enable,
        .disable        = mipi_dbi_pipe_disable,
        .update         = mipi_dbi_pipe_update,
-       .prepare_fb     = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb     = drm_gem_simple_display_pipe_prepare_fb,
 };
 
 static const struct st7735r_cfg jd_t18003_t01_cfg = {
 
 
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_panel.h>
 #include <drm/drm_vblank.h>
 
        .enable = tve200_display_enable,
        .disable = tve200_display_disable,
        .update = tve200_display_update,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
        .enable_vblank = tve200_display_enable_vblank,
        .disable_vblank = tve200_display_disable_vblank,
 };
 
 #include <drm/drm_atomic_uapi.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fourcc.h>
-#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_plane_helper.h>
 
 #include "uapi/drm/vc4_drm.h"
 
        bo = to_vc4_bo(&drm_fb_cma_get_gem_obj(state->fb, 0)->base);
 
-       drm_gem_fb_prepare_fb(plane, state);
+       drm_gem_plane_helper_prepare_fb(plane, state);
 
        if (plane->state->fb == state->fb)
                return 0;
 
 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_gem_shmem_helper.h>
        if (ret)
                DRM_ERROR("vmap failed: %d\n", ret);
 
-       return drm_gem_fb_prepare_fb(plane, state);
+       return drm_gem_plane_helper_prepare_fb(plane, state);
 }
 
 static void vkms_cleanup_fb(struct drm_plane *plane,
 
 #include <drm/drm_drv.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_gem.h>
+#include <drm/drm_gem_atomic_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_probe_helper.h>
 #include <drm/drm_vblank.h>
        .mode_valid = display_mode_valid,
        .enable = display_enable,
        .disable = display_disable,
-       .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
+       .prepare_fb = drm_gem_simple_display_pipe_prepare_fb,
        .check = display_check,
        .update = display_update,
 };
 
 
 struct drm_simple_display_pipe;
 
+/*
+ * Plane Helpers
+ */
+
+int drm_gem_plane_helper_prepare_fb(struct drm_plane *plane, struct drm_plane_state *state);
+int drm_gem_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe,
+                                          struct drm_plane_state *plane_state);
+
 /*
  * Helpers for planes with shadow buffers
  */
 
 struct drm_framebuffer_funcs;
 struct drm_gem_object;
 struct drm_mode_fb_cmd2;
-struct drm_plane;
-struct drm_plane_state;
-struct drm_simple_display_pipe;
 
 #define AFBC_VENDOR_AND_TYPE_MASK      GENMASK_ULL(63, 52)
 
                         const struct drm_mode_fb_cmd2 *mode_cmd,
                         struct drm_afbc_framebuffer *afbc_fb);
 
-int drm_gem_fb_prepare_fb(struct drm_plane *plane,
-                         struct drm_plane_state *state);
-int drm_gem_fb_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe,
-                                             struct drm_plane_state *plane_state);
 #endif
 
         * members in the plane structure.
         *
         * Drivers which always have their buffers pinned should use
-        * drm_gem_fb_prepare_fb() for this hook.
+        * drm_gem_plane_helper_prepare_fb() for this hook.
         *
         * The helpers will call @cleanup_fb with matching arguments for every
         * successful call to this hook.
 
         * preserved.
         *
         * Drivers should store any implicit fence in this from their
-        * &drm_plane_helper_funcs.prepare_fb callback. See drm_gem_fb_prepare_fb()
-        * and drm_gem_fb_simple_display_pipe_prepare_fb() for suitable helpers.
+        * &drm_plane_helper_funcs.prepare_fb callback. See drm_gem_plane_helper_prepare_fb()
+        * and drm_gem_simple_display_pipe_prepare_fb() for suitable helpers.
         */
        struct dma_fence *fence;
 
 
         * more details.
         *
         * Drivers which always have their buffers pinned should use
-        * drm_gem_fb_simple_display_pipe_prepare_fb() for this hook.
+        * drm_gem_simple_display_pipe_prepare_fb() for this hook.
         */
        int (*prepare_fb)(struct drm_simple_display_pipe *pipe,
                          struct drm_plane_state *plane_state);