diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 28586e46c604..202dd6e4dde2 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -4387,11 +4387,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(ddev, 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);
@@ -4604,10 +4605,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_to_drm(adev), 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_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index da9449b37291..acd0da34cf2f 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -46,11 +46,6 @@
 #include "drm_internal.h"
 #include "drm_crtc_internal.h"
 
-#ifdef __FreeBSD__
-#define register_framebuffer linux_register_framebuffer
-#define unregister_framebuffer linux_unregister_framebuffer
-#endif
-
 static bool drm_fbdev_emulation = true;
 module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
 MODULE_PARM_DESC(fbdev_emulation,
@@ -1900,15 +1895,17 @@ __drm_fb_helper_initial_config_and_unlock(struct drm_fb_helper *fb_helper)
 	info = fb_helper->info;
 	info->var.pixclock = 0;
 
-#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_fbdev_ttm.c b/drivers/gpu/drm/drm_fbdev_ttm.c
index 48e276a331e2..45021990218f 100644
--- a/drivers/gpu/drm/drm_fbdev_ttm.c
+++ b/drivers/gpu/drm/drm_fbdev_ttm.c
@@ -46,9 +46,7 @@ static void drm_fbdev_ttm_fb_destroy(struct fb_info *info)
 	if (!fb_helper->dev)
 		return;
 
-#ifdef __linux__
 	fb_deferred_io_cleanup(info);
-#endif
 	drm_fb_helper_fini(fb_helper);
 	vfree(shadow);
 	drm_client_framebuffer_delete(fb_helper->buffer);
diff --git a/drivers/gpu/drm/drm_os_freebsd.c b/drivers/gpu/drm/drm_os_freebsd.c
index b7f6bba44010..6662cbcf8696 100644
--- a/drivers/gpu/drm/drm_os_freebsd.c
+++ b/drivers/gpu/drm/drm_os_freebsd.c
@@ -1,40 +1,25 @@
+#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 <linux/fb.h>	/* linuxkpi_skip_ddb */
 
 #include <drm/drm_device.h>
 #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
-
 MALLOC_DEFINE(DRM_MEM_DRIVER, "drm_driver", "DRM DRIVER Data Structures");
 
 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");
+SYSCTL_INT(_dev_drm, OID_AUTO, skip_ddb, CTLFLAG_RWTUN, &linuxkpi_skip_ddb, 0, "go straight to dumping core (compat)");
+SYSCTL_INT(_hw_dri, OID_AUTO, skip_ddb, CTLFLAG_RWTUN, &linuxkpi_skip_ddb, 0, "go straight to dumping core");
 #if defined(DRM_DEBUG_LOG_ALL)
 int drm_debug_persist = 1;
 #else
@@ -78,44 +63,6 @@ sysctl_pci_id(SYSCTL_HANDLER_ARGS)
 	return (sysctl_handle_string(oidp, buf, sizeof(buf), req));
 }
 
-int
-register_fictitious_range(struct drm_device *ddev, 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);
-
-	ddev->fictitious_range_registered = true;
-
-	return (ret);
-}
-
-void
-unregister_fictitious_range(struct drm_device *ddev, vm_paddr_t base, size_t size)
-{
-	if (ddev->fictitious_range_registered) {
-		vm_phys_fictitious_unreg_range(base, base + size);
-		vt_unfreeze_main_vd();
-	}
-}
-
 /* Framebuffer related code */
 
 int
@@ -182,13 +129,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 3ff742cad2bf..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,36 +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);
-
-struct drm_device;
-int register_fictitious_range(struct drm_device *ddev, vm_paddr_t start, vm_paddr_t end);
-void unregister_fictitious_range(struct drm_device *ddev, 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 f5bc2850cf58..56e5aa98b0cb 100644
--- a/drivers/gpu/drm/i915/display/intel_fbdev.c
+++ b/drivers/gpu/drm/i915/display/intel_fbdev.c
@@ -140,13 +140,6 @@ static void intel_fbdev_fb_destroy(struct fb_info *info)
 	struct drm_fb_helper *fb_helper = info->par;
 	struct intel_fbdev *ifbdev = container_of(fb_helper, struct intel_fbdev, helper);
 
-#ifdef __FreeBSD__
-	unregister_fictitious_range(
-		fb_helper->dev,
-		ifbdev->helper.info->fix.smem_start,
-		ifbdev->helper.info->fix.smem_len);
-#endif
-
 	drm_fb_helper_fini(&ifbdev->helper);
 
 	/*
@@ -270,11 +263,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(dev, 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);
diff --git a/drivers/gpu/drm/radeon/radeon_fbdev.c b/drivers/gpu/drm/radeon/radeon_fbdev.c
index 5ec0447cd666..5e7803b6d6cb 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(fb_helper->dev, 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(fb_helper->dev, 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.h b/drivers/gpu/drm/vt_drmfb.h
deleted file mode 100644
index f054883f71f4..000000000000
--- a/drivers/gpu/drm/vt_drmfb.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*-
- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
- *
- * Copyright (c) 2013 The FreeBSD Foundation
- * Copyright (c) 2023 Jean-Sébastien Pédron <dumbbell@FreeBSD.org>
- *
- * This initial software `sys/dev/vt/hw/vt_fb.h` was developed by Aleksandr
- * Rybalko under sponsorship from the FreeBSD Foundation.
- * This file is a copy of the initial file and is modified by Jean-Sébastien
- * Pédron.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef _DEV_VT_HW_FB_VT_DRMFB_H_
-#define	_DEV_VT_HW_FB_VT_DRMFB_H_
-/* 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);
-void vt_drmfb_suspend(struct vt_device *vd);
-int vt_drmfb_detach(struct fb_info *info);
-
-#endif /* _DEV_VT_HW_FB_VT_DRMFB_H_ */
diff --git a/drivers/video/aperture.c b/drivers/video/linux_aperture.c
similarity index 99%
rename from drivers/video/aperture.c
rename to drivers/video/linux_aperture.c
index 6a88dd8b64af..54173de08008 100644
--- a/drivers/video/aperture.c
+++ b/drivers/video/linux_aperture.c
@@ -244,6 +244,7 @@ int devm_aperture_acquire_for_platform_device(struct platform_device *pdev,
 }
 EXPORT_SYMBOL(devm_aperture_acquire_for_platform_device);
 
+#ifdef __linux__
 static void aperture_detach_devices(resource_size_t base, resource_size_t size)
 {
 	resource_size_t end = base + size;
@@ -293,9 +294,7 @@ int aperture_remove_conflicting_devices(resource_size_t base, resource_size_t si
 	 * ask for this, so let's assume that a real driver for the display
 	 * was already probed and prevent sysfb to register devices later.
 	 */
-#ifdef __linux__
 	sysfb_disable(NULL);
-#endif
 
 	aperture_detach_devices(base, size);
 
@@ -330,11 +329,7 @@ int __aperture_remove_legacy_vga_devices(struct pci_dev *pdev)
 	aperture_detach_devices(VGA_FB_PHYS_BASE, VGA_FB_PHYS_SIZE);
 
 	/* VGA textmode console */
-#ifdef __linux__
 	return vga_remove_vgacon(pdev);
-#elif defined(__FreeBSD__)
-	return 0;
-#endif
 }
 EXPORT_SYMBOL(__aperture_remove_legacy_vga_devices);
 
@@ -355,9 +350,7 @@ int aperture_remove_conflicting_pci_devices(struct pci_dev *pdev, const char *na
 	resource_size_t base, size;
 	int bar, ret = 0;
 
-#ifdef __linux__
 	sysfb_disable(&pdev->dev);
-#endif
 
 	for (bar = 0; bar < PCI_STD_NUM_BARS; ++bar) {
 		if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM))
@@ -379,4 +372,5 @@ int aperture_remove_conflicting_pci_devices(struct pci_dev *pdev, const char *na
 	return ret;
 
 }
+#endif
 EXPORT_SYMBOL(aperture_remove_conflicting_pci_devices);
diff --git a/drivers/video/cmdline.c b/drivers/video/linux_cmdline.c
similarity index 100%
rename from drivers/video/cmdline.c
rename to drivers/video/linux_cmdline.c
diff --git a/drivers/gpu/drm/linux_fb.c b/drivers/video/linux_fb.c
similarity index 72%
rename from drivers/gpu/drm/linux_fb.c
rename to drivers/video/linux_fb.c
index 10d34554ae23..e37b65dc07ac 100644
--- a/drivers/gpu/drm/linux_fb.c
+++ b/drivers/video/linux_fb.c
@@ -24,28 +24,23 @@
  *
  */
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#undef fb_info
-
 #include <sys/param.h>
-#include <sys/types.h>
 #include <sys/kernel.h>
+#include <sys/fbio.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
+#include <sys/reboot.h>
 #include <sys/systm.h>
 #include <sys/sx.h>
-#include <sys/fbio.h>
 
 #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/aperture.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");
 
@@ -56,12 +51,16 @@ 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)
+/*
+ * skip_ddb is controlled via sysctls in drm_os_freebsd.c in drm.ko
+ * TODO: Move these sysctl definitions here.
+ */
+int linuxkpi_skip_ddb = 0;
+
+static void
+vt_freeze_main_vd(unsigned long base, unsigned long size)
 {
 	struct fb_info *fb;
-	int i;
-	bool overlap = false;
 
 	if (main_vd && main_vd->vd_driver && main_vd->vd_softc &&
 	    /* For these, we know the softc (or its first field) is of type fb_info */
@@ -72,23 +71,13 @@ 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;
 	}
 }
 
-void
+static void
 vt_unfreeze_main_vd(void)
 {
 	struct fb_info *fb;
@@ -108,6 +97,41 @@ vt_restore_fbdev_mode(void *arg, int pending)
 	info->fbops->fb_set_par(info);
 }
 
+static int
+vt_kms_postswitch(void *arg)
+{
+	struct linux_fb_info *info = arg;
+
+	if (!kdb_active && !KERNEL_PANICKED()) {
+		taskqueue_enqueue(taskqueue_thread, &info->fb_mode_task);
+
+		/* XXX the VT_ACTIVATE IOCTL must be synchronous */
+		if (curthread->td_proc->p_pid != 0 &&
+		    taskqueue_member(taskqueue_thread, curthread) == 0)
+			taskqueue_drain(taskqueue_thread, &info->fb_mode_task);
+	} else {
+#ifdef DDB
+		db_trace_self_depth(10);
+		mdelay(1000);
+#endif
+		if (linuxkpi_skip_ddb) {
+			spinlock_enter();
+			doadump(false);
+			EVENTHANDLER_INVOKE(shutdown_final, RB_NOSYNC);
+		}
+
+		if (main_vd->vd_grabwindow != NULL) {
+			if (info->fbops->fb_debug_enter)
+				info->fbops->fb_debug_enter(info);
+		} else {
+			if (info->fbops->fb_debug_leave)
+				info->fbops->fb_debug_leave(info);
+		}
+	}
+
+	return (0);
+}
+
 static void
 fb_info_print(struct linux_fb_info *info)
 {
@@ -115,7 +139,7 @@ fb_info_print(struct linux_fb_info *info)
 	printf("height=%d width=%d depth=%d\n",
 	       info->var.yres, info->var.xres, info->var.bits_per_pixel);
 	printf("pbase=0x%lx vbase=0x%lx\n",
-	       info->fix.smem_start, info->screen_base);
+	       info->fix.smem_start, (unsigned long)info->screen_base);
 	printf("name=%s id=%s flags=0x%x stride=%d\n",
 	       info->fbio.fb_name, info->fix.id, info->fbio.fb_flags,
 	       info->fix.line_length);
@@ -125,13 +149,16 @@ fb_info_print(struct linux_fb_info *info)
 CTASSERT((sizeof(struct linux_fb_info) % sizeof(long)) == 0);
 
 struct linux_fb_info *
-framebuffer_alloc(size_t size, struct device *dev)
+linuxkpi_framebuffer_alloc(size_t size, struct device *dev)
 {
 	struct linux_fb_info *info;
 
 	info = malloc(sizeof(*info) + size, LKPI_FB_MEM, M_WAITOK | M_ZERO);
 	TASK_INIT(&info->fb_mode_task, 0, vt_restore_fbdev_mode, info);
 
+	info->fbio.fb_priv = info;
+	info->fbio.enter = &vt_kms_postswitch;
+
 	if (size)
 		info->par = info + 1;
 
@@ -141,53 +168,41 @@ framebuffer_alloc(size_t size, struct device *dev)
 }
 
 void
-framebuffer_release(struct linux_fb_info *info)
+linuxkpi_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,
-				const char *name, bool primary)
+aperture_remove_conflicting_devices(resource_size_t base,
+    resource_size_t size, const char *name)
 {
 
 	sx_xlock(&linux_fb_mtx);
-	vt_freeze_main_vd(a);
+	vt_freeze_main_vd(base, size);
 	sx_xunlock(&linux_fb_mtx);
 	return (0);
 }
 
-#define	PCI_STD_NUM_BARS	6
 int
-remove_conflicting_pci_framebuffers(struct pci_dev *pdev, const char *name)
+aperture_remove_conflicting_pci_devices(struct pci_dev *pdev,
+    const char *name)
 {
-	struct apertures_struct *ap;
-	int idx, bar;
+	unsigned long base, size;
+	int 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;
-
-	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);
 }
 
@@ -195,10 +210,23 @@ static int
 __register_framebuffer(struct linux_fb_info *fb_info)
 {
 	int 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;
+	bus_topo_assert();
+
+	vt_freeze_main_vd(fb_info->aperture_base, fb_info->aperture_size);
+
+	if (fb_info->aperture_base != 0 && fb_info->aperture_size != 0) {
+		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);
+	} else
+		device_printf(fb_info->fb_bsddev, "Aperture undefined\n");
+
 	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);
 
@@ -213,9 +241,6 @@ __register_framebuffer(struct linux_fb_info *fb_info)
 	fb_info->fbio.fb_size = fb_info->fix.smem_len;
 	fb_info->fbio.fb_vbase = (uintptr_t)fb_info->screen_base;
 
-	fb_info->fbio.fb_fbd_dev = device_add_child(fb_info->fb_bsddev, "fbd",
-				device_get_unit(fb_info->fb_bsddev));
-
 	/* tell vt_drmfb to initialize color map */
 	fb_info->fbio.fb_cmsize = 0;
 	if (fb_info->fbio.fb_bpp == 0) {
@@ -223,28 +248,24 @@ __register_framebuffer(struct linux_fb_info *fb_info)
 		    "fb_bpp not set, setting to 8\n");
 		fb_info->fbio.fb_bpp = 32;
 	}
-	if ((err = vt_drmfb_attach(&fb_info->fbio)) != 0) {
-		switch (err) {
-		case EEXIST:
-			device_printf(fb_info->fbio.fb_fbd_dev,
-			    "not attached to vt(4) console; "
-			    "another device has precedence (err=%d)\n",
-			    err);
-			err = 0;
-			break;
-		default:
-			device_printf(fb_info->fbio.fb_fbd_dev,
-			    "failed to attach to vt(4) console (err=%d)\n",
-			    err);
-		}
+
+	fb_info->fbio.fb_fbd_dev = device_add_child(fb_info->fb_bsddev, "fbd",
+	    DEVICE_UNIT_ANY);
+	if (fb_info->fbio.fb_fbd_dev == NULL)
+		return (-ENODEV);
+	device_set_ivars(fb_info->fbio.fb_fbd_dev, &fb_info->fbio);
+	if ((err = device_probe_and_attach(fb_info->fbio.fb_fbd_dev)) != 0) {
+		device_printf(fb_info->fbio.fb_fbd_dev,
+		    "failed to attach to vt(4) console (err=%d)\n", err);
 		return (-err);
 	}
 	fb_info_print(fb_info);
-	return 0;
+
+	return (0);
 }
 
 int
-linux_register_framebuffer(struct linux_fb_info *fb_info)
+linuxkpi_register_framebuffer(struct linux_fb_info *fb_info)
 {
 	int rc;
 
@@ -257,24 +278,27 @@ linux_register_framebuffer(struct linux_fb_info *fb_info)
 static int
 __unregister_framebuffer(struct linux_fb_info *fb_info)
 {
-
-	vt_drmfb_detach(&fb_info->fbio);
-
 	if (fb_info->fbio.fb_fbd_dev) {
-		mtx_lock(&Giant);
+		bus_topo_lock();
 		device_delete_child(fb_info->fb_bsddev, fb_info->fbio.fb_fbd_dev);
-		mtx_unlock(&Giant);
+		bus_topo_unlock();
 		fb_info->fbio.fb_fbd_dev = NULL;
 	}
 
+	if (fb_info->aperture_base != 0 && fb_info->aperture_size != 0)
+		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;
 }
 
 int
-linux_unregister_framebuffer(struct linux_fb_info *fb_info)
+linuxkpi_unregister_framebuffer(struct linux_fb_info *fb_info)
 {
 	int rc;
 
@@ -285,7 +309,7 @@ linux_unregister_framebuffer(struct linux_fb_info *fb_info)
 }
 
 int
-linux_fb_get_options(const char *connector_name, char **option)
+linuxkpi_fb_get_options(const char *connector_name, char **option)
 {
 	*option = __DECONST(char *, video_get_options(connector_name));
 	return (*option != NULL ? 0 : -ENOENT);
@@ -366,7 +390,8 @@ fb_setpixel(struct linux_fb_info *info, uint32_t x, uint32_t y,
 }
 
 void
-cfb_fillrect(struct linux_fb_info *info, const struct fb_fillrect *rect)
+linuxkpi_cfb_fillrect(struct linux_fb_info *info,
+    const struct fb_fillrect *rect)
 {
 	uint32_t x, y;
 
@@ -385,13 +410,15 @@ 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)
+linuxkpi_cfb_copyarea(struct linux_fb_info *info,
+    const struct fb_copyarea *area)
 {
 	panic("cfb_copyarea() not implemented");
 }
 
 void
-cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image)
+linuxkpi_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, line;
@@ -408,7 +435,7 @@ cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image)
 
 	x = image->dx;
 	y = image->dy;
-	width = image->vt_width == 0 ? image->width : image->vt_width;
+	width = image->width;
 	height = image->height;
 
 	if (x + width > info->var.xres) {
@@ -449,42 +476,8 @@ cfb_imageblit(struct linux_fb_info *info, const struct fb_image *image)
 	}
 }
 
-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,
+linuxkpi_fb_io_read(struct linux_fb_info *info, char __user *buf,
     size_t count, loff_t *ppos)
 {
 	panic("fb_io_read() not implemented");
@@ -492,7 +485,7 @@ fb_io_read(struct linux_fb_info *info, char __user *buf,
 }
 
 ssize_t
-fb_io_write(struct linux_fb_info *info, const char __user *buf,
+linuxkpi_fb_io_write(struct linux_fb_info *info, const char __user *buf,
     size_t count, loff_t *ppos)
 {
 	panic("fb_io_write() not implemented");
@@ -500,7 +493,8 @@ fb_io_write(struct linux_fb_info *info, const char __user *buf,
 }
 
 int
-fb_deferred_io_mmap(struct linux_fb_info *info, struct vm_area_struct *vma)
+linuxkpi_fb_deferred_io_mmap(struct linux_fb_info *info,
+    struct vm_area_struct *vma)
 {
 	panic("fb_deferred_io_mmap() not implemented");
 	return (0);
diff --git a/drivers/video/hdmi.c b/drivers/video/linux_hdmi.c
similarity index 99%
rename from drivers/video/hdmi.c
rename to drivers/video/linux_hdmi.c
index ba301f3f4951..76905f659baa 100644
--- a/drivers/video/hdmi.c
+++ b/drivers/video/linux_hdmi.c
@@ -21,7 +21,9 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
+#ifdef __linux__
 #include <drm/display/drm_dp.h>
+#endif
 #include <linux/bitops.h>
 #include <linux/bug.h>
 #include <linux/errno.h>
@@ -486,6 +488,7 @@ ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame,
 }
 EXPORT_SYMBOL(hdmi_audio_infoframe_pack);
 
+#ifdef __linux__
 /**
  * hdmi_audio_infoframe_pack_for_dp - Pack a HDMI Audio infoframe for DisplayPort
  *
@@ -522,6 +525,7 @@ hdmi_audio_infoframe_pack_for_dp(const struct hdmi_audio_infoframe *frame,
 	return frame->length + 4;
 }
 EXPORT_SYMBOL(hdmi_audio_infoframe_pack_for_dp);
+#endif
 
 /**
  * hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe
diff --git a/drivers/gpu/drm/vt_drmfb.c b/drivers/video/vt_drmfb.c
similarity index 59%
rename from drivers/gpu/drm/vt_drmfb.c
rename to drivers/video/vt_drmfb.c
index b4b143031af9..8e0b7c477917 100644
--- a/drivers/gpu/drm/vt_drmfb.c
+++ b/drivers/video/vt_drmfb.c
@@ -31,18 +31,19 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/reboot.h>
+#include <sys/param.h>
+#include <sys/systm.h>
 #include <sys/fbio.h>
+#include <sys/module.h>
+#include <sys/reboot.h>
+
 #include <dev/vt/vt.h>
 #include <dev/vt/hw/fb/vt_fb.h>
 #include <dev/vt/colors/vt_termcolors.h>
 
 #include <linux/fb.h>
 
-#include <drm/drm_fb_helper.h>
+#include "fb_if.h"
 
 /*
  * `drm_fb_helper.h` redefines `fb_info` to be `linux_fb_info` to manage the
@@ -54,27 +55,17 @@ __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);
 
-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;
-vd_postswitch_t		vt_drmfb_postswitch;
+static vd_blank_t		vt_drmfb_blank;
+static vd_bitblt_bmp_t		vt_drmfb_bitblt_bitmap;
+static vd_bitblt_argb_t		vt_drmfb_bitblt_argb;
+static vd_drawrect_t		vt_drmfb_drawrect;
+static vd_setpixel_t		vt_drmfb_setpixel;
+static vd_invalidate_text_t	vt_drmfb_invalidate_text;
 
 static struct vt_driver vt_drmfb_driver = {
 	.vd_name = "drmfb",
-	.vd_init = vt_drmfb_init,
-	.vd_fini = vt_drmfb_fini,
 	.vd_blank = vt_drmfb_blank,
 	/*
 	 * .vd_bitblt_text is unset.
@@ -90,12 +81,16 @@ static struct vt_driver vt_drmfb_driver = {
 	.vd_drawrect = vt_drmfb_drawrect,
 	.vd_setpixel = vt_drmfb_setpixel,
 	.vd_invalidate_text = vt_drmfb_invalidate_text,
-	.vd_postswitch = vt_drmfb_postswitch,
 	.vd_priority = VD_PRIORITY_GENERIC+20,
-	.vd_suspend = vt_drmfb_suspend,
-	.vd_resume = vt_drmfb_resume,
+
+	/* Use generic implementation */
+	.vd_suspend = vt_suspend,
+	.vd_resume = vt_resume,
 
 	/* Use vt_fb implementation */
+	.vd_init = vt_fb_init,
+	.vd_fini = vt_fb_fini,
+	.vd_postswitch = vt_fb_postswitch,
 	.vd_fb_ioctl = vt_fb_ioctl,
 	.vd_fb_mmap = vt_fb_mmap,
 
@@ -104,13 +99,13 @@ static struct vt_driver vt_drmfb_driver = {
 
 VT_DRIVER_DECLARE(vt_drmfb, vt_drmfb_driver);
 
-void
+static void
 vt_drmfb_setpixel(struct vt_device *vd, int x, int y, term_color_t color)
 {
 	vt_drmfb_drawrect(vd, x, y, x, y, 1, color);
 }
 
-void
+static void
 vt_drmfb_drawrect(
     struct vt_device *vd,
     int x1, int y1, int x2, int y2, int fill,
@@ -147,7 +142,7 @@ vt_drmfb_drawrect(
 	info->fbops->fb_fillrect(info, &rect);
 }
 
-void
+static void
 vt_drmfb_blank(struct vt_device *vd, term_color_t color)
 {
 	struct fb_info *fbio;
@@ -165,7 +160,7 @@ vt_drmfb_blank(struct vt_device *vd, term_color_t color)
 	vt_drmfb_drawrect(vd, x1, y1, x2, y2, 1, color);
 }
 
-void
+static void
 vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
     const uint8_t *pattern, const uint8_t *mask,
     unsigned int width, unsigned int height,
@@ -174,7 +169,6 @@ 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);
@@ -182,17 +176,10 @@ vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
 		return;
 
 	/* 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;
-		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;
-		vt_width = vw->vw_draw_area.tr_end.tp_col - x;
-	}
+	if (y >= vw->vw_draw_area.tr_end.tp_row)
+		return;
+	if (x >= vw->vw_draw_area.tr_end.tp_col)
+		return;
 
 	image.dx = x;
 	image.dy = y;
@@ -203,7 +190,6 @@ 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);
@@ -211,7 +197,7 @@ vt_drmfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
 	info->fbops->fb_imageblit(info, &image);
 }
 
-int
+static int
 vt_drmfb_bitblt_argb(struct vt_device *vd, const struct vt_window *vw,
     const uint8_t *argb,
     unsigned int width, unsigned int height,
@@ -220,7 +206,6 @@ vt_drmfb_bitblt_argb(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);
@@ -228,17 +213,10 @@ vt_drmfb_bitblt_argb(struct vt_device *vd, const struct vt_window *vw,
 		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;
-	}
+	if (y >= vw->vw_draw_area.tr_end.tp_row)
+		return (EINVAL);
+	if (x >= vw->vw_draw_area.tr_end.tp_col)
+		return (EINVAL);
 
 	image.dx = x;
 	image.dy = y;
@@ -246,51 +224,13 @@ vt_drmfb_bitblt_argb(struct vt_device *vd, const struct vt_window *vw,
 	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)
-{
-	struct fb_info *fbio;
-	struct linux_fb_info *info;
-
-	fbio = vd->vd_softc;
-	info = to_linux_fb_info(fbio);
-
-	if (!kdb_active && !KERNEL_PANICKED()) {
-		taskqueue_enqueue(taskqueue_thread, &info->fb_mode_task);
-
-		/* XXX the VT_ACTIVATE IOCTL must be synchronous */
-		if (curthread->td_proc->p_pid != 0 &&
-		    taskqueue_member(taskqueue_thread, curthread) == 0)
-			taskqueue_drain(taskqueue_thread, &info->fb_mode_task);
-	} else {
-#ifdef DDB
-		db_trace_self_depth(10);
-		mdelay(1000);
-#endif
-		if (skip_ddb) {
-			spinlock_enter();
-			doadump(false);
-			EVENTHANDLER_INVOKE(shutdown_final, RB_NOSYNC);
-		}
-
-		if (vd->vd_grabwindow != NULL) {
-			if (info->fbops->fb_debug_enter)
-				info->fbops->fb_debug_enter(info);
-		} else {
-			if (info->fbops->fb_debug_leave)
-				info->fbops->fb_debug_leave(info);
-		}
-	}
-}
-
-void
+static void
 vt_drmfb_invalidate_text(struct vt_device *vd, const term_rect_t *area)
 {
 	unsigned int col, row;
@@ -315,106 +255,59 @@ vt_drmfb_invalidate_text(struct vt_device *vd, const term_rect_t *area)
 	}
 }
 
+/* Newbus methods. */
 static int
-vt_drmfb_init_colors(struct fb_info *info)
+vt_drmfb_probe(device_t dev)
 {
+	char *disabled;
 
-	switch (FBTYPE_GET_BPP(info)) {
-	case 8:
-		return (vt_config_cons_colors(info, COLOR_FORMAT_RGB,
-		    0x7, 5, 0x7, 2, 0x3, 0));
-	case 15:
-		return (vt_config_cons_colors(info, COLOR_FORMAT_RGB,
-		    0x1f, 10, 0x1f, 5, 0x1f, 0));
-	case 16:
-		return (vt_config_cons_colors(info, COLOR_FORMAT_RGB,
-		    0x1f, 11, 0x3f, 5, 0x1f, 0));
-	case 24:
-	case 32: /* Ignore alpha. */
-		return (vt_config_cons_colors(info, COLOR_FORMAT_RGB,
-		    0xff, 16, 0xff, 8, 0xff, 0));
-	default:
-		return (1);
-	}
+	disabled = kern_getenv("kern.vt.disable_drmfb");
+	if (disabled != NULL && strtoul(disabled, NULL, 10) != 0)
+		return (ENXIO);
+
+	return (BUS_PROBE_GENERIC);
 }
 
-int
-vt_drmfb_init(struct vt_device *vd)
+static int
+vt_drmfb_attach(device_t dev)
 {
 	struct fb_info *fbio;
-	u_int margin;
-	int bg, err;
-	term_color_t c;
-
-	fbio = vd->vd_softc;
-	vd->vd_height = MIN(VT_FB_MAX_HEIGHT, fbio->fb_height);
-	margin = (fbio->fb_height - vd->vd_height) >> 1;
-	vd->vd_transpose = margin * fbio->fb_stride;
-	vd->vd_width = MIN(VT_FB_MAX_WIDTH, fbio->fb_width);
-	margin = (fbio->fb_width - vd->vd_width) >> 1;
-	vd->vd_transpose += margin * (fbio->fb_bpp / NBBY);
-	vd->vd_video_dev = fbio->fb_video_dev;
-
-	if (fbio->fb_size == 0)
-		return (CN_DEAD);
-
-	if (fbio->fb_pbase == 0 && fbio->fb_vbase == 0)
-		fbio->fb_flags |= FB_FLAG_NOMMAP;
-
-	if (fbio->fb_cmsize <= 0) {
-		err = vt_drmfb_init_colors(fbio);
-		if (err)
-			return (CN_DEAD);
-		fbio->fb_cmsize = 16;
-	}
-
-	c = TC_BLACK;
-	if (TUNABLE_INT_FETCH("teken.bg_color", &bg) != 0) {
-		if (bg == TC_WHITE)
-			bg |= TC_LIGHT;
-		c = bg;
-	}
-
-	/* Clear the screen. */
-	vd->vd_driver->vd_blank(vd, c);
 
-	return (CN_INTERNAL);
-}
+	fbio = FB_GETINFO(device_get_parent(dev));
+	if (fbio == NULL)
+		return (ENXIO);
 
-void
-vt_drmfb_fini(struct vt_device *vd, void *softc)
-{
-	vd->vd_video_dev = NULL;
+	return (vt_allocate(&vt_drmfb_driver, fbio));
 }
 
-int
-vt_drmfb_attach(struct fb_info *fbio)
+static int
+vt_drmfb_detach(device_t dev)
 {
-	int ret;
+	struct fb_info *fbio;
 
-	ret = vt_allocate(&vt_drmfb_driver, fbio);
+	fbio = FB_GETINFO(device_get_parent(dev));
+	if (fbio == NULL)
+		return (ENXIO);
 
-	return (ret);
+	return (vt_deallocate(&vt_drmfb_driver, fbio));
 }
 
-int
-vt_drmfb_detach(struct fb_info *fbio)
-{
-	int ret;
 
-	ret = vt_deallocate(&vt_drmfb_driver, fbio);
+static device_method_t vt_drmfb_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		vt_drmfb_probe),
+	DEVMETHOD(device_attach,	vt_drmfb_attach),
+	DEVMETHOD(device_detach,	vt_drmfb_detach),
+	DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 
-	return (ret);
-}
+	DEVMETHOD_END
+};
 
-void
-vt_drmfb_suspend(struct vt_device *vd)
-{
-	vt_suspend(vd);
-}
+driver_t vt_drmfb_bus_driver = {
+	"fbd",
+	vt_drmfb_methods,
+	0
+};
 
-void
-vt_drmfb_resume(struct vt_device *vd)
-{
-	vt_resume(vd);
-}
+DRIVER_MODULE(vt_drmfb, drmn, vt_drmfb_bus_driver, NULL, NULL);
+MODULE_VERSION(vt_drmfb, 1);
diff --git a/drm/Makefile b/drm/Makefile
index 9ed8a944d7e4..62720d071426 100644
--- a/drm/Makefile
+++ b/drm/Makefile
@@ -69,9 +69,7 @@ SRCS=	drm_atomic.c \
 	drm_sysfs.c \
 	drm_vblank.c \
 	drm_vblank_work.c \
-	drm_vma_manager.c \
-	linux_fb.c \
-	vt_drmfb.c
+	drm_vma_manager.c
 
 # GPL-2.0.
 SRCS+=	drm_writeback.c
diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h
index a93d36f2f747..0194c86562e0 100644
--- a/include/drm/drm_device.h
+++ b/include/drm/drm_device.h
@@ -311,7 +311,8 @@ struct drm_device {
 	void *sysctl_private;
 	char busid_str[128];
 	int modesetting;
-	bool fictitious_range_registered;
+	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/linux/fb.h b/linuxkpi/bsd/include/linux/fb.h
new file mode 100644
index 000000000000..b7aebbb012a3
--- /dev/null
+++ b/linuxkpi/bsd/include/linux/fb.h
@@ -0,0 +1,399 @@
+/*-
+ * Copyright (c) 2023 Beckhoff Automation GmbH & Co. KG
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef _BSD_LKPI_UAPI_LINUX_FB_H_
+#define	_BSD_LKPI_UAPI_LINUX_FB_H_
+
+#include <sys/fbio.h>
+
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/pci.h>
+
+#define	FB_ROTATE_UR	0
+#define	FB_ROTATE_CW	1
+#define	FB_ROTATE_UD	2
+#define	FB_ROTATE_CCW	3
+
+#define	FBIO_WAITFORVSYNC	_IOW('F', 0x20, uint32_t)
+
+#define PICOS2KHZ(a) (1000000000UL/(a))
+#define KHZ2PICOS(a) (1000000000UL/(a))
+
+#define FB_TYPE_PACKED_PIXELS		0
+#define FB_TYPE_PLANES			1
+#define FB_TYPE_INTERLEAVED_PLANES	2
+#define FB_TYPE_TEXT			3
+#define FB_TYPE_VGA_PLANES		4
+#define FB_TYPE_FOURCC			5
+
+#define FB_VISUAL_MONO01		0
+#define FB_VISUAL_MONO10		1
+#define FB_VISUAL_TRUECOLOR		2
+#define FB_VISUAL_PSEUDOCOLOR		3
+#define FB_VISUAL_DIRECTCOLOR		4
+#define FB_VISUAL_STATIC_PSEUDOCOLOR	5
+#define FB_VISUAL_FOURCC		6
+
+#define FB_ACCEL_NONE		0
+
+#define	FBINFO_DEFAULT		0
+#define	FBINFO_VIRTFB		1
+#define	FBINFO_READS_FAST	2
+
+#define FBINFO_HIDE_SMEM_START  0x200000
+
+struct linux_fb_info;
+struct vm_area_struct;
+
+#ifdef __FreeBSD__
+extern int linuxkpi_skip_ddb;
+#endif
+
+struct fb_fix_screeninfo {
+	char id[16];
+	unsigned long smem_start;
+	uint32_t smem_len;
+	uint32_t type;
+	uint32_t type_aux;
+	uint32_t visual;
+	uint16_t xpanstep;
+	uint16_t ypanstep;
+	uint16_t ywrapstep;
+	uint32_t line_length;
+	unsigned long mmio_start;
+	uint32_t mmio_len;
+	uint32_t accel;
+	uint16_t capabilities;
+	uint16_t reserved[2];
+};
+
+struct fb_bitfield {
+	uint32_t offset;
+	uint32_t length;
+	uint32_t msb_right;
+};
+
+#define FB_ACTIVATE_NOW		0
+
+#define FB_ACCELF_TEXT		1
+
+struct fb_var_screeninfo {
+	uint32_t xres;
+	uint32_t yres;
+	uint32_t xres_virtual;
+	uint32_t yres_virtual;
+	uint32_t xoffset;
+	uint32_t yoffset;
+
+	uint32_t bits_per_pixel;
+	uint32_t grayscale;
+
+	struct fb_bitfield red;
+	struct fb_bitfield green;
+	struct fb_bitfield blue;
+	struct fb_bitfield transp;
+
+	uint32_t nonstd;
+
+	uint32_t activate;
+
+	uint32_t height;
+	uint32_t width;
+
+	uint32_t accel_flags;
+
+	uint32_t pixclock;
+	uint32_t left_margin;
+	uint32_t right_margin;
+	uint32_t upper_margin;
+	uint32_t lower_margin;
+	uint32_t hsync_len;
+	uint32_t vsync_len;
+	uint32_t sync;
+	uint32_t vmode;
+	uint32_t rotate;
+	uint32_t colorspace;
+	uint32_t reserved[4];
+};
+
+struct fb_cmap {
+	uint32_t start;
+	uint32_t len;
+	uint16_t *red;
+	uint16_t *green;
+	uint16_t *blue;
+	uint16_t *transp;
+};
+
+/* VESA Blanking Levels */
+#define VESA_NO_BLANKING        0
+#define VESA_VSYNC_SUSPEND      1
+#define VESA_HSYNC_SUSPEND      2
+#define VESA_POWERDOWN          3
+
+enum {
+	FB_BLANK_UNBLANK       = VESA_NO_BLANKING,
+	FB_BLANK_NORMAL        = VESA_NO_BLANKING + 1,
+	FB_BLANK_VSYNC_SUSPEND = VESA_VSYNC_SUSPEND + 1,
+	FB_BLANK_HSYNC_SUSPEND = VESA_HSYNC_SUSPEND + 1,
+	FB_BLANK_POWERDOWN     = VESA_POWERDOWN + 1
+};
+
+struct fb_vblank {
+	uint32_t flags;
+	uint32_t count;
+	uint32_t vcount;
+	uint32_t hcount;
+	uint32_t reserved[4];
+};
+
+#define ROP_COPY 0
+#define ROP_XOR  1
+
+struct fb_copyarea {
+	uint32_t dx;
+	uint32_t dy;
+	uint32_t width;
+	uint32_t height;
+	uint32_t sx;
+	uint32_t sy;
+};
+
+struct fb_fillrect {
+	uint32_t dx;
+	uint32_t dy;
+	uint32_t width;
+	uint32_t height;
+	uint32_t color;
+	uint32_t rop;
+};
+
+struct fb_image {
+	uint32_t dx;
+	uint32_t dy;
+	uint32_t width;
+	uint32_t height;
+	uint32_t fg_color;
+	uint32_t bg_color;
+	uint8_t  depth;
+	const char *data;
+	struct fb_cmap cmap;
+#ifdef __FreeBSD__
+	const char *mask;
+#endif
+};
+
+struct fbcurpos {
+	uint16_t x, y;
+};
+
+struct fb_cursor {
+	uint16_t set;
+	uint16_t enable;
+	uint16_t rop;
+	const char *mask;
+	struct fbcurpos hot;
+	struct fb_image	image;
+};
+
+struct fb_blit_caps {
+	uint32_t x;
+	uint32_t y;
+	uint32_t len;
+	uint32_t flags;
+};
+
+struct fb_ops {
+	struct module *owner;
+	int (*fb_open)(struct linux_fb_info *, int);
+	int (*fb_release)(struct linux_fb_info *, int);
+	ssize_t (*fb_read)(struct linux_fb_info *, char *, size_t, loff_t *);
+	ssize_t (*fb_write)(struct linux_fb_info *, const char *, size_t, loff_t *);
+	int (*fb_check_var)(struct fb_var_screeninfo *, struct linux_fb_info *);
+	int (*fb_set_par)(struct linux_fb_info *);
+	int (*fb_setcolreg)(unsigned, unsigned, unsigned, unsigned, unsigned,
+	    struct linux_fb_info *);
+	int (*fb_setcmap)(struct fb_cmap *, struct linux_fb_info *);
+	int (*fb_blank)(int, struct linux_fb_info *);
+	int (*fb_pan_display)(struct fb_var_screeninfo *, struct linux_fb_info *);
+	void (*fb_fillrect) (struct linux_fb_info *, const struct fb_fillrect *);
+	void (*fb_copyarea) (struct linux_fb_info *, const struct fb_copyarea *);
+	void (*fb_imageblit) (struct linux_fb_info *, const struct fb_image *);
+	int (*fb_cursor) (struct linux_fb_info *, struct fb_cursor *);
+	int (*fb_sync)(struct linux_fb_info *);
+	int (*fb_ioctl)(struct linux_fb_info *, unsigned int, unsigned long);
+	int (*fb_compat_ioctl)(struct linux_fb_info *, unsigned, unsigned long);
+	int (*fb_mmap)(struct linux_fb_info *, struct vm_area_struct *);
+	void (*fb_get_caps)(struct linux_fb_info *, struct fb_blit_caps *,
+	    struct fb_var_screeninfo *);
+	void (*fb_destroy)(struct linux_fb_info *);
+	int (*fb_debug_enter)(struct linux_fb_info *);
+	int (*fb_debug_leave)(struct linux_fb_info *);
+};
+
+struct linux_fb_info {
+	int flags;
+	int fbcon_rotate_hint;
+
+	struct fb_var_screeninfo var;
+	struct fb_fix_screeninfo fix;
+
+	const struct fb_ops *fbops;
+	struct device *device;
+	struct device *dev;
+	union {
+		char __iomem *screen_base;
+		char *screen_buffer;
+	};
+	unsigned long screen_size;
+	void *pseudo_palette;
+#define FBINFO_STATE_RUNNING	0
+#define FBINFO_STATE_SUSPENDED	1
+	uint32_t state;
+	void *par;
+	bool skip_vt_switch;
+	bool skip_panic;
+
+#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));
+
+#define __FB_DEFAULT_IOMEM_OPS_RDWR \
+	.fb_read	= linuxkpi_fb_io_read, \
+	.fb_write	= linuxkpi_fb_io_write
+
+#define __FB_DEFAULT_IOMEM_OPS_DRAW \
+	.fb_fillrect	= linuxkpi_cfb_fillrect, \
+	.fb_copyarea	= linuxkpi_cfb_copyarea, \
+	.fb_imageblit	= linuxkpi_cfb_imageblit
+
+#define __FB_DEFAULT_IOMEM_OPS_MMAP \
+	.fb_mmap	= NULL /* default implementation */
+
+#define FB_DEFAULT_IOMEM_OPS \
+	__FB_DEFAULT_IOMEM_OPS_RDWR, \
+	__FB_DEFAULT_IOMEM_OPS_DRAW, \
+	__FB_DEFAULT_IOMEM_OPS_MMAP
+
+#define FB_GEN_DEFAULT_DEFERRED_IOMEM_OPS(_pfx, _range, _area)		\
+	static void							\
+	_pfx ## _fillrect(struct linux_fb_info *fi, const struct fb_fillrect *fr) \
+	{								\
+		linuxkpi_cfb_fillrect(fi, fr);				\
+		_area(fi, fr->dx, fr->dy, fr->width, fr->height);	\
+	}								\
+	static void							\
+	_pfx ## _copyarea(struct linux_fb_info *fi, const struct fb_copyarea *fca) \
+	{								\
+		linuxkpi_cfb_copyarea(fi, fca);				\
+		_area(fi, fca->dx, fca->dy, fca->width, fca->height);	\
+	}								\
+	static void							\
+	_pfx ## _imageblit(struct linux_fb_info *fi, const struct fb_image *img) \
+	{								\
+		linuxkpi_cfb_imageblit(fi, img);			\
+		_area(fi, img->dx, img->dy, img->width, img->height);	\
+	}
+
+#define FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS(...) \
+	FB_GEN_DEFAULT_DEFERRED_IOMEM_OPS(__VA_ARGS__)
+
+#define __FB_DEFAULT_DEFERRED_OPS_RDWR(...)	\
+	.fb_read	= linuxkpi_fb_io_read,	\
+	.fb_write	= linuxkpi_fb_io_write
+
+#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(...)	\
+	.fb_mmap	= linuxkpi_fb_deferred_io_mmap
+
+#define FB_DEFAULT_DEFERRED_OPS(_pfx)		\
+	__FB_DEFAULT_DEFERRED_OPS_RDWR(),	\
+	__FB_DEFAULT_DEFERRED_OPS_DRAW(_pfx),	\
+	__FB_DEFAULT_DEFERRED_OPS_MMAP()
+
+void linuxkpi_cfb_fillrect(struct linux_fb_info *info,
+    const struct fb_fillrect *rect);
+#define	cfb_fillrect(...)	linuxkpi_cfb_fillrect(__VA_ARGS__)
+#define	sys_fillrect(...)	linuxkpi_cfb_fillrect(__VA_ARGS__)
+void linuxkpi_cfb_copyarea(struct linux_fb_info *info,
+    const struct fb_copyarea *area);
+#define	cfb_copyarea(...)	linuxkpi_cfb_copyarea(__VA_ARGS__)
+#define	sys_copyarea(...)	linuxkpi_cfb_copyarea(__VA_ARGS__)
+void linuxkpi_cfb_imageblit(struct linux_fb_info *info,
+    const struct fb_image *image);
+#define	cfb_imageblit(...)	linuxkpi_cfb_imageblit(__VA_ARGS__)
+#define	sys_imageblit(...)	linuxkpi_cfb_imageblit(__VA_ARGS__)
+ssize_t linuxkpi_fb_io_read(struct linux_fb_info *info, char __user *buf,
+    size_t count, loff_t *ppos);
+#define	fb_io_read(...)		linuxkpi_fb_io_read(__VA_ARGS__)
+#define	fb_sys_read(...)	linuxkpi_fb_io_read(__VA_ARGS__)
+ssize_t linuxkpi_fb_io_write(struct linux_fb_info *info, const char __user *buf,
+    size_t count, loff_t *ppos);
+#define	fb_io_write(...)	linuxkpi_fb_io_write(__VA_ARGS__)
+#define	fb_sys_write(...)	linuxkpi_fb_io_write(__VA_ARGS__)
+int linuxkpi_fb_deferred_io_mmap(struct linux_fb_info *info,
+    struct vm_area_struct *vma);
+#define	fb_deferred_io_mmap(...) linuxkpi_fb_deferred_io_mmap(__VA_ARGS__)
+
+int linuxkpi_register_framebuffer(struct linux_fb_info *fb_info);
+#define	register_framebuffer(...)	\
+    linuxkpi_register_framebuffer(__VA_ARGS__)
+int linuxkpi_unregister_framebuffer(struct linux_fb_info *fb_info);
+#define	unregister_framebuffer(...)	\
+    linuxkpi_unregister_framebuffer(__VA_ARGS__)
+struct linux_fb_info *linuxkpi_framebuffer_alloc(size_t size, struct device *dev);
+#define	framebuffer_alloc(...)	linuxkpi_framebuffer_alloc(__VA_ARGS__)
+void linuxkpi_framebuffer_release(struct linux_fb_info *info);
+#define	framebuffer_release(...)	\
+    linuxkpi_framebuffer_release(__VA_ARGS__)
+
+static inline void
+fb_set_suspend(struct linux_fb_info *info, int state)
+{
+}
+
+static inline void
+fb_deferred_io_cleanup(struct linux_fb_info *info)
+{
+}
+
+/* updated FreeBSD fb_info */
+int linuxkpi_fb_get_options(const char *name, char **option);
+#define	fb_get_options(...)	linuxkpi_fb_get_options(__VA_ARGS__)
+
+#endif
diff --git a/linuxkpi/bsd/include/uapi/linux/fb.h b/linuxkpi/bsd/include/uapi/linux/fb.h
deleted file mode 100644
index 3c311f11b192..000000000000
--- a/linuxkpi/bsd/include/uapi/linux/fb.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/*-
- * Copyright (c) 2023 Beckhoff Automation GmbH & Co. KG
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#ifndef _BSD_LKPI_UAPI_LINUX_FB_H_
-#define	_BSD_LKPI_UAPI_LINUX_FB_H_
-
-#define	FB_ROTATE_UR	0
-#define	FB_ROTATE_CW	1
-#define	FB_ROTATE_UD	2
-#define	FB_ROTATE_CCW	3
-
-#define	FBIO_WAITFORVSYNC	_IOW('F', 0x20, uint32_t)
-
-#define PICOS2KHZ(a) (1000000000UL/(a))
-#define KHZ2PICOS(a) (1000000000UL/(a))
-
-#define FB_TYPE_PACKED_PIXELS		0
-#define FB_TYPE_PLANES			1
-#define FB_TYPE_INTERLEAVED_PLANES	2
-#define FB_TYPE_TEXT			3
-#define FB_TYPE_VGA_PLANES		4
-#define FB_TYPE_FOURCC			5
-
-#define FB_VISUAL_MONO01		0
-#define FB_VISUAL_MONO10		1
-#define FB_VISUAL_TRUECOLOR		2
-#define FB_VISUAL_PSEUDOCOLOR		3
-#define FB_VISUAL_DIRECTCOLOR		4
-#define FB_VISUAL_STATIC_PSEUDOCOLOR	5
-#define FB_VISUAL_FOURCC		6
-
-#define FB_ACCEL_NONE		0
-
-struct fb_fix_screeninfo {
-	char id[16];
-#ifdef __linux__
-	unsigned long smem_start;
-#elif defined(__FreeBSD__)
-	vm_paddr_t smem_start;
-#endif
-
-	uint32_t smem_len;
-	uint32_t type;
-	uint32_t type_aux;
-	uint32_t visual;
-	uint16_t xpanstep;
-	uint16_t ypanstep;
-	uint16_t ywrapstep;
-	uint32_t line_length;
-	unsigned long mmio_start;
-
-	uint32_t mmio_len;
-	uint32_t accel;
-
-	uint16_t capabilities;
-	uint16_t reserved[2];
-};
-
-struct fb_bitfield {
-	uint32_t offset;
-	uint32_t length;
-	uint32_t msb_right;
-};
-
-#define FB_ACTIVATE_NOW		0
-
-#define FB_ACCELF_TEXT		1
-
-struct fb_var_screeninfo {
-	uint32_t xres;
-	uint32_t yres;
-	uint32_t xres_virtual;
-	uint32_t yres_virtual;
-	uint32_t xoffset;
-	uint32_t yoffset;
-
-	uint32_t bits_per_pixel;
-	uint32_t grayscale;
-
-	struct fb_bitfield red;
-	struct fb_bitfield green;
-	struct fb_bitfield blue;
-	struct fb_bitfield transp;
-
-	uint32_t nonstd;
-
-	uint32_t activate;
-
-	uint32_t height;
-	uint32_t width;
-
-	uint32_t accel_flags;
-
-	uint32_t pixclock;
-	uint32_t left_margin;
-	uint32_t right_margin;
-	uint32_t upper_margin;
-	uint32_t lower_margin;
-	uint32_t hsync_len;
-	uint32_t vsync_len;
-	uint32_t sync;
-	uint32_t vmode;
-	uint32_t rotate;
-	uint32_t colorspace;
-	uint32_t reserved[4];
-};
-
-struct fb_cmap {
-	uint32_t start;
-	uint32_t len;
-	uint16_t *red;
-	uint16_t *green;
-	uint16_t *blue;
-	uint16_t *transp;
-};
-
-/* VESA Blanking Levels */
-#define VESA_NO_BLANKING        0
-#define VESA_VSYNC_SUSPEND      1
-#define VESA_HSYNC_SUSPEND      2
-#define VESA_POWERDOWN          3
-
-enum {
-	FB_BLANK_UNBLANK       = VESA_NO_BLANKING,
-	FB_BLANK_NORMAL        = VESA_NO_BLANKING + 1,
-	FB_BLANK_VSYNC_SUSPEND = VESA_VSYNC_SUSPEND + 1,
-	FB_BLANK_HSYNC_SUSPEND = VESA_HSYNC_SUSPEND + 1,
-	FB_BLANK_POWERDOWN     = VESA_POWERDOWN + 1
-};
-
-struct fb_vblank {
-	uint32_t flags;
-	uint32_t count;
-	uint32_t vcount;
-	uint32_t hcount;
-	uint32_t reserved[4];
-};
-
-#define ROP_COPY 0
-#define ROP_XOR  1
-
-struct fb_copyarea {
-	uint32_t dx;
-	uint32_t dy;
-	uint32_t width;
-	uint32_t height;
-	uint32_t sx;
-	uint32_t sy;
-};
-
-struct fb_fillrect {
-	uint32_t dx;
-	uint32_t dy;
-	uint32_t width;
-	uint32_t height;
-	uint32_t color;
-	uint32_t rop;
-};
-
-struct fb_image {
-	uint32_t dx;
-	uint32_t dy;
-	uint32_t width;
-	uint32_t height;
-	uint32_t fg_color;
-	uint32_t bg_color;
-	uint8_t  depth;
-	const char *data;
-	struct fb_cmap cmap;
-#ifdef __FreeBSD__
-	const char *mask;
-	uint32_t vt_width;
-#endif
-};
-
-struct fbcurpos {
-	uint16_t x, y;
-};
-
-struct fb_cursor {
-	uint16_t set;
-	uint16_t enable;
-	uint16_t rop;
-	const char *mask;
-	struct fbcurpos hot;
-	struct fb_image	image;
-};
-
-#endif
diff --git a/linuxkpi/gplv2/include/linux/fb.h b/linuxkpi/gplv2/include/linux/fb.h
deleted file mode 100644
index d823f9a5d62f..000000000000
--- a/linuxkpi/gplv2/include/linux/fb.h
+++ /dev/null
@@ -1,303 +0,0 @@
-#ifndef __LINUX_FB_H_
-#define __LINUX_FB_H_
-#include <sys/fbio.h>
-#include <uapi/linux/fb.h>
-
-#include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/workqueue.h>
-#include <linux/list.h>
-#include <linux/pci.h>
-#include <linux/backlight.h>
-#include <linux/slab.h>
-#include <linux/mutex.h>
-#include <asm/io.h>
-#include <linux/notifier.h>
-
-#define	FBINFO_DEFAULT		0
-#define	FBINFO_VIRTFB		1
-#define	FBINFO_READS_FAST	2
-
-struct linux_fb_info;
-struct videomode;
-struct vm_area_struct;
-
-struct fb_blit_caps {
-	u32 x;
-	u32 y;
-	u32 len;
-	u32 flags;
-};
-
-struct fb_ops {
-	/* open/release and usage marking */
-	struct module *owner;
-	int (*fb_open)(struct linux_fb_info *info, int user);
-	int (*fb_release)(struct linux_fb_info *info, int user);
-
-	/* For framebuffers with strange non linear layouts or that do not
-	 * work with normal memory mapped access
-	 */
-	ssize_t (*fb_read)(struct linux_fb_info *info, char __user *buf,
-			   size_t count, loff_t *ppos);
-	ssize_t (*fb_write)(struct linux_fb_info *info, const char __user *buf,
-			    size_t count, loff_t *ppos);
-
-	/* checks var and eventually tweaks it to something supported,
-	 * DO NOT MODIFY PAR */
-	int (*fb_check_var)(struct fb_var_screeninfo *var, struct linux_fb_info *info);
-
-	/* set the video mode according to info->var */
-	int (*fb_set_par)(struct linux_fb_info *info);
-
-	/* set color register */
-	int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
-			    unsigned blue, unsigned transp, struct linux_fb_info *info);
-
-	/* set color registers in batch */
-	int (*fb_setcmap)(struct fb_cmap *cmap, struct linux_fb_info *info);
-
-	/* blank display */
-	int (*fb_blank)(int blank, struct linux_fb_info *info);
-
-	/* pan display */
-	int (*fb_pan_display)(struct fb_var_screeninfo *var, struct linux_fb_info *info);
-
-	/* Draws a rectangle */
-	void (*fb_fillrect) (struct linux_fb_info *info, const struct fb_fillrect *rect);
-	/* Copy data from area to another */
-	void (*fb_copyarea) (struct linux_fb_info *info, const struct fb_copyarea *region);
-	/* Draws a image to the display */
-	void (*fb_imageblit) (struct linux_fb_info *info, const struct fb_image *image);
-
-	/* Draws cursor */
-	int (*fb_cursor) (struct linux_fb_info *info, struct fb_cursor *cursor);
-
-	/* wait for blit idle, optional */
-	int (*fb_sync)(struct linux_fb_info *info);
-
-	/* perform fb specific ioctl (optional) */
-	int (*fb_ioctl)(struct linux_fb_info *info, unsigned int cmd,
-			unsigned long arg);
-
-	/* Handle 32bit compat ioctl (optional) */
-	int (*fb_compat_ioctl)(struct linux_fb_info *info, unsigned cmd,
-			unsigned long arg);
-
-	/* perform fb specific mmap */
-	int (*fb_mmap)(struct linux_fb_info *info, struct vm_area_struct *vma);
-
-	/* get capability given var */
-	void (*fb_get_caps)(struct linux_fb_info *info, struct fb_blit_caps *caps,
-			    struct fb_var_screeninfo *var);
-
-	/* teardown any resources to do with this framebuffer */
-	void (*fb_destroy)(struct linux_fb_info *info);
-
-	/* called at KDB enter and leave time to prepare the console */
-	int (*fb_debug_enter)(struct linux_fb_info *info);
-	int (*fb_debug_leave)(struct linux_fb_info *info);
-};
-
-/*
- * Hide smem_start in the FBIOGET_FSCREENINFO IOCTL. This is used by modern DRM
- * drivers to stop userspace from trying to share buffers behind the kernel's
- * back. Instead dma-buf based buffer sharing should be used.
- */
-#define FBINFO_HIDE_SMEM_START  0x200000
-
-
-struct linux_fb_info {
-	int flags;
-	/*
-	 * -1 by default, set to a FB_ROTATE_* value by the driver, if it knows
-	 * a lcd is not mounted upright and fbcon should rotate to compensate.
-	 */
-	int fbcon_rotate_hint;
-
-	struct fb_var_screeninfo var;	/* Current var */
-	struct fb_fix_screeninfo fix;	/* Current fix */
-
-	const struct fb_ops *fbops;
-	struct device *device;		/* This is the parent */
-	struct device *dev;		/* This is this fb device */
-	union {
-		char __iomem *screen_base;	/* Virtual address */
-		char *screen_buffer;
-	};
-	unsigned long screen_size;	/* Amount of ioremapped VRAM or 0 */ 
-	void *pseudo_palette;		/* Fake palette of 16 colors */ 
-#define FBINFO_STATE_RUNNING	0
-#define FBINFO_STATE_SUSPENDED	1
-	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 */
-	bool skip_panic; /* Do not write to the fb after a panic */
-
-#ifdef __FreeBSD__
-	struct fb_info fbio;
-	device_t fb_bsddev;
-	struct task fb_mode_task;
-#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,
-    size_t count, loff_t *ppos);
-extern ssize_t fb_io_write(struct linux_fb_info *info, const char __user *buf,
-    size_t count, loff_t *ppos);
-
-/*
- * Initializes struct fb_ops for framebuffers in I/O memory.
- */
-
-#define __FB_DEFAULT_IOMEM_OPS_RDWR \
-	.fb_read	= fb_io_read, \
-	.fb_write	= fb_io_write
-
-#define __FB_DEFAULT_IOMEM_OPS_DRAW \
-	.fb_fillrect	= cfb_fillrect, \
-	.fb_copyarea	= cfb_copyarea, \
-	.fb_imageblit	= cfb_imageblit
-
-#define __FB_DEFAULT_IOMEM_OPS_MMAP \
-	.fb_mmap	= NULL /* default implementation */
-
-#define FB_DEFAULT_IOMEM_OPS \
-	__FB_DEFAULT_IOMEM_OPS_RDWR, \
-	__FB_DEFAULT_IOMEM_OPS_DRAW, \
-	__FB_DEFAULT_IOMEM_OPS_MMAP
-
-/*
- * 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);
-
-/*
- * 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_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)
-
-/*
- * 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_DRAW(__prefix) \
-	.fb_fillrect	= __prefix ## _defio_fillrect, \
-	.fb_copyarea	= __prefix ## _defio_copyarea, \
-	.fb_imageblit	= __prefix ## _defio_imageblit
-
-#define __FB_DEFAULT_DEFERRED_OPS_MMAP(__prefix) \
-	.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)
-
-
-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,
-	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);
-
-static inline void
-fb_set_suspend(struct linux_fb_info *info, int state)
-{
-}
-
-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
-
-#endif /* __LINUX_FB_H_ */
diff --git a/linuxkpi_video/Makefile b/linuxkpi_video/Makefile
index fde77c73da48..cd5ab0f443a1 100644
--- a/linuxkpi_video/Makefile
+++ b/linuxkpi_video/Makefile
@@ -9,21 +9,27 @@ KMOD=	linuxkpi_video
 
 EXPORT_SYMS=    YES
 
-SRCS=	hdmi.c \
-	video_kmod.c
+SRCS=	linux_hdmi.c \
+	linux_fb.c \
+	video_kmod.c \
+	vt_drmfb.c
 
 .if !empty(KCONFIG:MAPERTURE_HELPERS)
-SRCS+= aperture.c
+SRCS+=	linux_aperture.c
 .endif
 
 .if !empty(KCONFIG:MVIDEO_CMDLINE)
-SRCS+=	cmdline.c
+SRCS+=	linux_cmdline.c
 .endif
 
 SRCS+=	bus_if.h \
 	device_if.h \
+	fb_if.h \
 	pci_if.h \
 	vnode_if.h \
+	opt_splash.h \
+	opt_syscons.h \
+	opt_teken.h
 
 .include <bsd.kmod.mk>
 
@@ -37,9 +43,10 @@ CFLAGS+=	-I${.CURDIR:H}/linuxkpi/bsd/include
 CFLAGS+=	-I${SYSDIR}/compat/linuxkpi/common/include
 CFLAGS+=	-I${SYSDIR}/compat/linuxkpi/dummy/include
 CFLAGS+=	-I${.CURDIR:H}/include
+CFLAGS+=	-I${SRCDIR}
 
 CFLAGS+= '-DKBUILD_MODNAME="${KMOD}"'
 CFLAGS+= '-DLINUXKPI_PARAM_PREFIX=ttm_' -DDRM_SYSCTL_PARAM_PREFIX=_${KMOD}
 CFLAGS+= ${KCONFIG:C/(.*)/-DCONFIG_\1/}
 
-CWARNFLAGS.hdmi.c=	-Wno-cast-qual
+CWARNFLAGS.linux_hdmi.c=	-Wno-cast-qual
diff --git a/scripts/drmgeneratepatch b/scripts/drmgeneratepatch
index 5309b8b5e555..30fc658dca35 100755
--- a/scripts/drmgeneratepatch
+++ b/scripts/drmgeneratepatch
@@ -148,4 +148,6 @@ for file in ${PATCH_DIR}/*; do
 	sed -i '' 's/\([ab]\)\/include\/linux\/dma-resv\.h/\1\/linuxkpi\/bsd\/include\/linux\/dma-resv.h/g' ${file}
 	sed -i '' 's/\([ab]\)\/include\/linux\/dma-fence-unwrap\.h/\1\/linuxkpi\/gplv2\/include\/linux\/dma-fence-unwrap.h/' ${file}
 	sed -i '' 's/\([ab]\)\/include\/linux\/hdmi\.h/\1\/linuxkpi\/bsd\/include\/linux\/hdmi.h/g' ${file}
+	sed -i '' 's|\([ab]/drivers/video\)/aperture\.c|\1/linux_aperture.c|g' ${file}
+	sed -i '' 's|\([ab]/drivers/video\)/hdmi\.c|\1/linux_hdmi.c|g' ${file}
 done