struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
        struct drm_device *dev = crtc->dev;
        struct radeon_device *rdev = dev->dev_private;
-       struct radeon_framebuffer *radeon_fb;
        struct drm_framebuffer *target_fb;
        struct drm_gem_object *obj;
        struct radeon_bo *rbo;
                return 0;
        }
 
-       if (atomic) {
-               radeon_fb = to_radeon_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       }
-       else {
-               radeon_fb = to_radeon_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 = radeon_fb->base.obj[0];
+       obj = target_fb->obj[0];
        rbo = gem_to_radeon_bo(obj);
        r = radeon_bo_reserve(rbo, false);
        if (unlikely(r != 0))
        WREG32(EVERGREEN_MASTER_UPDATE_MODE + radeon_crtc->crtc_offset, 0);
 
        if (!atomic && fb && fb != crtc->primary->fb) {
-               radeon_fb = to_radeon_framebuffer(fb);
-               rbo = gem_to_radeon_bo(radeon_fb->base.obj[0]);
+               rbo = gem_to_radeon_bo(fb->obj[0]);
                r = radeon_bo_reserve(rbo, false);
                if (unlikely(r != 0))
                        return r;
        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
        struct drm_device *dev = crtc->dev;
        struct radeon_device *rdev = dev->dev_private;
-       struct radeon_framebuffer *radeon_fb;
        struct drm_gem_object *obj;
        struct radeon_bo *rbo;
        struct drm_framebuffer *target_fb;
                return 0;
        }
 
-       if (atomic) {
-               radeon_fb = to_radeon_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       }
-       else {
-               radeon_fb = to_radeon_framebuffer(crtc->primary->fb);
+       else
                target_fb = crtc->primary->fb;
-       }
 
-       obj = radeon_fb->base.obj[0];
+       obj = target_fb->obj[0];
        rbo = gem_to_radeon_bo(obj);
        r = radeon_bo_reserve(rbo, false);
        if (unlikely(r != 0))
        WREG32(AVIVO_D1MODE_MASTER_UPDATE_MODE + radeon_crtc->crtc_offset, 3);
 
        if (!atomic && fb && fb != crtc->primary->fb) {
-               radeon_fb = to_radeon_framebuffer(fb);
-               rbo = gem_to_radeon_bo(radeon_fb->base.obj[0]);
+               rbo = gem_to_radeon_bo(fb->obj[0]);
                r = radeon_bo_reserve(rbo, false);
                if (unlikely(r != 0))
                        return r;
        atombios_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
        if (crtc->primary->fb) {
                int r;
-               struct radeon_framebuffer *radeon_fb;
                struct radeon_bo *rbo;
 
-               radeon_fb = to_radeon_framebuffer(crtc->primary->fb);
-               rbo = gem_to_radeon_bo(radeon_fb->base.obj[0]);
+               rbo = gem_to_radeon_bo(crtc->primary->fb->obj[0]);
                r = radeon_bo_reserve(rbo, false);
                if (unlikely(r))
                        DRM_ERROR("failed to reserve rbo before unpin\n");
 
        /* unpin the front buffers and cursors */
        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
                struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
-               struct radeon_framebuffer *rfb = to_radeon_framebuffer(crtc->primary->fb);
+               struct drm_framebuffer *fb = crtc->primary->fb;
                struct radeon_bo *robj;
 
                if (radeon_crtc->cursor_bo) {
                        }
                }
 
-               if (rfb == NULL || rfb->base.obj[0] == NULL) {
+               if (fb == NULL || fb->obj[0] == NULL) {
                        continue;
                }
-               robj = gem_to_radeon_bo(rfb->base.obj[0]);
+               robj = gem_to_radeon_bo(fb->obj[0]);
                /* don't unpin kernel fb objects */
                if (!radeon_fbdev_robj_is_fb(rdev, robj)) {
                        r = radeon_bo_reserve(robj, false);
 
        struct drm_device *dev = crtc->dev;
        struct radeon_device *rdev = dev->dev_private;
        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
-       struct radeon_framebuffer *old_radeon_fb;
-       struct radeon_framebuffer *new_radeon_fb;
        struct drm_gem_object *obj;
        struct radeon_flip_work *work;
        struct radeon_bo *new_rbo;
        work->async = (page_flip_flags & DRM_MODE_PAGE_FLIP_ASYNC) != 0;
 
        /* schedule unpin of the old buffer */
-       old_radeon_fb = to_radeon_framebuffer(crtc->primary->fb);
-       obj = old_radeon_fb->base.obj[0];
+       obj = crtc->primary->fb->obj[0];
 
        /* take a reference to the old object */
        drm_gem_object_get(obj);
        work->old_rbo = gem_to_radeon_bo(obj);
 
-       new_radeon_fb = to_radeon_framebuffer(fb);
-       obj = new_radeon_fb->base.obj[0];
+       obj = fb->obj[0];
        new_rbo = gem_to_radeon_bo(obj);
 
        /* pin the new buffer */
 
 int
 radeon_framebuffer_init(struct drm_device *dev,
-                       struct radeon_framebuffer *rfb,
+                       struct drm_framebuffer *fb,
                        const struct drm_mode_fb_cmd2 *mode_cmd,
                        struct drm_gem_object *obj)
 {
        int ret;
-       rfb->base.obj[0] = obj;
-       drm_helper_mode_fill_fb_struct(dev, &rfb->base, mode_cmd);
-       ret = drm_framebuffer_init(dev, &rfb->base, &radeon_fb_funcs);
+       fb->obj[0] = obj;
+       drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);
+       ret = drm_framebuffer_init(dev, fb, &radeon_fb_funcs);
        if (ret) {
-               rfb->base.obj[0] = NULL;
+               fb->obj[0] = NULL;
                return ret;
        }
        return 0;
                               const struct drm_mode_fb_cmd2 *mode_cmd)
 {
        struct drm_gem_object *obj;
-       struct radeon_framebuffer *radeon_fb;
+       struct drm_framebuffer *fb;
        int ret;
 
        obj = drm_gem_object_lookup(file_priv, mode_cmd->handles[0]);
                return ERR_PTR(-EINVAL);
        }
 
-       radeon_fb = kzalloc(sizeof(*radeon_fb), GFP_KERNEL);
-       if (radeon_fb == NULL) {
+       fb = kzalloc(sizeof(*fb), GFP_KERNEL);
+       if (fb == NULL) {
                drm_gem_object_put_unlocked(obj);
                return ERR_PTR(-ENOMEM);
        }
 
-       ret = radeon_framebuffer_init(dev, radeon_fb, mode_cmd, obj);
+       ret = radeon_framebuffer_init(dev, fb, mode_cmd, obj);
        if (ret) {
-               kfree(radeon_fb);
+               kfree(fb);
                drm_gem_object_put_unlocked(obj);
                return ERR_PTR(ret);
        }
 
-       return &radeon_fb->base;
+       return fb;
 }
 
 static const struct drm_mode_config_funcs radeon_mode_funcs = {
 
  */
 struct radeon_fbdev {
        struct drm_fb_helper helper;
-       struct radeon_framebuffer rfb;
+       struct drm_framebuffer fb;
        struct radeon_device *rdev;
 };
 
 
        info->par = rfbdev;
 
-       ret = radeon_framebuffer_init(rdev->ddev, &rfbdev->rfb, &mode_cmd, gobj);
+       ret = radeon_framebuffer_init(rdev->ddev, &rfbdev->fb, &mode_cmd, gobj);
        if (ret) {
                DRM_ERROR("failed to initialize framebuffer %d\n", ret);
                goto out;
        }
 
-       fb = &rfbdev->rfb.base;
+       fb = &rfbdev->fb;
 
        /* setup helper */
        rfbdev->helper.fb = fb;
 
 static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfbdev)
 {
-       struct radeon_framebuffer *rfb = &rfbdev->rfb;
+       struct drm_framebuffer *fb = &rfbdev->fb;
 
        drm_fb_helper_unregister_fbi(&rfbdev->helper);
 
-       if (rfb->base.obj[0]) {
-               radeonfb_destroy_pinned_object(rfb->base.obj[0]);
-               rfb->base.obj[0] = NULL;
-               drm_framebuffer_unregister_private(&rfb->base);
-               drm_framebuffer_cleanup(&rfb->base);
+       if (fb->obj[0]) {
+               radeonfb_destroy_pinned_object(fb->obj[0]);
+               fb->obj[0] = NULL;
+               drm_framebuffer_unregister_private(fb);
+               drm_framebuffer_cleanup(fb);
        }
        drm_fb_helper_fini(&rfbdev->helper);
 
        if (!rdev->mode_info.rfbdev)
                return false;
 
-       if (robj == gem_to_radeon_bo(rdev->mode_info.rfbdev->rfb.base.obj[0]))
+       if (robj == gem_to_radeon_bo(rdev->mode_info.rfbdev->fb.obj[0]))
                return true;
        return false;
 }
 
        struct drm_device *dev = crtc->dev;
        struct radeon_device *rdev = dev->dev_private;
        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
-       struct radeon_framebuffer *radeon_fb;
        struct drm_framebuffer *target_fb;
        struct drm_gem_object *obj;
        struct radeon_bo *rbo;
                return 0;
        }
 
-       if (atomic) {
-               radeon_fb = to_radeon_framebuffer(fb);
+       if (atomic)
                target_fb = fb;
-       }
-       else {
-               radeon_fb = to_radeon_framebuffer(crtc->primary->fb);
+       else
                target_fb = crtc->primary->fb;
-       }
 
        switch (target_fb->format->cpp[0] * 8) {
        case 8:
        }
 
        /* Pin framebuffer & get tilling informations */
-       obj = radeon_fb->base.obj[0];
+       obj = target_fb->obj[0];
        rbo = gem_to_radeon_bo(obj);
 retry:
        r = radeon_bo_reserve(rbo, false);
 
 #define to_radeon_crtc(x) container_of(x, struct radeon_crtc, base)
 #define to_radeon_connector(x) container_of(x, struct radeon_connector, base)
 #define to_radeon_encoder(x) container_of(x, struct radeon_encoder, base)
-#define to_radeon_framebuffer(x) container_of(x, struct radeon_framebuffer, base)
 
 #define RADEON_MAX_HPD_PINS 7
 #define RADEON_MAX_CRTCS 6
        int enabled_attribs;
 };
 
-struct radeon_framebuffer {
-       struct drm_framebuffer base;
-};
-
 #define ENCODER_MODE_IS_DP(em) (((em) == ATOM_ENCODER_MODE_DP) || \
                                ((em) == ATOM_ENCODER_MODE_DP_MST))
 
 extern void
 radeon_combios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on);
 int radeon_framebuffer_init(struct drm_device *dev,
-                            struct radeon_framebuffer *rfb,
+                            struct drm_framebuffer *rfb,
                             const struct drm_mode_fb_cmd2 *mode_cmd,
                             struct drm_gem_object *obj);