adev_to_drm(adev)->mode_config.preferred_depth = 24;
        adev_to_drm(adev)->mode_config.prefer_shadow = 1;
 
-       adev_to_drm(adev)->mode_config.fb_base = adev->gmc.aper_base;
-
        r = amdgpu_display_modeset_create_props(adev);
        if (r)
                return r;
 
 
        adev_to_drm(adev)->mode_config.fb_modifiers_not_supported = true;
 
-       adev_to_drm(adev)->mode_config.fb_base = adev->gmc.aper_base;
-
        r = amdgpu_display_modeset_create_props(adev);
        if (r)
                return r;
 
 
        adev_to_drm(adev)->mode_config.fb_modifiers_not_supported = true;
 
-       adev_to_drm(adev)->mode_config.fb_base = adev->gmc.aper_base;
-
        r = amdgpu_display_modeset_create_props(adev);
        if (r)
                return r;
 
        adev_to_drm(adev)->mode_config.preferred_depth = 24;
        adev_to_drm(adev)->mode_config.prefer_shadow = 1;
        adev_to_drm(adev)->mode_config.fb_modifiers_not_supported = true;
-       adev_to_drm(adev)->mode_config.fb_base = adev->gmc.aper_base;
 
        r = amdgpu_display_modeset_create_props(adev);
        if (r)
 
 
        adev_to_drm(adev)->mode_config.fb_modifiers_not_supported = true;
 
-       adev_to_drm(adev)->mode_config.fb_base = adev->gmc.aper_base;
-
        r = amdgpu_display_modeset_create_props(adev);
        if (r)
                return r;
 
        /* indicates support for immediate flip */
        adev_to_drm(adev)->mode_config.async_page_flip = true;
 
-       adev_to_drm(adev)->mode_config.fb_base = adev->gmc.aper_base;
-
        state = kzalloc(sizeof(*state), GFP_KERNEL);
        if (!state)
                return -ENOMEM;
 
 int ast_mode_config_init(struct ast_private *ast)
 {
        struct drm_device *dev = &ast->base;
-       struct pci_dev *pdev = to_pci_dev(dev->dev);
        int ret;
 
        ret = drmm_mode_config_init(dev);
        dev->mode_config.min_width = 0;
        dev->mode_config.min_height = 0;
        dev->mode_config.preferred_depth = 24;
-       dev->mode_config.fb_base = pci_resource_start(pdev, 0);
 
        if (ast->chip == AST2100 ||
            ast->chip == AST2200 ||
 
 
        info->fbops = &psbfb_unaccel_ops;
 
-       info->fix.smem_start = dev->mode_config.fb_base;
+       info->fix.smem_start = dev_priv->fb_base;
        info->fix.smem_len = size;
        info->fix.ywrapstep = 0;
        info->fix.ypanstep = 0;
        info->screen_size = size;
 
        if (dev_priv->gtt.stolen_size) {
-               info->apertures->ranges[0].base = dev->mode_config.fb_base;
+               info->apertures->ranges[0].base = dev_priv->fb_base;
                info->apertures->ranges[0].size = dev_priv->gtt.stolen_size;
        }
 
 
        /* set memory base */
        /* Oaktrail and Poulsbo should use BAR 2*/
-       pci_read_config_dword(pdev, PSB_BSM, (u32 *)&(dev->mode_config.fb_base));
+       pci_read_config_dword(pdev, PSB_BSM, (u32 *)&(dev_priv->fb_base));
 
        /* num pipes is 2 for PSB but 1 for Mrst */
        for (i = 0; i < dev_priv->num_pipe; i++)
 
        uint32_t blc_adj2;
 
        struct drm_fb_helper *fb_helper;
+       resource_size_t fb_base;
 
        bool dsr_enable;
        u32 dsr_fb_update;
 
        dev->mode_config.max_width = 1920;
        dev->mode_config.max_height = 1200;
 
-       dev->mode_config.fb_base = priv->fb_base;
        dev->mode_config.preferred_depth = 32;
        dev->mode_config.prefer_shadow = 1;
 
 {
        struct drm_device *dev = &priv->dev;
        struct pci_dev *pdev = to_pci_dev(dev->dev);
-       resource_size_t addr, size, ioaddr, iosize;
+       resource_size_t ioaddr, iosize;
 
        ioaddr = pci_resource_start(pdev, 1);
        iosize = pci_resource_len(pdev, 1);
                return -ENOMEM;
        }
 
-       addr = pci_resource_start(pdev, 0);
-       size = pci_resource_len(pdev, 0);
-       priv->fb_map = devm_ioremap(dev->dev, addr, size);
-       if (!priv->fb_map) {
-               drm_err(dev, "Cannot map framebuffer\n");
-               return -ENOMEM;
-       }
-       priv->fb_base = addr;
-       priv->fb_size = size;
-
        return 0;
 }
 
        if (ret)
                goto err;
 
-       ret = drmm_vram_helper_init(dev, pci_resource_start(pdev, 0), priv->fb_size);
+       ret = drmm_vram_helper_init(dev, pci_resource_start(pdev, 0),
+                                   pci_resource_len(pdev, 0));
        if (ret) {
                drm_err(dev, "Error initializing VRAM MM; %d\n", ret);
                goto err;
 
 struct hibmc_drm_private {
        /* hw */
        void __iomem   *mmio;
-       void __iomem   *fb_map;
-       resource_size_t  fb_base;
-       resource_size_t  fb_size;
 
        /* drm */
        struct drm_device dev;
 
        dev->mode_config.max_width = MGAG200_MAX_FB_WIDTH;
        dev->mode_config.max_height = MGAG200_MAX_FB_HEIGHT;
        dev->mode_config.preferred_depth = 24;
-       dev->mode_config.fb_base = mdev->vram_res->start;
        dev->mode_config.funcs = &mgag200_mode_config_funcs;
        dev->mode_config.helper_private = &mgag200_mode_config_helper_funcs;
 
 
 
        drm_fb_helper_fill_info(fbi, helper, sizes);
 
-       dev->mode_config.fb_base = paddr;
-
        fbi->screen_base = msm_gem_get_vaddr(bo);
        if (IS_ERR(fbi->screen_base)) {
                ret = PTR_ERR(fbi->screen_base);
 
        drm_mode_create_dvi_i_properties(dev);
 
        dev->mode_config.funcs = &nouveau_mode_config_funcs;
-       dev->mode_config.fb_base = device->func->resource_addr(device, 1);
 
        dev->mode_config.min_width = 0;
        dev->mode_config.min_height = 0;
 
        struct nouveau_channel *chan = drm->channel;
        struct nvif_device *device = &drm->client.device;
        struct nvif_push *push = chan->chan.push;
+       struct nvkm_device *nvkm_device = nvxx_device(&drm->client.device);
+       resource_size_t fb_base = nvkm_device->func->resource_addr(nvkm_device, 1);
        int surface_fmt, pattern_fmt, rect_fmt;
        int ret;
 
                               0x0188, chan->vram.handle);
        PUSH_NVSQ(push, NV042, 0x0300, surface_fmt,
                               0x0304, info->fix.line_length | (info->fix.line_length << 16),
-                              0x0308, info->fix.smem_start - dev->mode_config.fb_base,
-                              0x030c, info->fix.smem_start - dev->mode_config.fb_base);
+                              0x0308, info->fix.smem_start - fb_base,
+                              0x030c, info->fix.smem_start - fb_base);
 
        PUSH_NVSQ(push, NV043, 0x0000, nfbdev->rop.handle);
        PUSH_NVSQ(push, NV043, 0x0300, 0x55);
 
 
        drm_fb_helper_fill_info(fbi, helper, sizes);
 
-       dev->mode_config.fb_base = dma_addr;
-
        fbi->screen_buffer = omap_gem_vaddr(fbdev->bo);
        fbi->screen_size = fbdev->bo->size;
        fbi->fix.smem_start = dma_addr;
 
        qdev->ddev.mode_config.max_width = 8192;
        qdev->ddev.mode_config.max_height = 8192;
 
-       qdev->ddev.mode_config.fb_base = qdev->vram_base;
-
        drm_mode_create_suggested_offset_properties(&qdev->ddev);
        qxl_mode_create_hotplug_mode_update_property(qdev);
 
 
 
        rdev->ddev->mode_config.fb_modifiers_not_supported = true;
 
-       rdev->ddev->mode_config.fb_base = rdev->mc.aper_base;
-
        ret = radeon_modeset_create_props(rdev);
        if (ret) {
                return ret;
 
        drm_fb_helper_fill_info(info, &rfbdev->helper, sizes);
 
        /* setup aperture base/size for vesafb takeover */
-       info->apertures->ranges[0].base = rdev->ddev->mode_config.fb_base;
+       info->apertures->ranges[0].base = rdev->mc.aper_base;
        info->apertures->ranges[0].size = rdev->mc.aper_size;
 
        /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
                }
        }
 
-       drm->mode_config.fb_base = (resource_size_t)bo->iova;
        info->screen_base = (void __iomem *)bo->vaddr + offset;
        info->screen_size = size;
        info->fix.smem_start = (unsigned long)(bo->iova + offset);
 
        bochs->dev->mode_config.max_width = 8192;
        bochs->dev->mode_config.max_height = 8192;
 
-       bochs->dev->mode_config.fb_base = bochs->fb_base;
        bochs->dev->mode_config.preferred_depth = 24;
        bochs->dev->mode_config.prefer_shadow = 0;
        bochs->dev->mode_config.prefer_shadow_fbdev = 1;
 
  * @max_width: maximum fb pixel width on this device
  * @max_height: maximum fb pixel height on this device
  * @funcs: core driver provided mode setting functions
- * @fb_base: base address of the framebuffer
  * @poll_enabled: track polling support for this device
  * @poll_running: track polling status for this device
  * @delayed_event: track delayed poll uevent deliver for this device
        int min_width, min_height;
        int max_width, max_height;
        const struct drm_mode_config_funcs *funcs;
-       resource_size_t fb_base;
 
        /* output poll support */
        bool poll_enabled;