/* unpin the front buffers and cursors */
        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
                struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
-               struct amdgpu_framebuffer *rfb = to_amdgpu_framebuffer(crtc->primary->fb);
+               struct drm_framebuffer *fb = crtc->primary->fb;
                struct amdgpu_bo *robj;
 
                if (amdgpu_crtc->cursor_bo) {
                        }
                }
 
-               if (rfb == NULL || rfb->obj == NULL) {
+               if (fb == NULL || fb->obj[0] == NULL) {
                        continue;
                }
-               robj = gem_to_amdgpu_bo(rfb->obj);
+               robj = gem_to_amdgpu_bo(fb->obj[0]);
                /* don't unpin kernel fb objects */
                if (!amdgpu_fbdev_robj_is_fb(adev, robj)) {
                        r = amdgpu_bo_reserve(robj, true);
 
 #include <linux/pm_runtime.h>
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_edid.h>
+#include <drm/drm_gem_framebuffer_helper.h>
 #include <drm/drm_fb_helper.h>
 
 static void amdgpu_display_flip_callback(struct dma_fence *f,
        struct drm_device *dev = crtc->dev;
        struct amdgpu_device *adev = dev->dev_private;
        struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
-       struct amdgpu_framebuffer *old_amdgpu_fb;
-       struct amdgpu_framebuffer *new_amdgpu_fb;
        struct drm_gem_object *obj;
        struct amdgpu_flip_work *work;
        struct amdgpu_bo *new_abo;
        work->async = (page_flip_flags & DRM_MODE_PAGE_FLIP_ASYNC) != 0;
 
        /* schedule unpin of the old buffer */
-       old_amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
-       obj = old_amdgpu_fb->obj;
+       obj = crtc->primary->fb->obj[0];
 
        /* take a reference to the old object */
        work->old_abo = gem_to_amdgpu_bo(obj);
        amdgpu_bo_ref(work->old_abo);
 
-       new_amdgpu_fb = to_amdgpu_framebuffer(fb);
-       obj = new_amdgpu_fb->obj;
+       obj = fb->obj[0];
        new_abo = gem_to_amdgpu_bo(obj);
 
        /* pin the new buffer */
        return true;
 }
 
-static void amdgpu_display_user_framebuffer_destroy(struct drm_framebuffer *fb)
-{
-       struct amdgpu_framebuffer *amdgpu_fb = to_amdgpu_framebuffer(fb);
-
-       drm_gem_object_put_unlocked(amdgpu_fb->obj);
-       drm_framebuffer_cleanup(fb);
-       kfree(amdgpu_fb);
-}
-
-static int amdgpu_display_user_framebuffer_create_handle(
-                       struct drm_framebuffer *fb,
-                       struct drm_file *file_priv,
-                       unsigned int *handle)
-{
-       struct amdgpu_framebuffer *amdgpu_fb = to_amdgpu_framebuffer(fb);
-
-       return drm_gem_handle_create(file_priv, amdgpu_fb->obj, handle);
-}
-
 static const struct drm_framebuffer_funcs amdgpu_fb_funcs = {
-       .destroy = amdgpu_display_user_framebuffer_destroy,
-       .create_handle = amdgpu_display_user_framebuffer_create_handle,
+       .destroy = drm_gem_fb_destroy,
+       .create_handle = drm_gem_fb_create_handle,
 };
 
 uint32_t amdgpu_display_framebuffer_domains(struct amdgpu_device *adev)
                                    struct drm_gem_object *obj)
 {
        int ret;
-       rfb->obj = obj;
+       rfb->base.obj[0] = obj;
        drm_helper_mode_fill_fb_struct(dev, &rfb->base, mode_cmd);
        ret = drm_framebuffer_init(dev, &rfb->base, &amdgpu_fb_funcs);
        if (ret) {
-               rfb->obj = NULL;
+               rfb->base.obj[0] = NULL;
                return ret;
        }
        return 0;
 
 
        drm_fb_helper_unregister_fbi(&rfbdev->helper);
 
-       if (rfb->obj) {
-               amdgpufb_destroy_pinned_object(rfb->obj);
-               rfb->obj = NULL;
+       if (rfb->base.obj[0]) {
+               amdgpufb_destroy_pinned_object(rfb->base.obj[0]);
+               rfb->base.obj[0] = NULL;
                drm_framebuffer_unregister_private(&rfb->base);
                drm_framebuffer_cleanup(&rfb->base);
        }
        if (!adev->mode_info.rfbdev)
                return 0;
 
-       robj = gem_to_amdgpu_bo(adev->mode_info.rfbdev->rfb.obj);
+       robj = gem_to_amdgpu_bo(adev->mode_info.rfbdev->rfb.base.obj[0]);
        size += amdgpu_bo_size(robj);
        return size;
 }
 {
        if (!adev->mode_info.rfbdev)
                return false;
-       if (robj == gem_to_amdgpu_bo(adev->mode_info.rfbdev->rfb.obj))
+       if (robj == gem_to_amdgpu_bo(adev->mode_info.rfbdev->rfb.base.obj[0]))
                return true;
        return false;
 }
 
 
 struct amdgpu_framebuffer {
        struct drm_framebuffer base;
-       struct drm_gem_object *obj;
 
        /* caching for later use */
        uint64_t address;
 
        struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
        struct drm_device *dev = crtc->dev;
        struct amdgpu_device *adev = dev->dev_private;
-       struct amdgpu_framebuffer *amdgpu_fb;
        struct drm_framebuffer *target_fb;
        struct drm_gem_object *obj;
        struct amdgpu_bo *abo;
                return 0;
        }
 
-       if (atomic) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       } else {
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
+       else
                target_fb = crtc->primary->fb;
-       }
 
        /* If atomic, assume fb object is pinned & idle & fenced and
         * just update base pointers
         */
-       obj = amdgpu_fb->obj;
+       obj = target_fb->obj[0];
        abo = gem_to_amdgpu_bo(obj);
        r = amdgpu_bo_reserve(abo, false);
        if (unlikely(r != 0))
        WREG32(mmMASTER_UPDATE_MODE + amdgpu_crtc->crtc_offset, 0);
 
        if (!atomic && fb && fb != crtc->primary->fb) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r != 0))
                        return r;
        dce_v10_0_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
        if (crtc->primary->fb) {
                int r;
-               struct amdgpu_framebuffer *amdgpu_fb;
                struct amdgpu_bo *abo;
 
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(crtc->primary->fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r))
                        DRM_ERROR("failed to reserve abo before unpin\n");
 
        struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
        struct drm_device *dev = crtc->dev;
        struct amdgpu_device *adev = dev->dev_private;
-       struct amdgpu_framebuffer *amdgpu_fb;
        struct drm_framebuffer *target_fb;
        struct drm_gem_object *obj;
        struct amdgpu_bo *abo;
                return 0;
        }
 
-       if (atomic) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       } else {
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
+       else
                target_fb = crtc->primary->fb;
-       }
 
        /* If atomic, assume fb object is pinned & idle & fenced and
         * just update base pointers
         */
-       obj = amdgpu_fb->obj;
+       obj = target_fb->obj[0];
        abo = gem_to_amdgpu_bo(obj);
        r = amdgpu_bo_reserve(abo, false);
        if (unlikely(r != 0))
        WREG32(mmCRTC_MASTER_UPDATE_MODE + amdgpu_crtc->crtc_offset, 0);
 
        if (!atomic && fb && fb != crtc->primary->fb) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r != 0))
                        return r;
        dce_v11_0_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
        if (crtc->primary->fb) {
                int r;
-               struct amdgpu_framebuffer *amdgpu_fb;
                struct amdgpu_bo *abo;
 
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(crtc->primary->fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r))
                        DRM_ERROR("failed to reserve abo before unpin\n");
 
        struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
        struct drm_device *dev = crtc->dev;
        struct amdgpu_device *adev = dev->dev_private;
-       struct amdgpu_framebuffer *amdgpu_fb;
        struct drm_framebuffer *target_fb;
        struct drm_gem_object *obj;
        struct amdgpu_bo *abo;
                return 0;
        }
 
-       if (atomic) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       } else {
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
+       else
                target_fb = crtc->primary->fb;
-       }
 
        /* If atomic, assume fb object is pinned & idle & fenced and
         * just update base pointers
         */
-       obj = amdgpu_fb->obj;
+       obj = target_fb->obj[0];
        abo = gem_to_amdgpu_bo(obj);
        r = amdgpu_bo_reserve(abo, false);
        if (unlikely(r != 0))
        WREG32(mmMASTER_UPDATE_MODE + amdgpu_crtc->crtc_offset, 0);
 
        if (!atomic && fb && fb != crtc->primary->fb) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r != 0))
                        return r;
        dce_v6_0_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
        if (crtc->primary->fb) {
                int r;
-               struct amdgpu_framebuffer *amdgpu_fb;
                struct amdgpu_bo *abo;
 
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(crtc->primary->fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r))
                        DRM_ERROR("failed to reserve abo before unpin\n");
 
        struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
        struct drm_device *dev = crtc->dev;
        struct amdgpu_device *adev = dev->dev_private;
-       struct amdgpu_framebuffer *amdgpu_fb;
        struct drm_framebuffer *target_fb;
        struct drm_gem_object *obj;
        struct amdgpu_bo *abo;
                return 0;
        }
 
-       if (atomic) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       } else {
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
+       else
                target_fb = crtc->primary->fb;
-       }
 
        /* If atomic, assume fb object is pinned & idle & fenced and
         * just update base pointers
         */
-       obj = amdgpu_fb->obj;
+       obj = target_fb->obj[0];
        abo = gem_to_amdgpu_bo(obj);
        r = amdgpu_bo_reserve(abo, false);
        if (unlikely(r != 0))
        WREG32(mmMASTER_UPDATE_MODE + amdgpu_crtc->crtc_offset, 0);
 
        if (!atomic && fb && fb != crtc->primary->fb) {
-               amdgpu_fb = to_amdgpu_framebuffer(fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r != 0))
                        return r;
        dce_v8_0_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
        if (crtc->primary->fb) {
                int r;
-               struct amdgpu_framebuffer *amdgpu_fb;
                struct amdgpu_bo *abo;
 
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(crtc->primary->fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r))
                        DRM_ERROR("failed to reserve abo before unpin\n");
 
        dce_virtual_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
        if (crtc->primary->fb) {
                int r;
-               struct amdgpu_framebuffer *amdgpu_fb;
                struct amdgpu_bo *abo;
 
-               amdgpu_fb = to_amdgpu_framebuffer(crtc->primary->fb);
-               abo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+               abo = gem_to_amdgpu_bo(crtc->primary->fb->obj[0]);
                r = amdgpu_bo_reserve(abo, true);
                if (unlikely(r))
                        DRM_ERROR("failed to reserve abo before unpin\n");
 
 static int get_fb_info(const struct amdgpu_framebuffer *amdgpu_fb,
                       uint64_t *tiling_flags)
 {
-       struct amdgpu_bo *rbo = gem_to_amdgpu_bo(amdgpu_fb->obj);
+       struct amdgpu_bo *rbo = gem_to_amdgpu_bo(amdgpu_fb->base.obj[0]);
        int r = amdgpu_bo_reserve(rbo, false);
 
        if (unlikely(r)) {
        }
 
        afb = to_amdgpu_framebuffer(new_state->fb);
-
-       obj = afb->obj;
+       obj = new_state->fb->obj[0];
        rbo = gem_to_amdgpu_bo(obj);
        adev = amdgpu_ttm_adev(rbo->tbo.bdev);
        r = amdgpu_bo_reserve(rbo, false);
                                       struct drm_plane_state *old_state)
 {
        struct amdgpu_bo *rbo;
-       struct amdgpu_framebuffer *afb;
        int r;
 
        if (!old_state->fb)
                return;
 
-       afb = to_amdgpu_framebuffer(old_state->fb);
-       rbo = gem_to_amdgpu_bo(afb->obj);
+       rbo = gem_to_amdgpu_bo(old_state->fb->obj[0]);
        r = amdgpu_bo_reserve(rbo, false);
        if (unlikely(r)) {
                DRM_ERROR("failed to reserve rbo before unpin\n");
        int r, vpos, hpos;
        struct amdgpu_crtc *acrtc = to_amdgpu_crtc(crtc);
        struct amdgpu_framebuffer *afb = to_amdgpu_framebuffer(fb);
-       struct amdgpu_bo *abo = gem_to_amdgpu_bo(afb->obj);
+       struct amdgpu_bo *abo = gem_to_amdgpu_bo(fb->obj[0]);
        struct amdgpu_device *adev = crtc->dev->dev_private;
        bool async_flip = (crtc->state->pageflip_flags & DRM_MODE_PAGE_FLIP_ASYNC) != 0;
        struct dc_flip_addrs addr = { {0} };