diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 679700dd136c..d87d18c89e06 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -4243,11 +4243,12 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	 * stopped setting them when it got rid of its specific framebuffer
 	 * initialization to use the generic drm_fb_helper code.
 	 *
-	 * We can't do this in register_framebuffer() anymore because the
-	 * values passed to register_fictitious_range() below are unavailable
-	 * from a generic structure set by both drivers.
+	 * To keep doing this in register_framebuffer() the values are passed
+	 * to register_fictitious_range() in additional FreeBSD-specific fields
+	 * of drm_driver structure.
 	 */
-	register_fictitious_range(adev->gmc.aper_base, adev->gmc.aper_size);
+	adev_to_drm(adev)->aperture_base = adev->gmc.aper_base;
+	adev_to_drm(adev)->aperture_size = adev->gmc.aper_size;
 #endif
 
 	amdgpu_fence_driver_hw_init(adev);
@@ -4460,10 +4461,6 @@ void amdgpu_device_fini_hw(struct amdgpu_device *adev)
 	/* disable ras feature must before hw fini */
 	amdgpu_ras_pre_fini(adev);
 
-#ifdef __FreeBSD__
-	unregister_fictitious_range(adev->gmc.aper_base, adev->gmc.aper_size);
-#endif
-
 	amdgpu_ttm_set_buffer_funcs_status(adev, false);
 
 	amdgpu_device_ip_fini_early(adev);
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 249b47c5b321..7dbfc7f3721b 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -594,7 +594,9 @@ static void drm_dev_init_release(struct drm_device *dev, void *res)
 	drm_fs_inode_free(dev->anon_inode);
 #endif
 
+#ifdef __linux__
 	put_device(dev->dev);
+#endif
 	/* Prevent use-after-free in drm_managed_release when debugging is
 	 * enabled. Slightly awkward, but can't really be helped. */
 	dev->dev = NULL;
@@ -620,7 +622,11 @@ static int drm_dev_init(struct drm_device *dev,
 		return -EINVAL;
 
 	kref_init(&dev->ref);
+#ifdef __linux__
 	dev->dev = get_device(parent);
+#elif defined (__FreeBSD__)
+	dev->dev = parent;
+#endif
 	dev->driver = driver;
 
 	INIT_LIST_HEAD(&dev->managed.resources);
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 2d1d3f57956d..14de360a685c 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -1896,15 +1896,16 @@ __drm_fb_helper_initial_config_and_unlock(struct drm_fb_helper *fb_helper)
 	if (!drm_leak_fbdev_smem)
 		info->flags |= FBINFO_HIDE_SMEM_START;
 
-#ifdef __FreeBSD__
-	info->fbio.fb_priv = fb_helper;
-#endif
-
 	/* Need to drop locks to avoid recursive deadlock in
 	 * register_framebuffer. This is ok because the only thing left to do is
 	 * register the fbdev emulation instance in kernel_fb_helper_list. */
 	mutex_unlock(&fb_helper->lock);
 
+#ifdef __FreeBSD__
+	info->fb_bsddev = dev->dev->bsddev;
+	info->aperture_base = dev->aperture_base;
+	info->aperture_size = dev->aperture_size;
+#endif
 	ret = register_framebuffer(info);
 	if (ret < 0)
 		return ret;
diff --git a/drivers/gpu/drm/drm_os_freebsd.c b/drivers/gpu/drm/drm_os_freebsd.c
index 4a2278055404..cf05e35df9c0 100644
--- a/drivers/gpu/drm/drm_os_freebsd.c
+++ b/drivers/gpu/drm/drm_os_freebsd.c
@@ -1,29 +1,16 @@
+#include <sys/types.h>
+#include <sys/bus.h>
+#include <sys/reboot.h>
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
+#include <linux/cdev.h>
+#undef cdev
 
 #include <drm/drm_file.h>
 #include <drm/drm_ioctl.h>
 #include <drm/drm_print.h>
-#include <drm/drm_fb_helper.h>
 #include <drm/drm_os_freebsd.h>
 
-#include <sys/types.h>
-#include <sys/bus.h>
-#include <dev/agp/agpreg.h>
-#include <dev/pci/pcireg.h>
-#include <sys/reboot.h>
-#include <sys/fbio.h>
-#include <dev/vt/vt.h>
-#include <dev/iicbus/iicbus.h>
-#include <dev/iicbus/iiconf.h>
-
-#include <vm/vm_phys.h>
-
-#include <linux/cdev.h>
-#include <linux/fb.h>
-#undef fb_info
-#undef cdev
+#include "vt_drmfb.h"	/* skip_ddb */
 
 MALLOC_DEFINE(DRM_MEM_DRIVER, "drm_driver", "DRM DRIVER Data Structures");
 
@@ -31,7 +18,6 @@ SYSCTL_NODE(_dev, OID_AUTO, drm, CTLFLAG_RW, 0, "DRM args (compat)");
 SYSCTL_LONG(_dev_drm, OID_AUTO, __drm_debug, CTLFLAG_RWTUN, &__drm_debug, 0, "drm debug flags (compat)");
 SYSCTL_NODE(_hw, OID_AUTO, dri, CTLFLAG_RW, 0, "DRI args");
 SYSCTL_LONG(_hw_dri, OID_AUTO, __drm_debug, CTLFLAG_RWTUN, &__drm_debug, 0, "drm debug flags");
-int skip_ddb;
 SYSCTL_INT(_dev_drm, OID_AUTO, skip_ddb, CTLFLAG_RWTUN, &skip_ddb, 0, "go straight to dumping core (compat)");
 SYSCTL_INT(_hw_dri, OID_AUTO, skip_ddb, CTLFLAG_RWTUN, &skip_ddb, 0, "go straight to dumping core");
 #if defined(DRM_DEBUG_LOG_ALL)
@@ -77,40 +63,6 @@ sysctl_pci_id(SYSCTL_HANDLER_ARGS)
 	return (sysctl_handle_string(oidp, buf, sizeof(buf), req));
 }
 
-int
-register_fictitious_range(vm_paddr_t base, size_t size)
-{
-	int ret;
-	struct apertures_struct *ap;
-
-	MPASS(base != 0);
-	MPASS(size != 0);
-
-	ap = alloc_apertures(1);
-	ap->ranges[0].base = base;
-	ap->ranges[0].size = size;
-	vt_freeze_main_vd(ap);
-	kfree(ap);
-
-	ret = vm_phys_fictitious_reg_range(base, base + size,
-#ifdef VM_MEMATTR_WRITE_COMBINING
-					   VM_MEMATTR_WRITE_COMBINING
-#else
-					   VM_MEMATTR_UNCACHEABLE
-#endif
-	    );
-	MPASS(ret == 0);
-
-	return (ret);
-}
-
-void
-unregister_fictitious_range(vm_paddr_t base, size_t size)
-{
-	vm_phys_fictitious_unreg_range(base, base + size);
-	vt_unfreeze_main_vd();
-}
-
 /* Framebuffer related code */
 
 int
@@ -179,13 +131,6 @@ MODULE_VERSION(drmn, 2);
 #ifdef CONFIG_AGP
 MODULE_DEPEND(drmn, agp, 1, 1, 1);
 #endif
-DRIVER_MODULE(iicbus, drmn, iicbus_driver, NULL, NULL);
-DRIVER_MODULE(acpi_iicbus, drmn, acpi_iicbus_driver, NULL, NULL);
-MODULE_DEPEND(drmn, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
-MODULE_DEPEND(drmn, iic, 1, 1, 1);
-MODULE_DEPEND(drmn, iicbb, IICBB_MINVER, IICBB_PREFVER, IICBB_MAXVER);
-MODULE_DEPEND(drmn, pci, 1, 1, 1);
-MODULE_DEPEND(drmn, mem, 1, 1, 1);
 MODULE_DEPEND(drmn, linuxkpi, 1, 1, 1);
 MODULE_DEPEND(drmn, linuxkpi_video, 1, 1, 1);
 MODULE_DEPEND(drmn, dmabuf, 1, 1, 1);
diff --git a/drivers/gpu/drm/drm_os_freebsd.h b/drivers/gpu/drm/drm_os_freebsd.h
index 4426a3af4a14..d58681411ef3 100644
--- a/drivers/gpu/drm/drm_os_freebsd.h
+++ b/drivers/gpu/drm/drm_os_freebsd.h
@@ -3,15 +3,11 @@
  * OS abstraction macros.
  */
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
 #ifndef _DRM_OS_FREEBSD_H_
 #define	_DRM_OS_FREEBSD_H_
 
-#include <sys/fbio.h>
-#include <sys/priv.h>
-#include <sys/smp.h>
+#include <sys/param.h>
+#include <sys/bus.h>
 
 #include <linux/mod_devicetable.h>
 #include <linux/fb.h>
@@ -25,35 +21,13 @@ __FBSDID("$FreeBSD$");
 #define	EREMOTEIO	EIO
 
 #define	KTR_DRM		KTR_DEV
-#define	KTR_DRM_REG	KTR_SPARE3
 
-MALLOC_DECLARE(DRM_MEM_DRIVER);
+struct drm_minor;
+struct device;
 
-extern int skip_ddb;
+MALLOC_DECLARE(DRM_MEM_DRIVER);
 
-struct drm_minor;
 int drm_dev_alias(struct device *dev, struct drm_minor *minor, const char *minor_str);
 void cancel_reset_debug_log(void);
 
-void vt_freeze_main_vd(struct apertures_struct *a);
-void vt_unfreeze_main_vd(void);
-
-int register_fictitious_range(vm_paddr_t start, vm_paddr_t end);
-void unregister_fictitious_range(vm_paddr_t start, vm_paddr_t end);
-
-#if 0
-struct linux_fb_info;
-static inline void vga_switcheroo_unregister_client(struct pci_dev *pdev) {}
-static inline int vga_switcheroo_register_client(struct pci_dev *pdev,
-		const struct vga_switcheroo_client_ops *ops) { return 0; }
-static inline void vga_switcheroo_client_fb_set(struct pci_dev *pdev, struct linux_fb_info *info) {}
-static inline int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler) { return 0; }
-static inline int vga_switcheroo_register_audio_client(struct pci_dev *pdev,
-	const struct vga_switcheroo_client_ops *ops,
-	int id, bool active) { return 0; }
-static inline void vga_switcheroo_unregister_handler(void) {}
-static inline int vga_switcheroo_process_delayed_switch(void) { return 0; }
-static inline int vga_switcheroo_get_client_state(struct pci_dev *pdev) { return VGA_SWITCHEROO_ON; }
-#endif
-
 #endif /* _DRM_OS_FREEBSD_H_ */
diff --git a/drivers/gpu/drm/i915/display/intel_fbdev.c b/drivers/gpu/drm/i915/display/intel_fbdev.c
index cde5baf99e50..16b155acd7e5 100644
--- a/drivers/gpu/drm/i915/display/intel_fbdev.c
+++ b/drivers/gpu/drm/i915/display/intel_fbdev.c
@@ -239,11 +239,12 @@ static int intelfb_create(struct drm_fb_helper *helper,
 	 * driver stopped setting them when it got rid of its specific
 	 * framebuffer initialization to use the generic drm_fb_helper code.
 	 *
-	 * We can't do this in register_framebuffer() anymore because the
-	 * values passed to register_fictitious_range() below are unavailable
-	 * from a generic structure set by both drivers.
+	 * To keep doing this in register_framebuffer() the values are passed
+	 * to register_fictitious_range() in additional FreeBSD-specific fields
+	 * of drm_driver structure.
 	 */
-	register_fictitious_range(info->fix.smem_start, info->fix.smem_len);
+	dev->aperture_base = info->fix.smem_start;
+	dev->aperture_size = info->fix.smem_len;
 #endif
 
 	drm_fb_helper_fill_info(info, &ifbdev->helper, sizes);
@@ -297,12 +298,6 @@ static void intel_fbdev_destroy(struct intel_fbdev *ifbdev)
 	 * trying to rectify all the possible error paths leading here.
 	 */
 
-#ifdef __FreeBSD__
-	unregister_fictitious_range(
-		ifbdev->helper.info->fix.smem_start,
-		ifbdev->helper.info->fix.smem_len);
-#endif
-
 	drm_fb_helper_fini(&ifbdev->helper);
 
 	if (ifbdev->vma)
diff --git a/drivers/gpu/drm/linux_fb.c b/drivers/gpu/drm/linux_fb.c
index 2aad76ab1540..331256c973aa 100644
--- a/drivers/gpu/drm/linux_fb.c
+++ b/drivers/gpu/drm/linux_fb.c
@@ -24,11 +24,6 @@
  *
  */
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#undef fb_info
-
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/kernel.h>
@@ -41,11 +36,11 @@ __FBSDID("$FreeBSD$");
 #include <dev/vt/vt.h>
 #include "vt_drmfb.h"
 
-#include <drm/drm_fb_helper.h>
+#include <vm/vm.h>
+#include <vm/vm_phys.h>
+
 #include <linux/fb.h>
 #include <video/cmdline.h>
-#undef fb_info
-#include <drm/drm_os_freebsd.h>
 
 MALLOC_DEFINE(LKPI_FB_MEM, "fb_kms", "FB KMS Data Structures");
 
@@ -57,7 +52,7 @@ extern struct vt_device *main_vd;
 static int __unregister_framebuffer(struct linux_fb_info *fb_info);
 
 void
-vt_freeze_main_vd(struct apertures_struct *a)
+vt_freeze_main_vd(unsigned long base, unsigned long size)
 {
 	struct fb_info *fb;
 	int i;
@@ -72,18 +67,8 @@ vt_freeze_main_vd(struct apertures_struct *a)
 	    || strcmp(main_vd->vd_driver->vd_name, "drmfb") == 0)) {
 		fb = main_vd->vd_softc;
 
-		for (i = 0; i < a->count; i++) {
-			if (fb->fb_pbase == a->ranges[i].base) {
-				overlap = true;
-				break;
-			}
-			if ((fb->fb_pbase > a->ranges[i].base) &&
-			    (fb->fb_pbase < (a->ranges[i].base + a->ranges[i].size))) {
-				overlap = true;
-				break;
-			}
-		}
-		if (overlap == true)
+		if (fb->fb_pbase == base ||
+		    ((fb->fb_pbase > base) && (fb->fb_pbase < (base + size))))
 			fb->fb_flags |= FB_FLAG_NOWRITE;
 	}
 }
@@ -145,17 +130,16 @@ framebuffer_release(struct linux_fb_info *info)
 {
 	if (info == NULL)
 		return;
-	kfree(info->apertures);
 	free(info, LKPI_FB_MEM);
 }
 
 int
-remove_conflicting_framebuffers(struct apertures_struct *a,
+remove_conflicting_framebuffers(resource_size_t base, resource_size_t size,
 				const char *name, bool primary)
 {
 
 	sx_xlock(&linux_fb_mtx);
-	vt_freeze_main_vd(a);
+	vt_freeze_main_vd(base, size);
 	sx_xunlock(&linux_fb_mtx);
 	return (0);
 }
@@ -164,31 +148,20 @@ remove_conflicting_framebuffers(struct apertures_struct *a,
 int
 remove_conflicting_pci_framebuffers(struct pci_dev *pdev, const char *name)
 {
-	struct apertures_struct *ap;
+	unsigned long base, size;
 	bool primary = false;
-	int err, idx, bar;
-
-	for (idx = 0, bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
-		if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM))
-			continue;
-		idx++;
-	}
-
-	ap = alloc_apertures(idx);
-	if (!ap)
-		return -ENOMEM;
+	int bar;
 
-	for (idx = 0, bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
+	sx_xlock(&linux_fb_mtx);
+	for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 		if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM))
 			continue;
-		ap->ranges[idx].base = pci_resource_start(pdev, bar);
-		ap->ranges[idx].size = pci_resource_len(pdev, bar);
-		idx++;
+		base = pci_resource_start(pdev, bar);
+		size = pci_resource_len(pdev, bar);
+		vt_freeze_main_vd(base, size);
 	}
-	sx_xlock(&linux_fb_mtx);
-	vt_freeze_main_vd(ap);
 	sx_xunlock(&linux_fb_mtx);
-	kfree(ap);
+
 	return (0);
 }
 
@@ -196,10 +169,21 @@ static int
 __register_framebuffer(struct linux_fb_info *fb_info)
 {
 	int i, err;
-	struct drm_fb_helper *fb_helper;
 
-	fb_helper = (struct drm_fb_helper *)fb_info->fbio.fb_priv;
-	fb_info->fb_bsddev = fb_helper->dev->dev->bsddev;
+	MPASS(fb_info->aperture_base != 0);
+	MPASS(fb_info->aperture_size != 0);
+
+	vt_freeze_main_vd(fb_info->aperture_base, fb_info->aperture_size);
+
+	err = vm_phys_fictitious_reg_range(fb_info->aperture_base,
+	    fb_info->aperture_base + fb_info->aperture_size,
+#ifdef VM_MEMATTR_WRITE_COMBINING
+	    VM_MEMATTR_WRITE_COMBINING);
+#else
+	    VM_MEMATTR_UNCACHEABLE);
+#endif
+	MPASS(err == 0);
+
 	fb_info->fbio.fb_video_dev = device_get_parent(fb_info->fb_bsddev);
 	fb_info->fbio.fb_name = device_get_nameunit(fb_info->fb_bsddev);
 
@@ -269,9 +253,14 @@ __unregister_framebuffer(struct linux_fb_info *fb_info)
 		fb_info->fbio.fb_fbd_dev = NULL;
 	}
 
+	vm_phys_fictitious_unreg_range(fb_info->aperture_base,
+	    fb_info->aperture_base + fb_info->aperture_size);
+
 	if (fb_info->fbops->fb_destroy)
 		fb_info->fbops->fb_destroy(fb_info);
 
+	vt_unfreeze_main_vd();
+
 	return 0;
 }
 
@@ -389,21 +378,21 @@ void
 cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image)
 {
 	uint32_t x, y, width, height, xi, yi;
-	uint32_t bytes_per_img_line, bit, byte, color;
+	uint32_t bytes_per_img_line, bit, byte, color, line;
 
 	if (info->fbio.fb_flags & FB_FLAG_NOWRITE)
 		return;
 
 	KASSERT(
-	    (image->depth == 1),
+	    (image->depth == 1 || image->depth == 32),
 	    ("`image->depth=%u` is unsupported in cfb_imageblit()",
 	     image->depth));
 
-	bytes_per_img_line = (image->width + 7) / 8;
+	bytes_per_img_line = (image->width * image->depth + 7) / 8;
 
 	x = image->dx;
 	y = image->dy;
-	width = image->width;
+	width = image->vt_width == 0 ? image->width : image->vt_width;
 	height = image->height;
 
 	if (x + width > info->var.xres) {
@@ -417,66 +406,33 @@ cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image)
 		height = info->var.yres - y;
 	}
 
-	if (image->mask == NULL) {
-		for (yi = 0; yi < height; ++yi) {
-			for (xi = 0; xi < width; ++xi) {
-				byte = yi * bytes_per_img_line + xi / 8;
-				bit = 0x80 >> (xi % 8);
+	for (yi = 0, line = 0; yi < height; ++yi, line += bytes_per_img_line) {
+		for (xi = 0; xi < width; ++xi) {
+			switch (image->depth) {
+			case 32:
+				byte = line + (xi << 2);
+				color = ((uint8_t)image->data[byte] << 16) |
+					((uint8_t)image->data[byte + 1] << 8) |
+					((uint8_t)image->data[byte + 2]) |
+					((uint8_t)image->data[byte + 3] << 24);
+				break;
+			case 1:
+				byte = line + (xi >> 3);
+				bit = 0x80 >> (xi & 0x07);
+				if (image->mask != NULL &&
+				    (image->mask[byte] & bit) == 0)
+					continue;
 				color = image->data[byte] & bit ?
 				    image->fg_color : image->bg_color;
-
-				fb_setpixel(info, x + xi, y + yi, color);
-			}
-		}
-	} else {
-		for (yi = 0; yi < height; ++yi) {
-			for (xi = 0; xi < width; ++xi) {
-				byte = yi * bytes_per_img_line + xi / 8;
-				bit = 0x80 >> (xi % 8);
-				if (image->mask[byte] & bit) {
-					color = image->fg_color;
-
-					fb_setpixel(info, x + xi, y + yi, color);
-				}
+				break;
+			default:
+				break;
 			}
+			fb_setpixel(info, x + xi, y + yi, color);
 		}
 	}
 }
 
-void
-sys_fillrect(struct linux_fb_info *info, const struct fb_fillrect *rect)
-{
-	cfb_fillrect(info, rect);
-}
-
-void
-sys_copyarea(struct linux_fb_info *info, const struct fb_copyarea *area)
-{
-	cfb_copyarea(info, area);
-}
-
-void
-sys_imageblit(struct linux_fb_info *info, const struct fb_image *image)
-{
-	cfb_imageblit(info, image);
-}
-
-ssize_t
-fb_sys_read(struct linux_fb_info *info, char __user *buf,
-    size_t count, loff_t *ppos)
-{
-	panic("fb_sys_read() not implemented");
-	return (0);
-}
-
-ssize_t
-fb_sys_write(struct linux_fb_info *info, const char __user *buf,
-    size_t count, loff_t *ppos)
-{
-	panic("fb_sys_write() not implemented");
-	return (0);
-}
-
 ssize_t
 fb_io_read(struct linux_fb_info *info, char __user *buf,
     size_t count, loff_t *ppos)
diff --git a/drivers/gpu/drm/radeon/radeon_fbdev.c b/drivers/gpu/drm/radeon/radeon_fbdev.c
index 9f43332e5a2b..e699a15a1fb1 100644
--- a/drivers/gpu/drm/radeon/radeon_fbdev.c
+++ b/drivers/gpu/drm/radeon/radeon_fbdev.c
@@ -177,11 +177,6 @@ static void radeon_fbdev_fb_destroy(struct fb_info *info)
 	struct drm_framebuffer *fb = fb_helper->fb;
 	struct drm_gem_object *gobj = drm_gem_fb_get_obj(fb, 0);
 
-#ifdef __FreeBSD__
-	struct radeon_device *rdev = fb_helper->dev->dev_private;
-	unregister_fictitious_range(rdev->mc.aper_base, rdev->mc.aper_size);
-#endif
-
 	drm_fb_helper_fini(fb_helper);
 
 	drm_framebuffer_unregister_private(fb);
@@ -284,11 +279,12 @@ static int radeon_fbdev_fb_helper_fb_probe(struct drm_fb_helper *fb_helper,
 	 * driver stopped setting them when it got rid of its specific
 	 * framebuffer initialization to use the generic drm_fb_helper code.
 	 *
-	 * We can't do this in register_framebuffer() anymore because the
-	 * values passed to register_fictitious_range() below are unavailable
-	 * from a generic structure set by both drivers.
+	 * To keep doing this in register_framebuffer() the values are passed
+	 * to register_fictitious_range() in additional FreeBSD-specific fields
+	 * of drm_driver structure.
 	 */
-	register_fictitious_range(rdev->mc.aper_base, rdev->mc.aper_size);
+	rdev->ddev->aperture_base = rdev->mc.aper_base;
+	rdev->ddev->aperture_size = rdev->mc.aper_size;
 #endif
 
 	/* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
diff --git a/drivers/gpu/drm/vt_drmfb.c b/drivers/gpu/drm/vt_drmfb.c
index 12e834a345be..440a0d8a0c7f 100644
--- a/drivers/gpu/drm/vt_drmfb.c
+++ b/drivers/gpu/drm/vt_drmfb.c
@@ -31,9 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
 #include <sys/reboot.h>
 #include <sys/fbio.h>
 #include <dev/vt/vt.h>
@@ -42,8 +39,6 @@ __FBSDID("$FreeBSD$");
 
 #include <linux/fb.h>
 
-#include <drm/drm_fb_helper.h>
-
 /*
  * `drm_fb_helper.h` redefines `fb_info` to be `linux_fb_info` to manage the
  * name conflict between the Linux and FreeBSD structures, while avoiding a
@@ -54,17 +49,21 @@ __FBSDID("$FreeBSD$");
  */
 #undef	fb_info
 
-#include <drm/drm_os_freebsd.h>
-
 #include "vt_drmfb.h"
 
-#define	to_drm_fb_helper(fbio) ((struct drm_fb_helper *)fbio->fb_priv)
-#define	to_linux_fb_info(fbio) (to_drm_fb_helper(fbio)->info)
+#define	to_linux_fb_info(f)	container_of(f, struct linux_fb_info, fbio);
+
+/*
+ * skip_ddb is controlled via sysctls in drm_os_freebsd.c in drm.ko
+ * TODO: Move these sysctl definitions here.
+ */
+int skip_ddb = 0;
 
 vd_init_t		vt_drmfb_init;
 vd_fini_t		vt_drmfb_fini;
 vd_blank_t		vt_drmfb_blank;
 vd_bitblt_bmp_t		vt_drmfb_bitblt_bitmap;
+vd_bitblt_argb_t	vt_drmfb_bitblt_argb;
 vd_drawrect_t		vt_drmfb_drawrect;
 vd_setpixel_t		vt_drmfb_setpixel;
 vd_invalidate_text_t	vt_drmfb_invalidate_text;
@@ -85,6 +84,7 @@ static struct vt_driver vt_drmfb_driver = {
 	 * `vt_drmfb_bitblt_bitmap()` may sleep.
 	 */
 	.vd_bitblt_bmp = vt_drmfb_bitblt_bitmap,
+	.vd_bitblt_argb = vt_drmfb_bitblt_argb,
 	.vd_drawrect = vt_drmfb_drawrect,
 	.vd_setpixel = vt_drmfb_setpixel,
 	.vd_invalidate_text = vt_drmfb_invalidate_text,
@@ -172,6 +172,7 @@ vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
 	struct fb_info *fbio;
 	struct linux_fb_info *info;
 	struct fb_image image;
+	uint32_t vt_width;
 
 	fbio = vd->vd_softc;
 	info = to_linux_fb_info(fbio);
@@ -184,10 +185,11 @@ vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
 			return;
 		height = vw->vw_draw_area.tr_end.tp_row - y;
 	}
+	vt_width = width;
 	if (x + width > vw->vw_draw_area.tr_end.tp_col) {
 		if (x >= vw->vw_draw_area.tr_end.tp_col)
 			return;
-		width = vw->vw_draw_area.tr_end.tp_col - x;
+		vt_width = vw->vw_draw_area.tr_end.tp_col - x;
 	}
 
 	image.dx = x;
@@ -199,6 +201,7 @@ vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
 	image.depth = 1;
 	image.data = pattern;
 	image.mask = mask; // Specific to FreeBSD to display the mouse pointer.
+	image.vt_width = vt_width; // FreeBSD. Stores truncated width.
 
 	if (!kdb_active && !KERNEL_PANICKED())
 		linux_set_current(curthread);
@@ -206,6 +209,48 @@ vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
 	info->fbops->fb_imageblit(info, &image);
 }
 
+int
+vt_drmfb_bitblt_argb(struct vt_device *vd, const struct vt_window *vw,
+    const uint8_t *argb,
+    unsigned int width, unsigned int height,
+    unsigned int x, unsigned int y)
+{
+	struct fb_info *fbio;
+	struct linux_fb_info *info;
+	struct fb_image image;
+	uint32_t vt_width;
+
+	fbio = vd->vd_softc;
+	info = to_linux_fb_info(fbio);
+	if (info->fbops->fb_imageblit == NULL)
+		return (ENOTSUP);
+
+	/* Bound by right and bottom edges. */
+	if (y + height > vw->vw_draw_area.tr_end.tp_row) {
+		if (y >= vw->vw_draw_area.tr_end.tp_row)
+			return (EINVAL);
+		height = vw->vw_draw_area.tr_end.tp_row - y;
+	}
+	vt_width = width;
+	if (x + width > vw->vw_draw_area.tr_end.tp_col) {
+		if (x >= vw->vw_draw_area.tr_end.tp_col)
+			return (EINVAL);
+		vt_width = vw->vw_draw_area.tr_end.tp_col - x;
+	}
+
+	image.dx = x;
+	image.dy = y;
+	image.width = width;
+	image.height = height;
+	image.depth = 32;
+	image.data = argb;
+	image.vt_width = vt_width; // FreeBSD. Stores truncated width.
+
+	info->fbops->fb_imageblit(info, &image);
+
+	return (0);
+}
+
 void
 vt_drmfb_postswitch(struct vt_device *vd)
 {
diff --git a/drivers/gpu/drm/vt_drmfb.h b/drivers/gpu/drm/vt_drmfb.h
index f054883f71f4..eb173fd38ce0 100644
--- a/drivers/gpu/drm/vt_drmfb.h
+++ b/drivers/gpu/drm/vt_drmfb.h
@@ -35,6 +35,12 @@
 
 #ifndef _DEV_VT_HW_FB_VT_DRMFB_H_
 #define	_DEV_VT_HW_FB_VT_DRMFB_H_
+
+struct fb_info;
+struct vt_device;
+
+extern int skip_ddb;
+
 /* Generic framebuffer interface call vt_drmfb_attach to init VT(9) */
 int vt_drmfb_attach(struct fb_info *info);
 void vt_drmfb_resume(struct vt_device *vd);
diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h
index c4d0cac9809a..89a3271a7ada 100644
--- a/include/drm/drm_device.h
+++ b/include/drm/drm_device.h
@@ -310,6 +310,8 @@ struct drm_device {
 	void *sysctl_private;
 	char busid_str[128];
 	int modesetting;
+	resource_size_t aperture_base;
+	resource_size_t aperture_size;
 /* FIXME: Should be defined in linux/mmzone.h and include linux/mmzone.h in the
  * correct headers, such as gfp.h. */
 #define	MAX_ORDER 11
diff --git a/linuxkpi/bsd/include/uapi/linux/fb.h b/linuxkpi/bsd/include/uapi/linux/fb.h
index 4498c3fa4f53..3c311f11b192 100644
--- a/linuxkpi/bsd/include/uapi/linux/fb.h
+++ b/linuxkpi/bsd/include/uapi/linux/fb.h
@@ -192,6 +192,7 @@ struct fb_image {
 	struct fb_cmap cmap;
 #ifdef __FreeBSD__
 	const char *mask;
+	uint32_t vt_width;
 #endif
 };
 
diff --git a/linuxkpi/gplv2/include/linux/fb.h b/linuxkpi/gplv2/include/linux/fb.h
index ad25d2cbfaa9..3abfb1adc39e 100644
--- a/linuxkpi/gplv2/include/linux/fb.h
+++ b/linuxkpi/gplv2/include/linux/fb.h
@@ -132,45 +132,29 @@ struct linux_fb_info {
 	u32 state;			/* Hardware state i.e suspend */
 	/* From here on everything is device dependent */
 	void *par;
-	/* we need the PCI or similar aperture base/size not
-	   smem_start/size as smem_start may just be an object
-	   allocated inside the aperture so may not actually overlap */
-	struct apertures_struct {
-		unsigned int count;
-		struct aperture {
-			resource_size_t base;
-			resource_size_t size;
-		} ranges[0];
-	} *apertures;
-
 	bool skip_vt_switch; /* no VT switch on suspend/resume required */
 
 #ifdef __FreeBSD__
 	struct fb_info fbio;
 	device_t fb_bsddev;
 	struct task fb_mode_task;
+
+	/* i915 fictitious pages area */
+	resource_size_t aperture_base;
+	resource_size_t aperture_size;
 #endif
 } __aligned(sizeof(long));
 
-static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
-	struct apertures_struct *a = kzalloc(sizeof(struct apertures_struct)
-			+ max_num * sizeof(struct aperture), GFP_KERNEL);
-	if (!a)
-		return NULL;
-	a->count = max_num;
-	return a;
-}
-
     /*
      *  `Generic' versions of the frame buffer device operations
      */
 
-extern void cfb_fillrect(struct linux_fb_info *info, const struct fb_fillrect *rect);
-extern void cfb_copyarea(struct linux_fb_info *info, const struct fb_copyarea *area);
-extern void cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image);
-extern ssize_t fb_io_read(struct linux_fb_info *info, char __user *buf,
+void cfb_fillrect(struct linux_fb_info *info, const struct fb_fillrect *rect);
+void cfb_copyarea(struct linux_fb_info *info, const struct fb_copyarea *area);
+void cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image);
+ssize_t fb_io_read(struct linux_fb_info *info, char __user *buf,
     size_t count, loff_t *ppos);
-extern ssize_t fb_io_write(struct linux_fb_info *info, const char __user *buf,
+ssize_t fb_io_write(struct linux_fb_info *info, const char __user *buf,
     size_t count, loff_t *ppos);
 
 /*
@@ -197,100 +181,99 @@ extern ssize_t fb_io_write(struct linux_fb_info *info, const char __user *buf,
 /*
  * Drawing operations where framebuffer is in system RAM
  */
-extern void sys_fillrect(struct linux_fb_info *info, const struct fb_fillrect *rect);
-extern void sys_copyarea(struct linux_fb_info *info, const struct fb_copyarea *area);
-extern void sys_imageblit(struct linux_fb_info *info, const struct fb_image *image);
-extern ssize_t fb_sys_read(struct linux_fb_info *info, char __user *buf,
-			   size_t count, loff_t *ppos);
-extern ssize_t fb_sys_write(struct linux_fb_info *info, const char __user *buf,
-			    size_t count, loff_t *ppos);
-extern int fb_deferred_io_mmap(struct linux_fb_info *info, struct vm_area_struct *vma);
+static inline void
+sys_fillrect(struct linux_fb_info *info, const struct fb_fillrect *rect)
+{
+	cfb_fillrect(info, rect);
+}
+
+static inline void
+sys_copyarea(struct linux_fb_info *info, const struct fb_copyarea *area)
+{
+	cfb_copyarea(info, area);
+}
+
+static inline void
+sys_imageblit(struct linux_fb_info *info, const struct fb_image *image)
+{
+	cfb_imageblit(info, image);
+}
+
+static inline ssize_t
+fb_sys_read(struct linux_fb_info *info, char __user *buf, size_t count,
+    loff_t *ppos)
+{
+	return (fb_io_read(info, buf, count, ppos));
+}
+
+static inline ssize_t
+fb_sys_write(struct linux_fb_info *info, const char __user *buf, size_t count,
+    loff_t *ppos)
+{
+	return (fb_io_write(info, buf, count, ppos));
+}
+
+int fb_deferred_io_mmap(struct linux_fb_info *info,
+    struct vm_area_struct *vma);
 
 /*
  * Generate callbacks for deferred I/O
  */
 
-#define __FB_GEN_DEFAULT_DEFERRED_OPS_RDWR(__prefix, __damage_range, __mode) \
-	static ssize_t __prefix ## _defio_read(struct fb_info *info, char __user *buf, \
-					       size_t count, loff_t *ppos) \
-	{ \
-		return fb_ ## __mode ## _read(info, buf, count, ppos); \
-	} \
-	static ssize_t __prefix ## _defio_write(struct fb_info *info, const char __user *buf, \
-						size_t count, loff_t *ppos) \
-	{ \
-		unsigned long offset = *ppos; \
-		ssize_t ret = fb_ ## __mode ## _write(info, buf, count, ppos); \
-		if (ret > 0) \
-			__damage_range(info, offset, ret); \
-		return ret; \
+#define FB_GEN_DEFAULT_DEFERRED_IOMEM_OPS(_pfx, _range, _area)		\
+	static void							\
+	_pfx ## _fillrect(struct fb_info *fi, const struct fb_fillrect *fr) \
+	{								\
+		cfb_fillrect(fi, fr);					\
+		_area(fi, fr->dx, fr->dy, fr->width, fr->height);	\
+	}								\
+	static void							\
+	_pfx ## _copyarea(struct fb_info *fi, const struct fb_copyarea *fca) \
+	{								\
+		cfb_copyarea(fi, fca);					\
+		_area(fi, fca->dx, fca->dy, fca->width, fca->height);	\
+	}								\
+	static void							\
+	_pfx ## _imageblit(struct fb_info *fi, const struct fb_image *img) \
+	{								\
+		cfb_imageblit(fi, img);					\
+		_area(fi, img->dx, img->dy, img->width, img->height);	\
 	}
 
-#define __FB_GEN_DEFAULT_DEFERRED_OPS_DRAW(__prefix, __damage_area, __mode) \
-	static void __prefix ## _defio_fillrect(struct fb_info *info, \
-						const struct fb_fillrect *rect) \
-	{ \
-		__mode ## _fillrect(info, rect); \
-		__damage_area(info, rect->dx, rect->dy, rect->width, rect->height); \
-	} \
-	static void __prefix ## _defio_copyarea(struct fb_info *info, \
-						const struct fb_copyarea *area) \
-	{ \
-		__mode ## _copyarea(info, area); \
-		__damage_area(info, area->dx, area->dy, area->width, area->height); \
-	} \
-	static void __prefix ## _defio_imageblit(struct fb_info *info, \
-						 const struct fb_image *image) \
-	{ \
-		__mode ## _imageblit(info, image); \
-		__damage_area(info, image->dx, image->dy, image->width, image->height); \
-	}
-
-#define FB_GEN_DEFAULT_DEFERRED_IOMEM_OPS(__prefix, __damage_range, __damage_area) \
-	__FB_GEN_DEFAULT_DEFERRED_OPS_RDWR(__prefix, __damage_range, io) \
-	__FB_GEN_DEFAULT_DEFERRED_OPS_DRAW(__prefix, __damage_area, cfb)
-
-#define FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS(__prefix, __damage_range, __damage_area) \
-	__FB_GEN_DEFAULT_DEFERRED_OPS_RDWR(__prefix, __damage_range, sys) \
-	__FB_GEN_DEFAULT_DEFERRED_OPS_DRAW(__prefix, __damage_area, sys)
+#define FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS(...) \
+	FB_GEN_DEFAULT_DEFERRED_IOMEM_OPS(__VA_ARGS__)
 
 /*
  * Initializes struct fb_ops for deferred I/O.
  */
 
-#define __FB_DEFAULT_DEFERRED_OPS_RDWR(__prefix) \
-	.fb_read	= __prefix ## _defio_read, \
-	.fb_write	= __prefix ## _defio_write
+#define __FB_DEFAULT_DEFERRED_OPS_RDWR(...)	\
+	.fb_read	= fb_io_read,		\
+	.fb_write	= fb_io_write
 
-#define __FB_DEFAULT_DEFERRED_OPS_DRAW(__prefix) \
-	.fb_fillrect	= __prefix ## _defio_fillrect, \
-	.fb_copyarea	= __prefix ## _defio_copyarea, \
-	.fb_imageblit	= __prefix ## _defio_imageblit
+#define __FB_DEFAULT_DEFERRED_OPS_DRAW(_pfx)	\
+	.fb_fillrect	= _pfx ## _fillrect,	\
+	.fb_copyarea	= _pfx ## _copyarea,	\
+	.fb_imageblit	= _pfx ## _imageblit
 
-#define __FB_DEFAULT_DEFERRED_OPS_MMAP(__prefix) \
+#define __FB_DEFAULT_DEFERRED_OPS_MMAP(...)	\
 	.fb_mmap	= fb_deferred_io_mmap
 
-#define FB_DEFAULT_DEFERRED_OPS(__prefix) \
-        __FB_DEFAULT_DEFERRED_OPS_RDWR(__prefix), \
-        __FB_DEFAULT_DEFERRED_OPS_DRAW(__prefix), \
-        __FB_DEFAULT_DEFERRED_OPS_MMAP(__prefix)
+#define FB_DEFAULT_DEFERRED_OPS(_pfx)		\
+	__FB_DEFAULT_DEFERRED_OPS_RDWR(),	\
+	__FB_DEFAULT_DEFERRED_OPS_DRAW(_pfx),	\
+	__FB_DEFAULT_DEFERRED_OPS_MMAP()
 
 
 int linux_register_framebuffer(struct linux_fb_info *fb_info);
 int linux_unregister_framebuffer(struct linux_fb_info *fb_info);
-int remove_conflicting_framebuffers(struct apertures_struct *a,
+int remove_conflicting_framebuffers(resource_size_t base, resource_size_t size,
 	const char *name, bool primary);
 int remove_conflicting_pci_framebuffers(struct pci_dev *pdev, const char *name);
 struct linux_fb_info *framebuffer_alloc(size_t size, struct device *dev);
 void framebuffer_release(struct linux_fb_info *info);
 #define	fb_set_suspend(x, y)	0
 
-static inline bool
-is_firmware_framebuffer(struct apertures_struct *a __unused)
-{
-	return false;
-}
-
 /* updated FreeBSD fb_info */
 int linux_fb_get_options(const char *name, char **option);
 #define	fb_get_options	linux_fb_get_options