diff --git a/repos/dde_linux/imx8_fb.list b/repos/dde_linux/imx8_fb.list
new file mode 100644
index 000000000..c82d1c0df
--- /dev/null
+++ b/repos/dde_linux/imx8_fb.list
@@ -0,0 +1,214 @@
+linux-x.x.x/drivers/base/component.c
+linux-x.x.x/drivers/base/devres.c
+linux-x.x.x/drivers/dma-buf/dma-fence.c
+linux-x.x.x/drivers/gpu/drm/drm_atomic.c
+linux-x.x.x/drivers/gpu/drm/drm_atomic_helper.c
+linux-x.x.x/drivers/gpu/drm/drm_blend.c
+linux-x.x.x/drivers/gpu/drm/drm_bridge.c
+linux-x.x.x/drivers/gpu/drm/drm_connector.c
+linux-x.x.x/drivers/gpu/drm/drm_crtc.c
+linux-x.x.x/drivers/gpu/drm/drm_crtc_helper_internal.h
+linux-x.x.x/drivers/gpu/drm/drm_crtc_internal.h
+linux-x.x.x/drivers/gpu/drm/drm_dp_helper.c
+linux-x.x.x/drivers/gpu/drm/drm_edid.c
+linux-x.x.x/drivers/gpu/drm/drm_encoder.c
+linux-x.x.x/drivers/gpu/drm/drm_fourcc.c
+linux-x.x.x/drivers/gpu/drm/drm_framebuffer.c
+linux-x.x.x/drivers/gpu/drm/drm_gem.c
+linux-x.x.x/drivers/gpu/drm/drm_gem_cma_helper.c
+linux-x.x.x/drivers/gpu/drm/drm_gem_framebuffer_helper.c
+linux-x.x.x/drivers/gpu/drm/drm_internal.h
+linux-x.x.x/drivers/gpu/drm/drm_mm.c
+linux-x.x.x/drivers/gpu/drm/drm_mode_config.c
+linux-x.x.x/drivers/gpu/drm/drm_mode_object.c
+linux-x.x.x/drivers/gpu/drm/drm_modes.c
+linux-x.x.x/drivers/gpu/drm/drm_modeset_helper.c
+linux-x.x.x/drivers/gpu/drm/drm_modeset_lock.c
+linux-x.x.x/drivers/gpu/drm/drm_of.c
+linux-x.x.x/drivers/gpu/drm/drm_plane.c
+linux-x.x.x/drivers/gpu/drm/drm_probe_helper.c
+linux-x.x.x/drivers/gpu/drm/drm_property.c
+linux-x.x.x/drivers/gpu/drm/drm_rect.c
+linux-x.x.x/drivers/gpu/drm/drm_vblank.c
+linux-x.x.x/drivers/gpu/drm/drm_vma_manager.c
+linux-x.x.x/drivers/gpu/drm/imx/imx-drm.h
+linux-x.x.x/drivers/gpu/drm/imx/imx-drm-core.c
+linux-x.x.x/drivers/gpu/drm/imx/dcss/dcss-crtc.c
+linux-x.x.x/drivers/gpu/drm/imx/dcss/dcss-crtc.h
+linux-x.x.x/drivers/gpu/drm/imx/dcss/dcss-kms.c
+linux-x.x.x/drivers/gpu/drm/imx/dcss/dcss-kms.h
+linux-x.x.x/drivers/gpu/drm/imx/dcss/dcss-plane.c
+linux-x.x.x/drivers/gpu/drm/imx/dcss/dcss-plane.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_mcu1_dp.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_mcu1_dp.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_mcu2_dp.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_mcu2_dp.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_ss28fdsoi_kiran_hdmitx.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_ss28fdsoi_kiran_hdmitx.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_t28hpc_hdmitx.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/API_AFE_t28hpc_hdmitx.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-arc.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-dp.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-dp.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdcp-private.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdcp.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdcp.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdmi.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdmi.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdp.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/imx-hdp.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/ss28fdsoi_hdmitx_table.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/ss28fdsoi_hdmitx_table.h
+linux-x.x.x/drivers/gpu/drm/imx/hdp/t28hpc_hdmitx_table.c
+linux-x.x.x/drivers/gpu/drm/imx/hdp/t28hpc_hdmitx_table.h
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-common.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-blkctl.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-ctxld.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-dec400d.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-dpr.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-dtg.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-dtrc.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-hdr10.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-hdr10-tables.h
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-prv.h
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-rdsrc.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-scaler.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-ss.c
+linux-x.x.x/drivers/gpu/imx/dcss/dcss-wrscl.c
+linux-x.x.x/drivers/i2c/i2c-boardinfo.c
+linux-x.x.x/drivers/i2c/i2c-core-base.c
+linux-x.x.x/drivers/i2c/i2c-core.h
+linux-x.x.x/drivers/irqchip/irq-imx-irqsteer.c
+linux-x.x.x/drivers/mxc/hdp/API_AFE.c
+linux-x.x.x/drivers/mxc/hdp/API_AFE.h
+linux-x.x.x/drivers/mxc/hdp/API_DPTX.c
+linux-x.x.x/drivers/mxc/hdp/API_DPTX.h
+linux-x.x.x/drivers/mxc/hdp/API_General.c
+linux-x.x.x/drivers/mxc/hdp/API_General.h
+linux-x.x.x/drivers/mxc/hdp/API_HDCP.c
+linux-x.x.x/drivers/mxc/hdp/API_HDCP.h
+linux-x.x.x/drivers/mxc/hdp/API_HDMITX.c
+linux-x.x.x/drivers/mxc/hdp/API_HDMITX.h
+linux-x.x.x/drivers/mxc/hdp/API_Infoframe.c
+linux-x.x.x/drivers/mxc/hdp/API_Infoframe.h
+linux-x.x.x/drivers/mxc/hdp/address.h
+linux-x.x.x/drivers/mxc/hdp/all.h
+linux-x.x.x/drivers/mxc/hdp/apb_cfg.h
+linux-x.x.x/drivers/mxc/hdp/dptx_framer.h
+linux-x.x.x/drivers/mxc/hdp/dptx_stream.h
+linux-x.x.x/drivers/mxc/hdp/general_handler.h
+linux-x.x.x/drivers/mxc/hdp/hdcp.h
+linux-x.x.x/drivers/mxc/hdp/hdcp2.h
+linux-x.x.x/drivers/mxc/hdp/hdcp_tran.h
+linux-x.x.x/drivers/mxc/hdp/hdmi.h
+linux-x.x.x/drivers/mxc/hdp/mailBox.h
+linux-x.x.x/drivers/mxc/hdp/mhl_hdtx_top.h
+linux-x.x.x/drivers/mxc/hdp/opcodes.h
+linux-x.x.x/drivers/mxc/hdp/source_car.h
+linux-x.x.x/drivers/mxc/hdp/source_phy.h
+linux-x.x.x/drivers/mxc/hdp/source_pif.h
+linux-x.x.x/drivers/mxc/hdp/source_vif.h
+linux-x.x.x/drivers/mxc/hdp/util.c
+linux-x.x.x/drivers/mxc/hdp/util.h
+linux-x.x.x/drivers/mxc/hdp-cec/imx-hdp-cec.h
+linux-x.x.x/drivers/video/hdmi.c
+linux-x.x.x/include/asm-generic/atomic64.h
+linux-x.x.x/include/asm-generic/bitops/__ffs.h
+linux-x.x.x/include/asm-generic/bitops/ffs.h
+linux-x.x.x/include/asm-generic/bitops/fls64.h
+linux-x.x.x/include/asm-generic/bitops/__fls.h
+linux-x.x.x/include/asm-generic/bitops/fls.h
+linux-x.x.x/include/asm-generic/bitops/non-atomic.h
+linux-x.x.x/include/drm/drm_atomic.h
+linux-x.x.x/include/drm/drm_atomic_helper.h
+linux-x.x.x/include/drm/drm_auth.h
+linux-x.x.x/include/drm/drm_blend.h
+linux-x.x.x/include/drm/drm_bridge.h
+linux-x.x.x/include/drm/drm_connector.h
+linux-x.x.x/include/drm/drm_crtc.h
+linux-x.x.x/include/drm/drm_crtc_helper.h
+linux-x.x.x/include/drm/drm_debugfs_crc.h
+linux-x.x.x/include/drm/drm_device.h
+linux-x.x.x/include/drm/drm_displayid.h
+linux-x.x.x/include/drm/drm_dp_helper.h
+linux-x.x.x/include/drm/drm_drv.h
+linux-x.x.x/include/drm/drm_edid.h
+linux-x.x.x/include/drm/drm_encoder.h
+linux-x.x.x/include/drm/drm_fb_cma_helper.h
+linux-x.x.x/include/drm/drm_fb_helper.h
+linux-x.x.x/include/drm/drm_file.h
+linux-x.x.x/include/drm/drm_fourcc.h
+linux-x.x.x/include/drm/drm_framebuffer.h
+linux-x.x.x/include/drm/drm_gem.h
+linux-x.x.x/include/drm/drm_gem_cma_helper.h
+linux-x.x.x/include/drm/drm_gem_framebuffer_helper.h
+linux-x.x.x/include/drm/drm_hashtab.h
+linux-x.x.x/include/drm/drm_hdcp.h
+linux-x.x.x/include/drm/drm_ioctl.h
+linux-x.x.x/include/drm/drm_mm.h
+linux-x.x.x/include/drm/drm_mode_config.h
+linux-x.x.x/include/drm/drm_mode_object.h
+linux-x.x.x/include/drm/drm_modeset_helper.h
+linux-x.x.x/include/drm/drm_modeset_helper_vtables.h
+linux-x.x.x/include/drm/drm_modeset_lock.h
+linux-x.x.x/include/drm/drm_modes.h
+linux-x.x.x/include/drm/drm_of.h
+linux-x.x.x/include/drm/drm_panel.h
+linux-x.x.x/include/drm/drmP.h
+linux-x.x.x/include/drm/drm_plane.h
+linux-x.x.x/include/drm/drm_plane_helper.h
+linux-x.x.x/include/drm/drm_prime.h
+linux-x.x.x/include/drm/drm_print.h
+linux-x.x.x/include/drm/drm_property.h
+linux-x.x.x/include/drm/drm_rect.h
+linux-x.x.x/include/drm/drm_vblank.h
+linux-x.x.x/include/drm/drm_vma_manager.h
+linux-x.x.x/include/linux/irqchip/chained_irq.h
+linux-x.x.x/include/linux/busfreq-imx.h
+linux-x.x.x/include/linux/component.h
+linux-x.x.x/include/linux/dma-fence.h
+linux-x.x.x/include/linux/fb.h
+linux-x.x.x/include/linux/hdmi.h
+linux-x.x.x/include/linux/i2c.h
+linux-x.x.x/include/linux/idr.h
+linux-x.x.x/include/linux/interval_tree_generic.h
+linux-x.x.x/include/linux/interval_tree.h
+linux-x.x.x/include/linux/irqdomain.h
+linux-x.x.x/include/linux/irqhandler.h
+linux-x.x.x/include/linux/list.h
+linux-x.x.x/include/linux/list_sort.h
+linux-x.x.x/include/linux/log2.h
+linux-x.x.x/include/linux/math64.h
+linux-x.x.x/include/linux/mod_devicetable.h
+linux-x.x.x/include/linux/of_graph.h
+linux-x.x.x/include/linux/pm_runtime.h
+linux-x.x.x/include/linux/pm_wakeirq.h
+linux-x.x.x/include/linux/radix-tree.h
+linux-x.x.x/include/linux/ratelimit.h
+linux-x.x.x/include/linux/rbtree_augmented.h
+linux-x.x.x/include/linux/rbtree.h
+linux-x.x.x/include/linux/sort.h
+linux-x.x.x/include/linux/vga_switcheroo.h
+linux-x.x.x/include/soc/imx8/sc/ipc.h
+linux-x.x.x/include/soc/imx8/sc/scfw.h
+linux-x.x.x/include/soc/imx8/sc/sci.h
+linux-x.x.x/include/soc/imx8/sc/types.h
+linux-x.x.x/include/soc/imx8/soc.h
+linux-x.x.x/include/uapi/drm/drm_fourcc.h
+linux-x.x.x/include/uapi/drm/drm.h
+linux-x.x.x/include/uapi/drm/drm_mode.h
+linux-x.x.x/include/uapi/linux/byteorder/little_endian.h
+linux-x.x.x/include/uapi/linux/cec.h
+linux-x.x.x/include/uapi/linux/fb.h
+linux-x.x.x/include/uapi/linux/i2c.h
+linux-x.x.x/include/uapi/linux/media-bus-format.h
+linux-x.x.x/include/uapi/linux/swab.h
+linux-x.x.x/include/video/display_timing.h
+linux-x.x.x/include/video/of_videomode.h
+linux-x.x.x/include/video/videomode.h
+linux-x.x.x/include/video/viv-metadata.h
+linux-x.x.x/include/video/imx-dcss.h
+linux-x.x.x/lib/idr.c
+linux-x.x.x/lib/list_sort.c
+linux-x.x.x/lib/radix-tree.c
+linux-x.x.x/lib/rbtree.c
diff --git a/repos/dde_linux/lib/import/import-imx8_fb_include.mk b/repos/dde_linux/lib/import/import-imx8_fb_include.mk
new file mode 100644
index 000000000..71e9053c8
--- /dev/null
+++ b/repos/dde_linux/lib/import/import-imx8_fb_include.mk
@@ -0,0 +1,22 @@
+LX_CONTRIB_DIR := $(call select_from_ports,dde_linux)/src/drivers/framebuffer/imx8
+SRC_DIR        := $(REP_DIR)/src/drivers/framebuffer/imx8
+
+# architecture-dependent includes
+ifeq ($(filter-out $(SPECS),arm_64),)
+  ARCH_SRC_INC_DIR += $(REP_DIR)/src/include/spec/arm_64 \
+                      $(LX_CONTRIB_DIR)/arch/arm64/include \
+                      $(LX_CONTRIB_DIR)/arch/arm64/include/uapi \
+                      $(LX_CONTRIB_DIR)/arch/arm64/include/generated \
+                      $(LX_CONTRIB_DIR)/arch/arm64/include/generated/uapi
+endif # arm_64
+
+INC_DIR += $(SRC_DIR)/include \
+           $(REP_DIR)/src/include \
+           $(ARCH_SRC_INC_DIR) \
+           $(LX_CONTRIB_DIR)/drivers/gpu/drm \
+           $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx \
+           $(LX_CONTRIB_DIR)/include \
+           $(LX_CONTRIB_DIR)/include/uapi \
+           $(LIB_CACHE_DIR)/imx8_fb_include/include/include/include
+
+CC_OPT += -U__linux__ -D__KERNEL__
diff --git a/repos/dde_linux/lib/mk/spec/arm_64/imx8_fb_drv.mk b/repos/dde_linux/lib/mk/spec/arm_64/imx8_fb_drv.mk
new file mode 100644
index 000000000..d177acfca
--- /dev/null
+++ b/repos/dde_linux/lib/mk/spec/arm_64/imx8_fb_drv.mk
@@ -0,0 +1,47 @@
+LX_CONTRIB_DIR := $(call select_from_ports,dde_linux)/src/drivers/framebuffer/imx8
+SRC_DIR        := $(REP_DIR)/src/drivers/framebuffer/imx8
+
+LIBS    += imx8_fb_include
+
+SRC_C   :=
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/dma-buf/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/i2c/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/base/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/gpu/drm/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx/dcss/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx/hdp/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/gpu/imx/dcss/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/irqchip/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/mxc/hdp/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/drivers/video/*.c))
+SRC_C   += $(notdir $(wildcard $(LX_CONTRIB_DIR)/lib/*.c))
+
+#
+# Linux sources are C89 with GNU extensions
+#
+CC_C_OPT += -std=gnu89
+
+#
+# Reduce build noise of compiling contrib code
+#
+CC_WARN = -Wall -Wno-uninitialized -Wno-unused-but-set-variable \
+          -Wno-unused-variable -Wno-unused-function \
+          -Wno-pointer-arith -Wno-pointer-sign \
+          -Wno-int-to-pointer-cast -Wno-stringop-truncation
+
+vpath %.c $(LX_CONTRIB_DIR)/drivers/base
+vpath %.c $(LX_CONTRIB_DIR)/drivers/dma-buf
+vpath %.c $(LX_CONTRIB_DIR)/drivers/i2c
+vpath %.c $(LX_CONTRIB_DIR)/drivers/gpu/drm
+vpath %.c $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx
+vpath %.c $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx/dcss
+vpath %.c $(LX_CONTRIB_DIR)/drivers/gpu/drm/imx/hdp
+vpath %.c $(LX_CONTRIB_DIR)/drivers/gpu/imx/dcss
+vpath %.c $(LX_CONTRIB_DIR)/drivers/irqchip
+vpath %.c $(LX_CONTRIB_DIR)/drivers/mxc/hdp
+vpath %.c $(LX_CONTRIB_DIR)/drivers/video
+vpath %.c $(LX_CONTRIB_DIR)/lib
+
+
+CC_CXX_WARN_STRICT =
diff --git a/repos/dde_linux/lib/mk/spec/arm_64/imx8_fb_include.mk b/repos/dde_linux/lib/mk/spec/arm_64/imx8_fb_include.mk
new file mode 100644
index 000000000..e9a3112cf
--- /dev/null
+++ b/repos/dde_linux/lib/mk/spec/arm_64/imx8_fb_include.mk
@@ -0,0 +1,37 @@
+#
+# Pseudo library to generate a symlink for each header file included by the
+# contrib code. Each symlink points to the same 'lx_emul.h' file, which
+# provides our emulation of the Linux kernel API.
+#
+
+ifeq ($(called_from_lib_mk),yes)
+
+LX_CONTRIB_DIR := $(call select_from_ports,dde_linux)/src/drivers/framebuffer/imx8
+LX_EMUL_H      := $(REP_DIR)/src/drivers/framebuffer/imx8/include/lx_emul.h
+
+#
+# Determine the header files included by the contrib code. For each
+# of these header files we create a symlink to 'lx_emul.h'.
+#
+SCAN_DIRS := $(addprefix $(LX_CONTRIB_DIR)/include/, asm-generic drm linux soc uapi video) \
+             $(addprefix $(LX_CONTRIB_DIR)/, drivers lib)
+GEN_INCLUDES := $(shell grep -rIh "^\#include .*" $(SCAN_DIRS) |\
+                        sed "s/^\#include [^<\"]*[<\"]\([^>\"]*\)[>\"].*/\1/" |\
+                        sort | uniq)
+
+#
+# Put Linux headers in 'GEN_INC' dir, since some include use "../../" paths use
+# three level include hierarchy
+#
+GEN_INC         := $(shell pwd)/include/include/include
+GEN_INCLUDES    := $(addprefix $(GEN_INC)/,$(GEN_INCLUDES))
+
+all: $(GEN_INCLUDES)
+
+$(GEN_INCLUDES):
+	$(VERBOSE)mkdir -p $(dir $@)
+	$(VERBOSE)ln -sf $(LX_EMUL_H) $@
+
+endif
+
+CC_CXX_WARN_STRICT =
diff --git a/repos/dde_linux/patches/imx8_fb_dcss_blkctl.patch b/repos/dde_linux/patches/imx8_fb_dcss_blkctl.patch
new file mode 100644
index 000000000..66a974f36
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_dcss_blkctl.patch
@@ -0,0 +1,23 @@
+dcss_blkctl.patch
+
+diff --git a/drivers/gpu/imx/dcss/dcss-blkctl.c b/drivers/gpu/imx/dcss/dcss-blkctl.c
+index 2f13b33..63d48bf 100644
+--- a/drivers/gpu/imx/dcss/dcss-blkctl.c
++++ b/drivers/gpu/imx/dcss/dcss-blkctl.c
+@@ -115,10 +115,14 @@ int dcss_blkctl_init(struct dcss_soc *dcss, unsigned long blkctl_base)
+ 	disp_dev = of_get_property(node, "disp-dev", &len);
+ 	if (!disp_dev || !strncmp(disp_dev, "hdmi_disp", 9))
+ 		blkctl->hdmi_output = true;
+-
++#if 0
++	/*
++	 * XXX: for some reason 'HDMI_MIPI_CLK_SEL' does not work with SOC revision
++	 *      0x20 and Genode
++	 */
+ 	if (imx8_get_soc_revision() >= B0_SILICON_ID)
+ 		blkctl->clk_setting = HDMI_MIPI_CLK_SEL;
+-
++#endif
+ 	dcss_blkctl_cfg(dcss);
+ 
+ 	return 0;
diff --git a/repos/dde_linux/patches/imx8_fb_dcss_common.patch b/repos/dde_linux/patches/imx8_fb_dcss_common.patch
new file mode 100644
index 000000000..7ccd42503
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_dcss_common.patch
@@ -0,0 +1,23 @@
+dcss_common.patch
+
+diff --git a/drivers/gpu/imx/dcss/dcss-common.c b/drivers/gpu/imx/dcss/dcss-common.c
+index cb15533..90b6b4d 100644
+--- a/drivers/gpu/imx/dcss/dcss-common.c
++++ b/drivers/gpu/imx/dcss/dcss-common.c
+@@ -19,6 +19,7 @@
+ #include <linux/clk.h>
+ #include <linux/pm_runtime.h>
+ #include <linux/busfreq-imx.h>
++#include <linux/mod_devicetable.h>
+ #include <linux/pm_qos.h>
+ #include <video/imx-dcss.h>
+ 
+@@ -43,7 +44,7 @@ struct dcss_devtype {
+ 	u32 pll_base;
+ };
+ 
+-static struct dcss_devtype dcss_type_imx8m = {
++/*static*/ struct dcss_devtype dcss_type_imx8m = {
+ 	.name = "DCSS_imx8m",
+ 	.blkctl_ofs = 0x2F000,
+ 	.ctxld_ofs = 0x23000,
diff --git a/repos/dde_linux/patches/imx8_fb_dcss_ctxld.patch b/repos/dde_linux/patches/imx8_fb_dcss_ctxld.patch
new file mode 100644
index 000000000..5eb351f96
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_dcss_ctxld.patch
@@ -0,0 +1,15 @@
+dcss_ctxld.patch
+
+diff --git a/drivers/gpu/imx/dcss/dcss-ctxld.c b/drivers/gpu/imx/dcss/dcss-ctxld.c
+index 377a102..1e7a7cf 100644
+--- a/drivers/gpu/imx/dcss/dcss-ctxld.c
++++ b/drivers/gpu/imx/dcss/dcss-ctxld.c
+@@ -275,7 +275,7 @@ int dcss_ctxld_init(struct dcss_soc *dcss, unsigned long ctxld_base)
+ 	}
+ 
+ 	ret = dcss_ctxld_irq_config(priv);
+-	if (!ret)
++	if (ret)
+ 		return ret;
+ 
+ 	dcss_ctxld_hw_cfg(dcss);
diff --git a/repos/dde_linux/patches/imx8_fb_dcss_scaler.patch b/repos/dde_linux/patches/imx8_fb_dcss_scaler.patch
new file mode 100644
index 000000000..4b5d733bb
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_dcss_scaler.patch
@@ -0,0 +1,15 @@
+dcss_scaler.patch
+
+diff --git a/drivers/gpu/imx/dcss/dcss-scaler.c b/drivers/gpu/imx/dcss/dcss-scaler.c
+index 051bc4b..fc7b2e3 100644
+--- a/drivers/gpu/imx/dcss/dcss-scaler.c
++++ b/drivers/gpu/imx/dcss/dcss-scaler.c
+@@ -332,7 +332,7 @@ static int dcss_scaler_ch_init_all(struct dcss_soc *dcss,
+ 
+ 		ch->base_ofs = scaler_base + i * 0x400;
+ 
+-		ch->base_reg = devm_ioremap(dcss->dev, ch->base_ofs, SZ_4K);
++		ch->base_reg = devm_ioremap(dcss->dev, ch->base_ofs, 0x400);
+ 		if (!ch->base_reg) {
+ 			dev_err(dcss->dev, "scaler: unable to remap ch base\n");
+ 			return -ENOMEM;
diff --git a/repos/dde_linux/patches/imx8_fb_drm_connector.patch b/repos/dde_linux/patches/imx8_fb_drm_connector.patch
new file mode 100644
index 000000000..5adbf5956
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_drm_connector.patch
@@ -0,0 +1,26 @@
+drm_connector.patch
+
+diff --git a/drivers/gpu/drm/drm_connector.c b/drivers/gpu/drm/drm_connector.c
+index 0986447..d54c1cd 100644
+--- a/drivers/gpu/drm/drm_connector.c
++++ b/drivers/gpu/drm/drm_connector.c
+@@ -525,7 +525,9 @@ void drm_connector_list_iter_begin(struct drm_device *dev,
+ {
+ 	iter->dev = dev;
+ 	iter->conn = NULL;
++#ifdef CONFIG_LOCKDEP
+ 	lock_acquire_shared_recursive(&connector_list_iter_dep_map, 0, 1, NULL, _RET_IP_);
++#endif
+ }
+ EXPORT_SYMBOL(drm_connector_list_iter_begin);
+ 
+@@ -581,7 +583,9 @@ void drm_connector_list_iter_end(struct drm_connector_list_iter *iter)
+ 	iter->dev = NULL;
+ 	if (iter->conn)
+ 		drm_connector_put(iter->conn);
++#ifdef CONFIG_LOCKDEP
+ 	lock_release(&connector_list_iter_dep_map, 0, _RET_IP_);
++#endif
+ }
+ EXPORT_SYMBOL(drm_connector_list_iter_end);
+ 
diff --git a/repos/dde_linux/patches/imx8_fb_drm_edid.patch b/repos/dde_linux/patches/imx8_fb_drm_edid.patch
new file mode 100644
index 000000000..282293340
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_drm_edid.patch
@@ -0,0 +1,15 @@
+drm_edid.patch
+
+diff --git a/include/drm/drm_edid.h b/include/drm/drm_edid.h
+index 6f1410b..c874409 100644
+--- a/include/drm/drm_edid.h
++++ b/include/drm/drm_edid.h
+@@ -345,7 +345,7 @@ struct edid *drm_load_edid_firmware(struct drm_connector *connector);
+ static inline struct edid *
+ drm_load_edid_firmware(struct drm_connector *connector)
+ {
+-	return ERR_PTR(-ENOENT);
++	return (struct edid *)ERR_PTR(-ENOENT);
+ }
+ #endif
+ 
diff --git a/repos/dde_linux/patches/imx8_fb_drm_mm.patch b/repos/dde_linux/patches/imx8_fb_drm_mm.patch
new file mode 100644
index 000000000..3c4f45536
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_drm_mm.patch
@@ -0,0 +1,27 @@
+drm_mm.patch
+
+diff --git a/drivers/gpu/drm/drm_mm.c b/drivers/gpu/drm/drm_mm.c
+index 1acf3b1..7fd72a0 100644
+--- a/drivers/gpu/drm/drm_mm.c
++++ b/drivers/gpu/drm/drm_mm.c
+@@ -48,6 +48,7 @@
+ #include <linux/seq_file.h>
+ #include <linux/export.h>
+ #include <linux/interval_tree_generic.h>
++#include <linux/math64.h>
+ 
+ /**
+  * DOC: Overview
+diff --git a/include/drm/drm_mm.h b/include/drm/drm_mm.h
+index 8d10fc9..452977c 100644
+--- a/include/drm/drm_mm.h
++++ b/include/drm/drm_mm.h
+@@ -423,7 +423,7 @@ static inline int drm_mm_insert_node(struct drm_mm *mm,
+ 				     struct drm_mm_node *node,
+ 				     u64 size)
+ {
+-	return drm_mm_insert_node_generic(mm, node, size, 0, 0, 0);
++	return drm_mm_insert_node_generic(mm, node, size, 0, 0, DRM_MM_INSERT_BEST);
+ }
+ 
+ void drm_mm_remove_node(struct drm_mm_node *node);
diff --git a/repos/dde_linux/patches/imx8_fb_drm_vblank.patch b/repos/dde_linux/patches/imx8_fb_drm_vblank.patch
new file mode 100644
index 000000000..08b029495
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_drm_vblank.patch
@@ -0,0 +1,14 @@
+drm_vblank.patch
+
+diff --git a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c
+index c2f23a6..f1bc5df 100644
+--- a/drivers/gpu/drm/drm_vblank.c
++++ b/drivers/gpu/drm/drm_vblank.c
+@@ -27,6 +27,7 @@
+ #include <drm/drm_vblank.h>
+ #include <drm/drmP.h>
+ #include <linux/export.h>
++#include <linux/math64.h>
+ 
+ #include "drm_trace.h"
+ #include "drm_internal.h"
diff --git a/repos/dde_linux/patches/imx8_fb_fb.patch b/repos/dde_linux/patches/imx8_fb_fb.patch
new file mode 100644
index 000000000..8adeb5fd8
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_fb.patch
@@ -0,0 +1,45 @@
+fb.patch
+
+diff --git a/include/linux/fb.h b/include/linux/fb.h
+index bc24e48..5cc1e2a 100644
+--- a/include/linux/fb.h
++++ b/include/linux/fb.h
+@@ -461,6 +461,16 @@ struct fb_tile_ops {
+    output like oopses */
+ #define FBINFO_CAN_FORCE_OUTPUT     0x200000
+ 
++struct aperture {
++	resource_size_t base;
++	resource_size_t size;
++};
++
++struct apertures_struct {
++	unsigned int count;
++	struct aperture ranges[0];
++};
++
+ struct fb_info {
+ 	atomic_t count;
+ 	int node;
+@@ -514,19 +524,13 @@ struct fb_info {
+ 	/* 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;
++	struct apertures_struct *apertures;
+ 
+ 	bool skip_vt_switch; /* no VT switch on suspend/resume required */
+ };
+ 
+ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
+-	struct apertures_struct *a = kzalloc(sizeof(struct apertures_struct)
++	struct apertures_struct *a = (struct apertures_struct*)kzalloc(sizeof(struct apertures_struct)
+ 			+ max_num * sizeof(struct aperture), GFP_KERNEL);
+ 	if (!a)
+ 		return NULL;
diff --git a/repos/dde_linux/patches/imx8_fb_imx_drm_core.patch b/repos/dde_linux/patches/imx8_fb_imx_drm_core.patch
new file mode 100644
index 000000000..dfef7cb5c
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_imx_drm_core.patch
@@ -0,0 +1,53 @@
+imx_drm_core.patch
+
+diff --git a/drivers/gpu/drm/imx/imx-drm-core.c b/drivers/gpu/drm/imx/imx-drm-core.c
+index 76b782c..a2c3a76 100644
+--- a/drivers/gpu/drm/imx/imx-drm-core.c
++++ b/drivers/gpu/drm/imx/imx-drm-core.c
+@@ -43,7 +43,9 @@ static void imx_drm_driver_lastclose(struct drm_device *drm)
+ {
+ 	struct imx_drm_device *imxdrm = drm->dev_private;
+ 
++#if IS_ENABLED(CONFIG_DRM_FBDEV_EMULATION)
+ 	drm_fbdev_cma_restore_mode(imxdrm->fbhelper);
++#endif
+ }
+ 
+ DEFINE_DRM_GEM_CMA_FOPS(imx_drm_driver_fops);
+@@ -120,6 +122,17 @@ static int compare_of(struct device *dev, void *data)
+ {
+ 	struct device_node *np = data;
+ 
++	if ((strncmp(dev->driver->name, "imx-dcss-crtc", strlen(dev->driver->name)) == 0) &&
++	    (strncmp(np->name, "port", strlen(np->name)) == 0))
++		return 1;
++
++	if ((strncmp(dev->driver->name, "i.mx8-hdp", strlen(dev->driver->name)) == 0) &&
++	    (strncmp(np->name, "hdmi", strlen(np->name)) == 0))
++		return 1;
++
++	return 0;
++
++#if 0
+ 	/* Special case for DI, dev->of_node may not be set yet */
+ 	if (strcmp(dev->driver->name, "imx-ipuv3-crtc") == 0) {
+ 		struct ipu_client_platformdata *pdata = dev->platform_data;
+@@ -161,6 +174,7 @@ static int compare_of(struct device *dev, void *data)
+ 	}
+ 
+ 	return dev->of_node == np;
++#endif
+ }
+ 
+ static const char *const imx_drm_dpu_comp_parents[] = {
+@@ -416,8 +430,10 @@ static void imx_drm_unbind(struct device *dev)
+ 
+ 	drm_kms_helper_poll_fini(drm);
+ 
++#if IS_ENABLED(CONFIG_DRM_FBDEV_EMULATION)
+ 	if (imxdrm->fbhelper)
+ 		drm_fbdev_cma_fini(imxdrm->fbhelper);
++#endif
+ 
+ 	drm_mode_config_cleanup(drm);
+ 
diff --git a/repos/dde_linux/patches/imx8_fb_imx_hdcp.patch b/repos/dde_linux/patches/imx8_fb_imx_hdcp.patch
new file mode 100644
index 000000000..378600fb0
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_imx_hdcp.patch
@@ -0,0 +1,28 @@
+imx_hdcp.patch
+
+diff --git a/drivers/gpu/drm/imx/hdp/imx-hdcp.c b/drivers/gpu/drm/imx/hdp/imx-hdcp.c
+index 4f10737..0f5665a 100644
+--- a/drivers/gpu/drm/imx/hdp/imx-hdcp.c
++++ b/drivers/gpu/drm/imx/hdp/imx-hdcp.c
+@@ -527,6 +527,12 @@ int imx_hdcp_init(struct imx_hdp *hdp, struct device_node *of_node)
+ 	int ret;
+ 	const char *compat;
+ 	u32 temp;
++	
++	/*
++	 * 'imx_hdcp_disable()' is called regardless of -EPERM early return
++	 * and needs an initialized mutex on Genode
++	 */
++	mutex_init(&hdp->hdcp.mutex);
+ 
+ 	ret = of_property_read_string(of_node, "compatible", &compat);
+ 	if (ret) {
+@@ -561,7 +567,7 @@ int imx_hdcp_init(struct imx_hdp *hdp, struct device_node *of_node)
+ 		return ret;
+ 
+ 	/*connector->hdcp_shim = hdcp_shim;*/
+-	mutex_init(&hdp->hdcp.mutex);
++	/*mutex_init(&hdp->hdcp.mutex);*/
+ 	INIT_DELAYED_WORK(&hdp->hdcp.check_work, imx_hdcp_check_work);
+ 	INIT_WORK(&hdp->hdcp.prop_work, imx_hdcp_prop_work);
+ 	return 0;
diff --git a/repos/dde_linux/patches/imx8_fb_imx_hdp.patch b/repos/dde_linux/patches/imx8_fb_imx_hdp.patch
new file mode 100644
index 000000000..f5f66e0e9
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_imx_hdp.patch
@@ -0,0 +1,26 @@
+imx_hdp.patch
+
+diff --git a/drivers/gpu/drm/imx/hdp/imx-hdp.c b/drivers/gpu/drm/imx/hdp/imx-hdp.c
+index bcfad52..0ed949a 100644
+--- a/drivers/gpu/drm/imx/hdp/imx-hdp.c
++++ b/drivers/gpu/drm/imx/hdp/imx-hdp.c
+@@ -1478,10 +1478,19 @@ static int imx_hdp_imx_bind(struct device *dev, struct device *master,
+ 		return -EINVAL;
+ 	}
+ 
++#if 0
+ 	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+ 	hdp->mem.rst_base = devm_ioremap_resource(dev, res);
+ 	if (IS_ERR(hdp->mem.rst_base))
+ 		dev_warn(dev, "Failed to get HDP RESET base register\n");
++#else
++	/*
++	 * On Genode, the requested address range is already mapped by a different
++	 * part of the driver and cannot be mapped again. Fortunately, not mapping
++	 * it here didn't show problems so far.
++	 */
++	hdp->mem.rst_base = 0;
++#endif
+ 
+ 	hdp->is_cec = of_property_read_bool(pdev->dev.of_node, "fsl,cec");
+ 
diff --git a/repos/dde_linux/patches/imx8_fb_irq_imx_irqsteer.patch b/repos/dde_linux/patches/imx8_fb_irq_imx_irqsteer.patch
new file mode 100644
index 000000000..bdc6a2a7a
--- /dev/null
+++ b/repos/dde_linux/patches/imx8_fb_irq_imx_irqsteer.patch
@@ -0,0 +1,14 @@
+irq_imx_irqsteer.patch
+
+diff --git a/drivers/irqchip/irq-imx-irqsteer.c b/drivers/irqchip/irq-imx-irqsteer.c
+index e26d242..1b2334b 100644
+--- a/drivers/irqchip/irq-imx-irqsteer.c
++++ b/drivers/irqchip/irq-imx-irqsteer.c
+@@ -13,6 +13,7 @@
+ #include <linux/irq.h>
+ #include <linux/irqchip/chained_irq.h>
+ #include <linux/irqdomain.h>
++#include <linux/mod_devicetable.h>
+ #include <linux/of_platform.h>
+ #include <linux/spinlock.h>
+ #include <linux/pm_runtime.h>
diff --git a/repos/dde_linux/ports/dde_linux.hash b/repos/dde_linux/ports/dde_linux.hash
index 492443ae1..a033b2de3 100644
--- a/repos/dde_linux/ports/dde_linux.hash
+++ b/repos/dde_linux/ports/dde_linux.hash
@@ -1 +1 @@
-8d086553e63be398b2e00ffa093fb4d44d6e746d
+173719007927a108a9558e727b8c9b388f3159a2
diff --git a/repos/dde_linux/ports/dde_linux.port b/repos/dde_linux/ports/dde_linux.port
index ac40d0134..75210c15c 100644
--- a/repos/dde_linux/ports/dde_linux.port
+++ b/repos/dde_linux/ports/dde_linux.port
@@ -3,7 +3,7 @@ VERSION     := 2
 DOWNLOADS   := dwc_otg.git usb.archive intel_fb.archive lxip.archive \
                wifi.archive fec.archive libnl.archive wpa_supplicant.git \
                fw.archive usb_host.archive dwc_otg_host.git usb_hid.archive \
-               usb_net.archive
+               usb_net.archive imx8_fb.archive
 
 #
 # Tools
@@ -116,6 +116,16 @@ DIR(fec)     := $(SRC_DIR_FEC)
 TAR_OPT(fec) := --strip-components=1  --files-from - < <(sed 's/-x.x.x/-$(VERSION_FEC)/g'     $(REP_DIR)/fec.list)
 HASH_INPUT   += $(REP_DIR)/fec.list
 
+#
+# i.MX8 Framebuffer driver
+#
+SRC_DIR_IMX8_FB  := src/drivers/framebuffer/imx8
+URL(imx8_fb)     := https://github.com/Freescale/linux-fslc/tarball/1ddf624
+NAME(imx8_fb)    := linux-4.14-2.0.x-imx.tgz
+SHA(imx8_fb)     := 879219874f74b420f2f49f197d418d800ad3b716b9cc3d2d7b85a6fbf2296928
+TAR_OPT(imx8_fb) := --strip-components=1 --files-from - < <(sed 's/linux-x.x.x/Freescale-linux-fslc-1ddf624/g' $(REP_DIR)/imx8_fb.list)
+DIR(imx8_fb)     := $(SRC_DIR_IMX8_FB)
+
 #
 # libnl sources
 #
@@ -151,6 +161,7 @@ PATCHES += $(addprefix patches/,$(notdir $(wildcard $(REP_DIR)/patches/usb*.patc
 PATCHES += $(addprefix patches/,$(notdir $(wildcard $(REP_DIR)/patches/intel*.patch)))
 PATCHES += $(addprefix patches/,$(notdir $(wildcard $(REP_DIR)/patches/fec_*.patch)))
 PATCHES += $(addprefix patches/,$(notdir $(wildcard $(REP_DIR)/patches/usb_hid*.patch)))
+PATCHES += $(addprefix patches/,$(notdir $(wildcard $(REP_DIR)/patches/imx8_fb*.patch)))
 
 #IP stack
 LXIP_OPT = -p1 -d$(SRC_DIR_LXIP)
@@ -212,4 +223,20 @@ PATCH_OPT(patches/fec_skbuff_cast.patch) := -p1 -d$(SRC_DIR_FEC)
 PATCH_OPT(patches/fec_tx_bounce_dma.patch) := -p1 -d$(SRC_DIR_FEC)
 PATCH_OPT(patches/fec_ndev_owner.patch) := -p1 -d$(SRC_DIR_FEC)
 
+# Freescale i.MX8 framebuffer
+IMX8_FB_OPT = -p1 -d$(SRC_DIR_IMX8_FB)
+PATCH_OPT(patches/imx8_fb_dcss_blkctl.patch)      := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_dcss_common.patch)      := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_dcss_ctxld.patch)       := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_dcss_scaler.patch)      := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_drm_connector.patch)    := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_drm_edid.patch)         := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_drm_mm.patch)           := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_drm_vblank.patch)       := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_fb.patch)               := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_imx_drm_core.patch)     := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_imx_hdcp.patch)         := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_imx_hdp.patch)          := $(IMX8_FB_OPT)
+PATCH_OPT(patches/imx8_fb_irq_imx_irqsteer.patch) := $(IMX8_FB_OPT)
+
 # vi: set ft=make :
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/README b/repos/dde_linux/src/drivers/framebuffer/imx8/README
new file mode 100644
index 000000000..194ae5c84
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/README
@@ -0,0 +1,36 @@
+This driver is for the i.MX8MQ EVK Board.
+
+Default behaviour
+~~~~~~~~~~~~~~~~~
+When no configuration is provided to the driver, it will enable the HDMI
+connector and use the best resolution as provided by EDID information from
+the HDMI display.
+
+Configuration
+~~~~~~~~~~~~~
+The HDMI connector can be configured explicitly in terms of resolution and
+whether it should be enabled or not. This looks like the following:
+
+! <config>
+!   <connector name="HDMI-A-1" width="1920" height="1080" hz="60" enabled="true"/>
+! </config>
+
+When the configuration changes during run-time, the driver will adapt to it.
+
+To present all available connectors and their possible resolutions to the user
+the driver is able to export a corresponding report ROM. This has to be
+configured too, like in the following:
+
+! <config>
+!   <report connectors="yes"/>
+! </config>
+
+The exported report has the following format:
+
+! <connectors>
+!   <connector name="HDMI-A-1" connected="1">
+!     <mode width="1920" height="1080" hz="60"/>
+!     ...
+!   </connector>
+! </connectors>
+
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/dummies.c b/repos/dde_linux/src/drivers/framebuffer/imx8/dummies.c
new file mode 100644
index 000000000..685980f5c
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/dummies.c
@@ -0,0 +1,743 @@
+#include <lx_emul.h>
+#include <lx_emul_c.h>
+
+#include <drm/drm_device.h>
+#include <drm/drm_gem.h>
+#include <linux/component.h>
+#include <linux/irqdomain.h>
+#include <linux/irqhandler.h>
+#include <linux/ratelimit.h>
+#include <soc/imx8/sc/types.h>
+#include <uapi/linux/i2c.h>
+
+
+/************************
+ ** drivers/base/bus.c **
+ ************************/
+
+int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
+                     void *data, int (*fn)(struct device_driver *, void *))
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/*************************
+ ** drivers/base/core.c **
+ *************************/
+
+int device_for_each_child(struct device *dev, void *data,
+                          int (*fn)(struct device *dev, void *data))
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int device_register(struct device *dev)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/********************************
+ ** drivers/base/dma-mapping.c **
+ ********************************/
+
+void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
+                        dma_addr_t dma_handle)
+{
+	TRACE_AND_STOP;
+}
+
+
+/*****************************
+ ** drivers/base/platform.c **
+ *****************************/
+
+int platform_device_put(struct platform_device *pdev)
+{
+	TRACE_AND_STOP;
+	return 0;
+}
+
+void platform_device_unregister(struct platform_device *pdev)
+{
+	TRACE_AND_STOP;
+}
+
+
+/*****************************
+ ** drivers/base/property.c **
+ *****************************/
+
+int device_add_properties(struct device *dev, const struct property_entry *properties)
+{
+	TRACE_AND_STOP;
+}
+
+void device_remove_properties(struct device *dev)
+{
+	TRACE_AND_STOP;
+}
+
+
+/***********************
+ ** drivers/clk/clk.c **
+ ***********************/
+
+struct clk *clk_get_parent(struct clk *clk)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+bool clk_is_match(const struct clk *p, const struct clk *q)
+{
+	TRACE_AND_STOP;
+	return false;
+}
+
+int clk_set_parent(struct clk *clk, struct clk *parent)
+{
+	TRACE;
+	return 0;
+}
+
+
+/*******************************
+ ** drivers/gpu/drm/drm_drv.c **
+ *******************************/
+
+void drm_dev_unref(struct drm_device *dev)
+{
+	TRACE_AND_STOP;
+}
+
+void drm_dev_unregister(struct drm_device *dev)
+{
+	TRACE_AND_STOP;
+}
+
+
+/*****************************************
+ ** drivers/gpu/drm/drm_fb_cma_helper.c **
+ *****************************************/
+
+struct drm_framebuffer *drm_fb_cma_create(struct drm_device *dev,
+                                          struct drm_file *file_priv,
+                                          const struct drm_mode_fb_cmd2 *mode_cmd)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+struct drm_fbdev_cma;
+
+void drm_fbdev_cma_hotplug_event(struct drm_fbdev_cma *fbdev_cma)
+{
+	TRACE;
+}
+
+
+/*******************************
+ ** drivers/i2c/i2c-core-of.c **
+ *******************************/
+
+struct i2c_adapter;
+
+void of_i2c_register_devices(struct i2c_adapter *adap)
+{
+	TRACE_AND_STOP;
+}
+
+
+/**********************************
+ ** drivers/i2c/i2c-core-smbus.c **
+ **********************************/
+
+struct i2c_adapter;
+
+s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
+		   char read_write, u8 command, int protocol,
+		   union i2c_smbus_data *data) {
+	TRACE_AND_STOP;
+}
+
+
+/***********************
+ ** drivers/of/base.c **
+ ***********************/
+
+bool of_device_is_available(const struct device_node *device)
+{
+	return device;
+}
+
+
+/**************************
+ ** drivers/of/dynamic.c **
+ **************************/
+
+struct device_node *of_node_get(struct device_node *node)
+{
+	TRACE;
+	return node;
+}
+
+void of_node_put(struct device_node *node)
+{
+	TRACE;
+}
+
+
+/***********************************
+ ** drivers/soc/imx/sc/main/ipc.c **
+ ***********************************/
+
+int sc_ipc_getMuID(uint32_t *mu_id)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void sc_ipc_close(sc_ipc_t handle)
+{
+	TRACE_AND_STOP;
+}
+
+sc_err_t sc_ipc_open(sc_ipc_t *handle, uint32_t id)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/********************************************
+ ** drivers/soc/imx/sc/svc/misc/rpc_clnt.c **
+ ********************************************/
+
+sc_err_t sc_misc_set_control(sc_ipc_t ipc, sc_rsrc_t resource,
+                             sc_ctrl_t ctrl, uint32_t val)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/***********************
+ ** kernel/irq/chip.c **
+ ***********************/
+
+void handle_level_irq(struct irq_desc *desc)
+{
+	TRACE_AND_STOP;
+}
+
+void handle_simple_irq(struct irq_desc *desc)
+{
+	TRACE_AND_STOP;
+}
+
+void irq_chip_eoi_parent(struct irq_data *data)
+{
+	TRACE;
+}
+
+struct irq_data *irq_get_irq_data(unsigned int irq)
+{
+	TRACE_AND_STOP;
+}
+
+int irq_set_chip_data(unsigned int irq, void *data)
+{
+	TRACE;
+	return 0;
+}
+
+
+/****************************
+ ** kernel/irq/irqdomain.c **
+ ****************************/
+
+unsigned int irq_create_mapping(struct irq_domain *host, irq_hw_number_t hwirq)
+{
+	TRACE_AND_STOP;
+}
+
+int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
+                             const u32 *intspec, unsigned int intsize,
+                             irq_hw_number_t *out_hwirq, unsigned int *out_type)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/******************
+ ** lib/string.c **
+ ******************/
+
+char *strstr(const char * a0, const char * a1)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+
+/*****************
+ ** linux/clk.h **
+ *****************/
+
+void clk_disable_unprepare(struct clk *clk)
+{
+	TRACE;
+}
+
+int clk_prepare_enable(struct clk *clk)
+{
+	TRACE;
+	return 0;
+}
+
+
+/******************
+ ** linux/gpio.h **
+ ******************/
+
+void gpio_free(unsigned gpio)
+{
+	TRACE_AND_STOP;
+}
+
+int gpio_get_value(unsigned int gpio)
+{
+	TRACE_AND_STOP;
+}
+
+bool gpio_is_valid(int number)
+{
+	TRACE_AND_STOP;
+	return false;
+}
+
+int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
+{
+	TRACE_AND_STOP;
+}
+
+void gpio_set_value(unsigned int gpio, int value)
+{
+	TRACE_AND_STOP;
+}
+
+
+/*****************
+ ** linux/i2c.h **
+ *****************/
+
+struct i2c_client;
+
+const struct of_device_id *i2c_of_match_device(const struct of_device_id *matches,
+                                               struct i2c_client *client)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+
+/*****************
+ ** linux/irq.h **
+ *****************/
+
+void irq_set_status_flags(unsigned int irq, unsigned long set)
+{
+	TRACE;
+}
+
+void irqd_set_trigger_type(struct irq_data *d, u32 type)
+{
+	TRACE_AND_STOP;
+}
+
+
+/****************
+ ** linux/of.h **
+ ****************/
+
+bool is_of_node(const struct fwnode_handle *fwnode)
+{
+	TRACE_AND_STOP;
+	return false;
+}
+
+
+/************************
+ ** linux/pm_runtime.h **
+ ************************/
+
+int pm_runtime_get_sync(struct device *dev)
+{
+	TRACE;
+	return 0;
+}
+
+int pm_runtime_put_sync(struct device *dev)
+{
+	TRACE_AND_STOP;
+	return 0;
+}
+
+
+/**********************
+ ** linux/spinlock.h **
+ **********************/
+
+void assert_spin_locked(spinlock_t *lock)
+{
+	TRACE;
+}
+
+
+/*************************
+ ** linux/timekeeping.h **
+ *************************/
+
+ktime_t ktime_get_real(void)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/*************************
+ ** linux/dma-mapping.h **
+ *************************/
+
+int
+dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
+                      dma_addr_t dma_addr, size_t size,
+                      unsigned long attrs)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int dma_mmap_wc(struct device *dev,
+                struct vm_area_struct *vma,
+                void *cpu_addr, dma_addr_t dma_addr,
+                size_t size)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+
+/************************
+ ** linux/pm-runtime.h **
+ ************************/
+
+void pm_runtime_enable(struct device *dev)
+{
+	TRACE;
+}
+
+void pm_runtime_disable(struct device *dev)
+{
+	TRACE_AND_STOP;
+}
+
+int acpi_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *ev)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+bool acpi_driver_match_device(struct device *dev, const struct device_driver *drv)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+const char *acpi_dev_name(struct acpi_device *adev)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void destroy_workqueue(struct workqueue_struct *wq)
+{
+	TRACE_AND_STOP;
+}
+
+int device_init_wakeup(struct device *dev, bool val)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void down_read(struct rw_semaphore *sem)
+{
+	TRACE_AND_STOP;
+}
+
+struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
+                                     struct drm_gem_object *obj,
+                                     int flags)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+int drm_gem_prime_fd_to_handle(struct drm_device *dev, struct drm_file *file_priv, int prime_fd, uint32_t *handle)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int drm_gem_prime_handle_to_fd(struct drm_device *dev, struct drm_file *file_priv, uint32_t handle, uint32_t flags, int *prime_fd)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
+                                            struct dma_buf *dma_buf)
+{
+	TRACE_AND_STOP;
+	return NULL;
+}
+
+long drm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int drm_open(struct inode *inode, struct file *filp)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg)
+{
+	TRACE_AND_STOP;
+}
+
+ssize_t drm_read(struct file *filp, char __user *buffer, size_t count, loff_t *offset)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int drm_release(struct inode *inode, struct file *filp)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void ndelay(unsigned long ns)
+{
+	TRACE_AND_STOP;
+}
+
+loff_t noop_llseek(struct file *file, loff_t offset, int whence)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int of_alias_get_id(struct device_node *np, const char *stem)
+{
+	TRACE_AND_STOP;
+	return -ENOSYS;
+}
+
+int of_irq_get(struct device_node *dev, int index)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int of_irq_get_byname(struct device_node *dev, const char *name)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+pgprot_t pgprot_writecombine(pgprot_t prot)
+{
+	TRACE_AND_STOP;
+	return prot;
+}
+
+void print_hex_dump(const char *level, const char *prefix_str, int prefix_type, int rowsize, int groupsize, const void *buf, size_t len, bool ascii)
+{
+	TRACE;
+}
+
+int PTR_ERR_OR_ZERO(__force const void *ptr)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void up_read(struct rw_semaphore *sem)
+{
+	TRACE_AND_STOP;
+}
+
+pgprot_t vm_get_page_prot(unsigned long vm_flags)
+{
+	pgprot_t prot;
+	TRACE_AND_STOP;
+	return prot;
+}
+
+void ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+	TRACE_AND_STOP;
+}
+
+int  ww_mutex_lock_slow_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int  ww_mutex_trylock(struct ww_mutex *lock)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+int  ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+	TRACE_AND_STOP;
+	return -1;
+}
+
+void might_lock(struct mutex *m)
+{
+	TRACE;
+}
+
+void write_lock(rwlock_t *l)
+{
+	TRACE;
+}
+
+void write_unlock(rwlock_t *l)
+{
+	TRACE;
+}
+
+void read_lock(rwlock_t *l)
+{
+	TRACE_AND_STOP;
+}
+
+void read_unlock(rwlock_t *l)
+{
+	TRACE_AND_STOP;
+}
+
+void write_seqlock(seqlock_t *l)
+{
+	TRACE;
+}
+
+void write_sequnlock(seqlock_t *l)
+{
+	TRACE;
+}
+
+unsigned read_seqbegin(const seqlock_t *s)
+{
+	TRACE;
+	return 0;
+}
+
+unsigned read_seqretry(const seqlock_t *s, unsigned x)
+{
+	TRACE;
+	return 0;
+}
+
+struct dma_fence * reservation_object_get_excl_rcu(struct reservation_object *obj)
+{
+	TRACE;
+	return obj->fence_excl;
+}
+
+void rwlock_init(rwlock_t *rw)
+{
+	TRACE;
+}
+
+unsigned long vma_pages(struct vm_area_struct *p)
+{
+	TRACE_AND_STOP;
+	return 0;
+}
+
+void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *))
+{
+	TRACE;
+
+	func(head);
+}
+
+void seqlock_init (seqlock_t *s)
+{
+	TRACE;
+}
+
+void irq_domain_remove(struct irq_domain *d)
+{
+	TRACE_AND_STOP;
+}
+
+pgprot_t pgprot_decrypted(pgprot_t prot)
+{
+	TRACE_AND_STOP;
+	return prot;
+}
+
+void dma_buf_put(struct dma_buf *buf)
+{
+	TRACE_AND_STOP;
+}
+
+int ___ratelimit(struct ratelimit_state *rs, const char *func)
+{
+	TRACE_AND_STOP;
+	return 0;
+}
+
+bool _drm_lease_held(struct drm_file *f, int x)
+{
+	TRACE_AND_STOP;
+	return false;
+}
+
+long long atomic64_add_return(long long i, atomic64_t *p)
+{
+	TRACE;
+	p->counter += i;
+	return p->counter;
+}
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/include/component.h b/repos/dde_linux/src/drivers/framebuffer/imx8/include/component.h
new file mode 100644
index 000000000..d99688b81
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/include/component.h
@@ -0,0 +1,227 @@
+/*
+ * \brief  i.MX8 framebuffer driver session component
+ * \author Stefan Kalkowski
+ * \author Christian Prochaska
+ * \date   2015-10-16
+ */
+
+/*
+ * Copyright (C) 2015-2019 Genode Labs GmbH
+ *
+ * This file is distributed under the terms of the GNU General Public License
+ * version 2.
+ */
+
+#ifndef __COMPONENT_H__
+#define __COMPONENT_H__
+
+/* Genode includes */
+#include <base/component.h>
+#include <base/rpc_server.h>
+#include <root/component.h>
+#include <dataspace/capability.h>
+#include <framebuffer_session/framebuffer_session.h>
+#include <timer_session/connection.h>
+#include <util/reconstructible.h>
+#include <base/attached_dataspace.h>
+#include <base/attached_ram_dataspace.h>
+#include <base/attached_rom_dataspace.h>
+#include <os/reporter.h>
+#include <os/pixel_rgb565.h>
+#include <os/pixel_rgb888.h>
+#include <os/dither_painter.h>
+
+#include <lx_emul_c.h>
+
+namespace Framebuffer {
+	class Driver;
+	class Session_component;
+	class Root;
+}
+
+
+class Framebuffer::Driver
+{
+	private:
+
+		struct Configuration
+		{
+			struct lx_c_fb_config _lx = { 16, 64, 64, 4,
+			                              nullptr, 0, nullptr };
+		} _config;
+
+		Session_component             &_session;
+		Timer::Connection              _timer;
+		Genode::Reporter               _reporter;
+
+		Genode::Signal_context_capability _config_sigh;
+
+		drm_display_mode * _preferred_mode(drm_connector *connector,
+		                                   unsigned &brightness);
+
+	public:
+
+		Driver(Genode::Env & env, Session_component &session)
+		: _session(session), _timer(env),
+		  _reporter(env, "connectors") {}
+
+		int      width()   const { return _config._lx.width;  }
+		int      height()  const { return _config._lx.height; }
+		int      bpp()     const { return _config._lx.bpp;    }
+
+		void *   fb_addr() const { return _config._lx.addr;   }
+		unsigned pitch()   const { return _config._lx.pitch;  }
+
+		void finish_initialization();
+
+		void update_mode();
+
+		void generate_report();
+
+		/**
+		 * Register signal handler used for config updates
+		 *
+		 * The signal handler is artificially triggered as a side effect
+		 * of connector changes.
+		 */
+		void config_sigh(Genode::Signal_context_capability sigh)
+		{
+			_config_sigh = sigh;
+		}
+
+		void trigger_reconfiguration()
+		{
+			/*
+			 * Trigger the reprocessing of the configuration following the
+			 * same ontrol flow as used for external config changes.
+			 */
+			if (_config_sigh.valid())
+				Genode::Signal_transmitter(_config_sigh).submit();
+			else
+				Genode::warning("config signal handler unexpectedly undefined");
+		}
+};
+
+
+class Framebuffer::Session_component : public Genode::Rpc_object<Session>
+{
+	private:
+
+		template <typename T> using Lazy = Genode::Constructible<T>;
+
+		Driver                               _driver;
+		Genode::Attached_rom_dataspace      &_config;
+		Genode::Signal_context_capability    _mode_sigh;
+		Timer::Connection                    _timer;
+		Genode::Ram_allocator               &_ram;
+		Genode::Attached_ram_dataspace       _ds;
+		bool                                 _in_mode_change = true;
+
+	public:
+
+		Session_component(Genode::Env &env,
+		                  Genode::Attached_rom_dataspace &config)
+		: _driver(env, *this), _config(config), _timer(env),
+		  _ram(env.ram()), _ds(env.ram(), env.rm(), 0) {}
+
+		Driver & driver() { return _driver; }
+
+		void config_changed()
+		{
+			_config.update();
+			if (!_config.valid()) return;
+
+			_in_mode_change = true;
+
+			_driver.update_mode();
+
+			if (_mode_sigh.valid())
+				Genode::Signal_transmitter(_mode_sigh).submit();
+		}
+
+		Genode::Xml_node config() { return _config.xml(); }
+
+		int force_width_from_config()
+		{
+			return _config.xml().attribute_value<unsigned>("force_width", 0);
+		}
+
+		int force_height_from_config()
+		{
+			return _config.xml().attribute_value<unsigned>("force_height", 0);
+		}
+
+		/***********************************
+		 ** Framebuffer session interface **
+		 ***********************************/
+
+		Genode::Dataspace_capability dataspace() override
+		{
+			_ds.realloc(&_ram, _driver.width() * _driver.height() *
+			                   Mode::bytes_per_pixel(Mode::RGB565));
+			_in_mode_change = false;
+			return _ds.cap();
+		}
+
+		Mode mode() const override {
+			return Mode(_driver.width(), _driver.height(), Mode::RGB565); }
+
+		void mode_sigh(Genode::Signal_context_capability sigh) override {
+			_mode_sigh = sigh; }
+
+		void sync_sigh(Genode::Signal_context_capability sigh) override
+		{
+			_timer.sigh(sigh);
+			_timer.trigger_periodic(10*1000);
+		}
+
+		void refresh(int x, int y, int w, int h) override
+		{
+			using namespace Genode;
+
+			if (!_driver.fb_addr()         ||
+				!_ds.local_addr<void>() ||
+				_in_mode_change) return;
+
+			int width      = _driver.width();
+			int height     = _driver.height();
+
+			/* clip specified coordinates against screen boundaries */
+			int x2 = min(x + w - 1, width  - 1),
+			    y2 = min(y + h - 1, height - 1);
+			int x1 = max(x, 0),
+			    y1 = max(y, 0);
+			if (x1 > x2 || y1 > y2) return;
+
+			/* copy pixels from back buffer to physical frame buffer */
+			Genode::Pixel_rgb565 * src = _ds.local_addr<Genode::Pixel_rgb565>();
+			Genode::Pixel_rgb888 * dst = (Genode::Pixel_rgb888*)_driver.fb_addr();
+
+			for (int row = y1; row <= y2; row++) {
+				for (int col = x1; col <= x2; col++) {
+					Genode::Pixel_rgb565 px = src[width * row + col];
+					dst[width * row + col] = Genode::Pixel_rgb888(px.r(), px.g(), px.b(), px.a());
+				}
+			}
+		}
+};
+
+
+struct Framebuffer::Root
+: Genode::Root_component<Framebuffer::Session_component, Genode::Single_client>
+{
+	Session_component session; /* single session */
+
+	Session_component *_create_session(const char *) override {
+		return &session; }
+
+	void _destroy_session(Session_component *) override { }
+
+	Root(Genode::Env &env, Genode::Allocator &alloc,
+	     Genode::Attached_rom_dataspace &config)
+	: Genode::Root_component<Session_component,
+	                         Genode::Single_client>(env.ep(), alloc),
+	  session(env, config) { }
+};
+
+#endif /* __COMPONENT_H__ */
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/include/lx_emul.h b/repos/dde_linux/src/drivers/framebuffer/imx8/include/lx_emul.h
new file mode 100644
index 000000000..387ccbf11
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/include/lx_emul.h
@@ -0,0 +1,1753 @@
+/*
+ * \brief  Emulation of the Linux kernel API used by DRM
+ * \author Norman Feske
+ * \date   2015-08-19
+ *
+ * The content of this file, in particular data structures, is partially
+ * derived from Linux-internal headers.
+ */
+
+#ifndef _LX_EMUL_H_
+#define _LX_EMUL_H_
+
+#define DEBUG_LINUX_PRINTK 0
+#define DEBUG_DRIVER       0
+
+/* XXX: acquire from firmware if this becomes necessary */
+#define SOC_REVISION 0x20
+
+#include <stdarg.h>
+#include <base/fixed_stdint.h>
+
+#include <lx_emul/extern_c_begin.h>
+
+#include <lx_emul/irq.h>      /* dependency of lx_kit/irq.h */
+
+#include <lx_emul/atomic.h>   /* dependency of lx_emul/work.h */
+#include <lx_emul/compiler.h> /* dependency of lx_emul/kernel.h */
+#include <lx_emul/printf.h>   /* dependency of lx_emul/kernel.h */
+#include <lx_emul/kernel.h>   /* dependency of lx_emul/jiffies.h */
+#include <lx_emul/types.h>    /* dependency of lx_emul/jiffies.h */
+
+/*****************
+ ** asm/param.h **
+ *****************/
+
+enum { HZ = 100UL };          /* dependency of lx_emul/jiffies.h */
+
+
+#include <lx_emul/jiffies.h>  /* dependency of lx_emul/time.h */
+#include <lx_emul/time.h>     /* dependency of lx_emul/timer.h */
+
+
+/*******************
+ ** linux/timer.h **
+ *******************/
+
+typedef int clockid_t;        /* dependency of lx_emul/timer.h */
+
+#define from_timer(var, callback_timer, timer_fieldname) \
+	container_of(callback_timer, typeof(*var), timer_fieldname)
+
+struct timer_list;
+
+void setup_timer(struct timer_list *timer, void (*function)(unsigned long),
+                 unsigned long data);
+
+#include <lx_emul/timer.h>    /* dependency of lx_emul/work.h */
+#include <lx_emul/bitops.h>   /* dependency of lx_emul/work.h */
+
+
+/***********************
+ ** linux/interrupt.h **
+ ***********************/
+
+#define IRQF_TRIGGER_RISING	0x00000001
+#define IRQF_TRIGGER_HIGH	0x00000004
+
+#define IRQF_ONESHOT		0x00002000
+
+struct tasklet_struct         /* dependency of lx_kit/work.h */
+{
+	unsigned long state;
+	void (*func)(unsigned long);
+	unsigned long data;
+};
+
+struct device;
+
+int devm_request_irq(struct device *dev, unsigned int irq,
+                     irq_handler_t handler,
+                     unsigned long irqflags,
+                     const char *devname, void *dev_id);
+
+int devm_request_threaded_irq(struct device *dev, unsigned int irq,
+			      irq_handler_t handler, irq_handler_t thread_fn,
+			      unsigned long irqflags, const char *devname,
+			      void *dev_id);
+
+#include <lx_emul/spinlock.h> /* dependency of lx_emul/work.h */
+#include <lx_emul/work.h>     /* dependency of lx_kit/work.h */
+
+#include <lx_emul/mutex.h>    /* dependency of lx_emul/kobject.h */
+#include <lx_emul/kobject.h>
+#include <lx_emul/completion.h>
+#include <lx_emul/errno.h>
+#include <lx_emul/barrier.h>
+#include <lx_emul/bug.h>
+#include <lx_emul/gfp.h>
+#include <lx_emul/ioport.h>
+#include <lx_emul/module.h>
+#include <lx_emul/pm.h>
+#include <lx_emul/scatterlist.h>
+#include <lx_emul/semaphore.h>
+#include <lx_emul/string.h>
+
+LX_MUTEX_INIT_DECLARE(component_mutex);
+#define component_mutex LX_MUTEX(component_mutex)
+
+
+/**********************
+ ** asm-generic/io.h **
+ **********************/
+
+static inline u32 __raw_readl(const volatile void __iomem *addr)
+{
+	return *(const volatile u32 __force *) addr;
+}
+
+static inline void __raw_writel(u32 b, volatile void __iomem *addr)
+{
+	*(volatile u32 __force *) addr = b;
+}
+
+
+/***************************************
+ ** drivers/gpu/drm/imx/hdp/imx-hdp.h **
+ ***************************************/
+
+void imx_hdp_register_audio_driver(struct device *dev);
+
+
+/********************
+ ** linux/module.h **
+ ********************/
+
+#define arch_initcall(fn) module_init(fn)
+
+
+/********************
+ ** linux/percpu.h **
+ ********************/
+
+void __percpu *__alloc_percpu(size_t size, size_t align);
+void free_percpu(void __percpu *__pdata);
+
+
+/*************************
+ ** linux/timekeeping.h **
+ *************************/
+
+ktime_t ktime_mono_to_real(ktime_t mono);
+
+
+/********************************
+ ** soc/imx8/sc/svc/misc/api.h **
+ ********************************/
+
+#include <soc/imx8/soc.h>
+#include <soc/imx8/sc/types.h>
+
+sc_err_t sc_misc_set_control(sc_ipc_t ipc, sc_rsrc_t resource,
+                             sc_ctrl_t ctrl, uint32_t val);
+
+
+/************************
+ ** uapi/linux/types.h **
+ ************************/
+
+typedef __u16 __le16;
+typedef __u32 __le32;
+typedef __u64 __le64;
+typedef __u64 __be64;
+
+
+/********************
+ ** linux/printk.h **
+ ********************/
+
+/* needed by drm_edid.c */
+enum { DUMP_PREFIX_NONE, };
+
+void print_hex_dump(const char *level, const char *prefix_str,
+		int prefix_type, int rowsize, int groupsize,
+		const void *buf, size_t len, bool ascii);
+
+#define printk_once(fmt, ...) ({})
+
+
+/***********************
+ ** linux/sync_file.h **
+ ***********************/
+
+struct sync_file {
+	struct file *file;
+};
+
+struct dma_fence;
+struct dma_fence *sync_file_get_fence(int);
+struct sync_file *sync_file_create(struct dma_fence *);
+
+
+/*******************
+ ** linux/ctype.h **
+ *******************/
+
+#define isascii(c) (((unsigned char)(c))<=0x7f)
+#define isprint(c) (isascii(c) && ((unsigned char)(c) >= 32))
+
+
+/****************
+ ** asm/page.h **
+ ****************/
+
+/*
+ * For now, hardcoded
+ */
+#define PAGE_SIZE 4096UL
+
+enum {
+	PAGE_SHIFT = 12,
+};
+
+struct page
+{
+	atomic_t   _count;
+	void      *addr;
+	dma_addr_t paddr;
+} __attribute((packed));
+
+extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
+                                   size, unsigned long offset);
+
+extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
+                                        long size, unsigned long offset);
+
+#define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
+
+#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
+
+#define __const_hweight8(w)             \
+	( (!!((w) & (1ULL << 0))) +       \
+	  (!!((w) & (1ULL << 1))) +       \
+	  (!!((w) & (1ULL << 2))) +       \
+	  (!!((w) & (1ULL << 3))) +       \
+	  (!!((w) & (1ULL << 4))) +       \
+	  (!!((w) & (1ULL << 5))) +       \
+	  (!!((w) & (1ULL << 6))) +       \
+	  (!!((w) & (1ULL << 7))) )
+
+#define hweight16(w) (__const_hweight8(w)  + __const_hweight8((w)  >> 8 ))
+#define hweight32(w) (hweight16(w) + hweight16((w) >> 16))
+#define hweight64(w) (hweight32(w) + hweight32((w) >> 32))
+
+#define GENMASK(h, l) \
+	(((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
+
+/* needed by 'virt_to_phys', which is needed by agp/generic.c */
+typedef unsigned long phys_addr_t;
+
+void *memchr_inv(const void *s, int c, size_t n);
+
+
+/**********************
+ ** linux/compiler.h **
+ **********************/
+
+static inline void __read_once_size(const volatile void *p, void *res, int size)
+{
+	switch (size) {
+		case 1: *(__u8  *)res = *(volatile __u8  *)p; break;
+		case 2: *(__u16 *)res = *(volatile __u16 *)p; break;
+		case 4: *(__u32 *)res = *(volatile __u32 *)p; break;
+		case 8: *(__u64 *)res = *(volatile __u64 *)p; break;
+		default:
+			barrier();
+			__builtin_memcpy((void *)res, (const void *)p, size);
+			barrier();
+	}
+}
+
+/* dependency of lx_emul/list.h */
+#ifdef __cplusplus
+#define READ_ONCE(x) \
+({                                               \
+	barrier(); \
+	x; \
+})
+
+#else
+#define READ_ONCE(x) \
+({                                               \
+	union { typeof(x) __val; char __c[1]; } __u; \
+	__read_once_size(&(x), __u.__c, sizeof(x));  \
+	__u.__val;                                   \
+})
+#endif
+
+#include <lx_emul/list.h>
+
+#define ULLONG_MAX	(~0ULL)
+#define SIZE_MAX (~(size_t)0)
+
+#define U64_MAX  ((u64)~0ULL)
+
+extern long simple_strtol(const char *,char **,unsigned int);
+
+
+/****************************
+ ** kernel/printk/printk.c **
+ ****************************/
+
+extern int oops_in_progress;
+
+#define pr_debug(fmt, ...)      printk(KERN_INFO fmt,   ##__VA_ARGS__)
+#define pr_info(fmt, ...)       printk(KERN_INFO fmt,   ##__VA_ARGS__)
+#define pr_err(fmt, ...)        printk(KERN_ERR fmt,    ##__VA_ARGS__)
+#define pr_warn(fmt, ...)       printk(KERN_ERR fmt,    ##__VA_ARGS__)
+#define pr_notice(fmt, ...)     printk(KERN_NOTICE fmt, ##__VA_ARGS__)
+
+int sprintf(char *buf, const char *fmt, ...);
+int snprintf(char *buf, size_t size, const char *fmt, ...);
+
+int sscanf(const char *, const char *, ...);
+
+enum { SPRINTF_STR_LEN = 64 };
+
+#define kasprintf(gfp, fmt, ...) ({ \
+		void *buf = kmalloc(SPRINTF_STR_LEN, 0); \
+		sprintf(buf, fmt, __VA_ARGS__); \
+		buf; \
+		})
+
+#define DIV_ROUND_CLOSEST_ULL(x, divisor)(              \
+		{                                               \
+		typeof(divisor) __d = divisor;                  \
+		unsigned long long _tmp = (x) + (__d) / 2;      \
+		do_div(_tmp, __d);                              \
+		_tmp;                                           \
+		}                                               \
+		)
+
+/* linux/i2c.h */
+#define __deprecated
+
+/* i2c-core.c */
+#define postcore_initcall(fn) void postcore_##fn(void) { fn(); }
+
+
+/**************************
+ ** linux/preempt_mask.h **
+ **************************/
+
+/* needed bu i2c-core.c */
+bool in_atomic();
+
+void preempt_enable(void);
+void preempt_disable(void);
+
+
+/**********************
+ ** linux/irqflags.h **
+ **********************/
+
+/* needed by drmP.h */
+bool irqs_disabled();
+
+
+/********************
+ ** linux/kernel.h **
+ ********************/
+
+int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
+
+#define u64_to_user_ptr(x) ({ \
+	(void __user *)(uintptr_t)x; \
+})
+
+char *kvasprintf(gfp_t, const char *, va_list);
+
+/******************
+ ** linux/kref.h **
+ ******************/
+
+struct kref;
+unsigned int kref_read(const struct kref*);
+
+LX_MUTEX_INIT_DECLARE(bridge_lock);
+LX_MUTEX_INIT_DECLARE(core_lock);
+
+#define bridge_lock LX_MUTEX(bridge_lock)
+#define core_lock   LX_MUTEX(core_lock)
+
+void might_lock(struct mutex *);
+
+
+/*********************
+ ** linux/rtmutex.h **
+ *********************/
+
+#define rt_mutex            mutex
+#define rt_mutex_init(m)    mutex_init(m)
+#define rt_mutex_lock(m)    mutex_lock(m)
+#define rt_mutex_lock_nested(lock, subclass) rt_mutex_lock(lock)
+
+#define rt_mutex_trylock(m) mutex_trylock(m)
+#define rt_mutex_unlock(m)  mutex_unlock(m)
+
+
+/*********************
+ ** linux/ww_mutex.h **
+ *********************/
+
+struct ww_acquire_ctx { unsigned dummy; };
+
+struct ww_class { int dummy; };
+
+struct ww_mutex {
+	bool locked;
+	struct ww_acquire_ctx *ctx;
+};
+
+#define DEFINE_WW_CLASS(classname) \
+	struct ww_class classname;
+
+#ifndef CONFIG_DEBUG_OBJECTS_WORK
+#define INIT_WORK_ONSTACK(_work, _func) while(0) { }
+static inline void destroy_work_on_stack(struct work_struct *work) { }
+#endif
+
+
+/*******************
+ ** linux/sched.h **
+ *******************/
+
+enum {
+	TASK_RUNNING         = 0x0,
+	TASK_INTERRUPTIBLE   = 0x1,
+	TASK_UNINTERRUPTIBLE = 0x2,
+	TASK_NORMAL          = TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE,
+};
+
+#define	MAX_SCHEDULE_TIMEOUT LONG_MAX
+
+struct task_struct {
+	char comm[16]; /* only for debug output */
+};
+
+signed long schedule_timeout(signed long timeout);
+
+void __set_current_state(int state);
+
+int signal_pending(struct task_struct *p);
+
+int wake_up_state(struct task_struct *tsk, unsigned int state);
+
+/* normally defined in asm/current.h, included by sched.h */
+extern struct task_struct *current;
+
+void set_current_state(int);
+
+
+/************************
+ ** linux/completion.h **
+ ************************/
+
+struct completion {
+	unsigned done;
+	void * task;
+};
+
+long __wait_completion(struct completion *work, unsigned long);
+
+void reinit_completion(struct completion *work);
+
+
+/*********************
+ ** asm/processor.h **
+ *********************/
+ 
+void cpu_relax(void);
+
+
+/*******************
+ ** linux/delay.h **
+ *******************/
+
+void msleep(unsigned int);
+
+void udelay(unsigned long);
+void mdelay(unsigned long);
+void ndelay(unsigned long);
+void usleep_range(unsigned long min, unsigned long max);
+
+
+/************************
+ ** asm/memory_model.h **
+ ************************/
+
+dma_addr_t page_to_pfn(struct page *page);
+
+
+/*********************
+ ** linux/pagemap.h **
+ *********************/
+
+struct address_space {
+	unsigned long flags;
+	struct page * my_page;
+};
+
+gfp_t mapping_gfp_constraint(struct address_space *mapping, gfp_t gfp_mask);
+
+
+/******************
+ ** linux/swap.h **
+ ******************/
+
+void mark_page_accessed(struct page *);
+
+
+/***************************
+ ** linux/pgtable_types.h **
+ ***************************/
+
+typedef unsigned long   pgprotval_t;
+struct pgprot { pgprotval_t pgprot; };
+typedef struct pgprot pgprot_t;
+
+extern pgprot_t pgprot_writecombine(pgprot_t prot);
+extern pgprot_t pgprot_decrypted(pgprot_t prot);
+
+
+/**********************
+ ** linux/mm_types.h **
+ **********************/
+
+struct vm_operations_struct;
+
+struct vm_area_struct {
+	unsigned long                      vm_start;
+	unsigned long                      vm_end;
+	pgprot_t                           vm_page_prot;
+	unsigned long                      vm_flags;
+	const struct vm_operations_struct *vm_ops;
+	unsigned long                      vm_pgoff;
+	void                               *vm_private_data;
+};
+
+
+/****************
+ ** linux/mm.h **
+ ****************/
+
+enum {
+	VM_WRITE        = 0x00000002,
+	VM_MAYWRITE     = 0x00000020,
+	VM_PFNMAP       = 0x00000400,
+	VM_IO           = 0x00004000,
+	VM_DONTEXPAND   = 0x00040000,
+	VM_NORESERVE    = 0x00200000,
+	VM_DONTDUMP     = 0x04000000,
+};
+
+struct vm_fault;
+
+int set_page_dirty(struct page *page);
+
+void put_page(struct page *page);
+
+struct vm_area_struct;
+
+struct vm_operations_struct {
+	void (*open)(struct vm_area_struct * area);
+	void (*close)(struct vm_area_struct * area);
+	int (*fault)(struct vm_fault *vmf);
+};
+
+void free_pages(unsigned long addr, unsigned int order);
+
+pgprot_t vm_get_page_prot(unsigned long vm_flags);
+void kvfree(const void *p);
+
+void *kvmalloc_array(size_t, size_t, gfp_t);
+void unmap_mapping_range(struct address_space *, loff_t const, loff_t const, int);
+
+unsigned long vma_pages(struct vm_area_struct *);
+
+
+/******************
+ ** linux/slab.h **
+ ******************/
+
+#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
+
+enum {
+	SLAB_RECLAIM_ACCOUNT = 0x00020000ul,
+	SLAB_PANIC           = 0x00040000ul,
+};
+
+void *kzalloc(size_t size, gfp_t flags);
+void *kvzalloc(size_t size, gfp_t flags);
+void kfree(const void *);
+void *kcalloc(size_t n, size_t size, gfp_t flags);
+void *kmalloc(size_t size, gfp_t flags);
+void *krealloc(const void *, size_t, gfp_t);
+void *kmalloc_array(size_t n, size_t size, gfp_t flags);
+void *kmalloc_node_track_caller(size_t size, gfp_t flags, int node);
+
+struct kmem_cache;
+
+struct kmem_cache *kmem_cache_create(const char *, size_t, size_t, unsigned long, void (*)(void *));
+
+void  kmem_cache_free(struct kmem_cache *, void *);
+
+void  *kmem_cache_alloc(struct kmem_cache *, gfp_t);
+
+
+/**********************
+ ** linux/kmemleak.h **
+ **********************/
+
+#ifndef CONFIG_DEBUG_KMEMLEAK
+static inline void kmemleak_update_trace(const void *ptr) { }
+#endif
+
+/**********************
+ ** linux/byteorder/ **
+ **********************/
+
+#include <lx_emul/byteorder.h>
+
+/******************
+ ** linux/swab.h **
+ ******************/
+
+#define swab16 __swab16
+
+
+/**********************
+ ** linux/highmem.h  **
+ **********************/
+
+unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
+
+
+/*************************
+ ** linux/percpu-defs.h **
+ *************************/
+
+#define DECLARE_PER_CPU(type, name) \
+	extern typeof(type) name
+
+#define DEFINE_PER_CPU(type, name) \
+	typeof(type) name
+
+#define this_cpu_xchg(pcp, nval) \
+({									\
+	typeof(pcp) before = pcp; \
+	pcp = nval; \
+	before; \
+})
+
+#define this_cpu_ptr(ptr) ptr
+#define this_cpu_read(val) val
+#define per_cpu(var, cpu) var
+#define this_cpu_cmpxchg(pcp, oval, nval) \
+	cmpxchg(&pcp, oval, nval)
+
+#define cpuhp_setup_state_nocalls(a, b, c, d) 0
+
+
+/******************
+ ** linux/gfp.h  **
+ ******************/
+
+#define __GFP_BITS_SHIFT (25 + IS_ENABLED(CONFIG_LOCKDEP))
+
+#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
+
+static inline bool gfpflags_allow_blocking(const gfp_t gfp_flags)
+{
+	return !!(gfp_flags & __GFP_DIRECT_RECLAIM);
+}
+
+
+/*********************
+ ** linux/dma-buf.h **
+ *********************/
+
+struct dma_buf;
+void dma_buf_put(struct dma_buf *);
+
+struct dma_buf {
+	size_t size;
+	void *priv;
+	struct reservation_object *resv;
+};
+
+struct dma_buf_attachment {
+	struct dma_buf *dmabuf;
+};
+
+
+/********************
+ ** linux/pm_qos.h **
+ ********************/
+
+struct pm_qos_request { int dummy; };
+
+
+/***********************
+ ** linux/pm_wakeup.h **
+ ***********************/
+
+int device_init_wakeup(struct device *dev, bool val);
+
+
+/*******************
+ ** linux/sysfs.h **
+ *******************/
+
+struct attribute { int dummy; };
+
+struct attribute_group {
+	struct attribute	**attrs;
+};
+
+#define __ATTRIBUTE_GROUPS(_name)                               \
+	static const struct attribute_group *_name##_groups[] = {   \
+		&_name##_group,                                         \
+		NULL,                                                   \
+	}
+
+#define ATTRIBUTE_GROUPS(_name)                                 \
+	static const struct attribute_group _name##_group = {       \
+		.attrs = _name##_attrs,                                 \
+	};                                                          \
+__ATTRIBUTE_GROUPS(_name)
+
+
+/****************
+ ** linux/pm.h **
+ ****************/
+
+#define SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
+
+#define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn)
+
+#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) struct dev_pm_ops name;
+
+
+struct dev_pm_domain;
+
+enum rpm_status {
+	RPM_ACTIVE = 0,
+	RPM_SUSPENDED,
+};
+
+
+/***********************
+ ** linux/pm_domain.h **
+ ***********************/
+
+static inline int dev_pm_domain_attach(struct device *dev, bool power_on) {
+	return -ENODEV; }
+static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
+
+
+/******************
+ ** linux/numa.h **
+ ******************/
+
+enum { NUMA_NO_NODE = -1 };
+
+/********************
+ ** linux/device.h **
+ ********************/
+
+struct device_driver;
+struct subsys_private;
+
+struct bus_type
+{
+	const char *name;
+
+	int (*match)(struct device *dev, struct device_driver *drv);
+	int (*probe)(struct device *dev);
+	int (*remove)(struct device *dev);
+	void (*shutdown)(struct device *dev);
+	int (*suspend)(struct device *dev, pm_message_t state);
+	int (*resume)(struct device *dev);
+
+	const struct dev_pm_ops *pm;
+	struct subsys_private *p;
+};
+
+struct device_type
+{
+	const struct attribute_group **groups;
+	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
+	void (*release)(struct device *dev);
+};
+
+struct dev_archdata
+{
+	struct dma_map_ops *dma_ops;
+};
+
+struct fwnode_operations { int dummy; };
+
+struct fwnode_handle {
+	const struct fwnode_operations *ops;
+};
+
+struct device {
+	const char               *name;
+	struct device            *parent;
+	struct kobject            kobj;
+	u64                       _dma_mask_buf;
+	u64                      *dma_mask;
+	u64                       coherent_dma_mask;
+	struct device_driver     *driver;
+	void                     *drvdata;  /* not in Linux */
+	const struct device_type *type;
+	void                     *platform_data;
+	void                     *driver_data;
+	struct dev_pm_info        power;
+	struct dev_archdata       archdata;
+	struct bus_type          *bus;
+	struct device_node       *of_node;
+	struct fwnode_handle     *fwnode;
+	spinlock_t		          devres_lock;
+	struct list_head	      devres_head;
+};
+
+static inline const char *dev_name(const struct device *dev)
+{
+	return dev->name;
+}
+
+struct device_attribute {
+	struct attribute attr;
+};
+
+#define DEVICE_ATTR(_name, _mode, _show, _store) \
+	struct device_attribute dev_attr_##_name = { { 0 } }
+
+#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
+	struct device_attribute dev_attr_##_name = { { 0 } }
+
+#define dev_info(  dev, format, arg...) lx_printf("dev_info: "   format , ## arg)
+#define dev_warn(  dev, format, arg...) lx_printf("dev_warn: "   format , ## arg)
+#define dev_err(   dev, format, arg...) lx_printf("dev_error: "  format , ## arg)
+
+#define dev_printk(level, dev, format, arg...) \
+	lx_printf("dev_printk: " format , ## arg)
+
+#define dev_dbg(dev, format, arg...) \
+	lx_printf("dev_dbg: " format, ## arg)
+
+#define dev_err_ratelimited(dev, fmt, ...)                              \
+	dev_err(dev, fmt, ##__VA_ARGS__)
+
+struct device_driver
+{
+	char const      *name;
+	struct bus_type *bus;
+	struct module   *owner;
+	const struct of_device_id *of_match_table;
+	const struct acpi_device_id *acpi_match_table;
+	const struct dev_pm_ops *pm;
+	int            (*probe)  (struct device *dev);
+};
+
+int driver_register(struct device_driver *drv);
+void driver_unregister(struct device_driver *drv);
+
+static inline void *dev_get_drvdata(const struct device *dev)
+{
+	return dev->driver_data;
+}
+
+static inline void dev_set_drvdata(struct device *dev, void *data)
+{
+	dev->driver_data = data;
+}
+
+int dev_set_name(struct device *dev, const char *name, ...);
+
+int bus_register(struct bus_type *bus);
+void bus_unregister(struct bus_type *bus);
+
+struct device *get_device(struct device *dev);
+void put_device(struct device *dev);
+
+int device_for_each_child(struct device *dev, void *data, int (*fn)(struct device *dev, void *data));
+
+int  device_add(struct device *dev);
+
+int device_register(struct device *dev);
+void device_unregister(struct device *dev);
+
+const char *dev_name(const struct device *dev);
+
+int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
+                     void *data, int (*fn)(struct device_driver *, void *));
+
+int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
+                     int (*fn)(struct device *dev, void *data));
+
+/* needed by linux/i2c.h */
+struct acpi_device;
+
+void devm_kfree(struct device *dev, void *p);
+void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
+
+typedef void (*dr_release_t)(struct device *dev, void *res);
+typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
+
+void devres_add(struct device *dev, void *res);
+
+void *devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid);
+
+static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
+{
+	return devres_alloc_node(release, size, gfp, NUMA_NO_NODE);
+}
+
+void devres_close_group(struct device *dev, void *id);
+void *devres_open_group(struct device *dev, void *id, gfp_t gfp);
+int devres_release_group(struct device *dev, void *id);
+void devres_remove_group(struct device *dev, void *id);
+
+int dev_to_node(struct device *dev);
+
+
+/****************
+ ** linux/io.h **
+ ****************/
+
+#define writel(value, addr) (*(volatile uint32_t *)(addr) = (value))
+#define readl(addr)         (*(volatile uint32_t *)(addr))
+
+#define readl_relaxed  readl
+#define writel_relaxed(v, a) writel(v, a)
+
+void memset_io(void *s, int c, size_t n);
+
+void *devm_ioremap(struct device *dev, resource_size_t offset,
+                   unsigned long size);
+
+void *devm_ioremap_resource(struct device *dev, struct resource *res);
+
+
+/*********************
+ ** linux/uaccess.h **
+ *********************/
+
+#define get_user(x, ptr) ({  (x)   = *(ptr); 0; })
+#define put_user(x, ptr) ({ *(ptr) =  (x);   0; })
+
+size_t copy_from_user(void *to, void const *from, size_t len);
+size_t copy_to_user(void *dst, void const *src, size_t len);
+
+
+/*************************
+ ** linux/dma-mapping.h **
+ *************************/
+
+#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
+
+static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
+{
+	dev->coherent_dma_mask = mask;
+	return 0;
+}
+
+int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
+                          void *cpu_addr, dma_addr_t dma_addr, size_t size,
+                          unsigned long attrs);
+
+#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
+
+void *dma_alloc_wc(struct device *dev, size_t size,
+                   dma_addr_t *dma_addr, gfp_t gfp);
+void dma_free_wc(struct device *dev, size_t size,
+                 void *cpu_addr, dma_addr_t dma_addr);
+int dma_mmap_wc(struct device *dev,
+                struct vm_area_struct *vma,
+                void *cpu_addr, dma_addr_t dma_addr,
+                size_t size);
+
+void *dmam_alloc_coherent(struct device *dev, size_t size,
+                          dma_addr_t *dma_handle, gfp_t gfp);
+
+void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
+                        dma_addr_t dma_handle);
+
+
+/********************
+ ** linux/ioport.h **
+ ********************/
+
+#define IORESOURCE_BITS 0x000000ff
+
+
+/********************
+ ** linux/of_irq.h **
+ ********************/
+
+extern int of_irq_get(struct device_node *dev, int index);
+extern int of_irq_get_byname(struct device_node *dev, const char *name);
+
+struct irq_data *irq_get_irq_data(unsigned int);
+
+
+/*****************
+ ** linux/irq.h **
+ *****************/
+
+#include <linux/irqhandler.h>
+
+struct irq_chip {
+	struct device	*parent_device;
+	const char	*name;
+
+	void		(*irq_ack)(struct irq_data *data);
+	void		(*irq_mask)(struct irq_data *data);
+	void		(*irq_mask_ack)(struct irq_data *data);
+	void		(*irq_unmask)(struct irq_data *data);
+	void		(*irq_eoi)(struct irq_data *data);
+};
+
+struct irq_data {
+	unsigned long    hwirq;
+	struct irq_chip *chip;
+	void            *chip_data;
+};
+
+void irq_chip_eoi_parent(struct irq_data *data);
+
+struct irq_common_data {
+	void *handler_data;
+};
+
+struct irq_desc;
+
+void handle_level_irq(struct irq_desc *desc);
+
+
+void irqd_set_trigger_type(struct irq_data *, u32);
+
+void irq_set_chip_and_handler(unsigned int, struct irq_chip *,
+                              irq_flow_handler_t);
+
+int irq_set_chip_data(unsigned int irq, void *data);
+
+extern struct irq_chip dummy_irq_chip;
+
+void handle_simple_irq(struct irq_desc *);
+
+enum {
+	IRQ_NOAUTOEN		= (1 << 12),
+};
+
+void irq_set_chained_handler_and_data(unsigned int irq,
+                                      irq_flow_handler_t handle,
+                                      void *data);
+
+void irq_set_status_flags(unsigned int irq, unsigned long set);
+
+
+/************************
+ ** linux/capability.h **
+ ************************/
+
+#define CAP_SYS_ADMIN 21
+
+bool capable(int);
+
+
+/**********************
+ ** linux/notifier.h **
+ **********************/
+
+struct notifier_block { int dummy; };
+
+
+/****************
+ ** linux/fs.h **
+ ****************/
+
+struct inode {
+	const struct inode_operations *i_op;
+	struct address_space *i_mapping;
+};
+
+struct file
+{
+	atomic_long_t         f_count;
+	struct inode         *f_inode;
+	struct address_space *f_mapping;
+	void                 *private_data;
+};
+
+struct poll_table_struct;
+
+/* drm_gem_cma_helper.h */
+struct file_operations {
+	struct module *owner;
+	loff_t (*llseek) (struct file *, loff_t, int);
+	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
+	unsigned int (*poll) (struct file *, struct poll_table_struct *);
+	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
+	int (*mmap) (struct file *, struct vm_area_struct *);
+	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
+	int (*open) (struct inode *, struct file *);
+	int (*release) (struct inode *, struct file *);
+};
+
+loff_t noop_llseek(struct file *file, loff_t offset, int whence);
+
+
+/*******************
+ ** linux/types.h **
+ *******************/
+struct rcu_head { int dummy; };
+
+typedef unsigned long irq_hw_number_t;
+
+
+/*********************
+ ** linux/seqlock.h **
+ *********************/
+
+typedef unsigned seqlock_t;
+
+void seqlock_init (seqlock_t *);
+
+void write_seqlock(seqlock_t *);
+void write_sequnlock(seqlock_t *);
+
+unsigned read_seqbegin(const seqlock_t *);
+unsigned read_seqretry(const seqlock_t *, unsigned);
+
+
+/*************************
+ ** linux/reservation.h **
+ *************************/
+
+struct reservation_object {
+	struct dma_fence *fence_excl;
+};
+
+struct dma_fence * reservation_object_get_excl_rcu(struct reservation_object *);
+
+
+/**********************
+ ** linux/shmem_fs.h **
+ **********************/
+
+extern struct page *shmem_read_mapping_page( struct address_space *mapping, pgoff_t index);
+struct file *shmem_file_setup(const char *, loff_t, unsigned long);
+
+
+/*****************
+ ** linux/i2c.h **
+ *****************/
+
+enum i2c_slave_event { DUMMY };
+
+
+/****************
+ ** linux/of.h **
+ ****************/
+
+int of_alias_get_id(struct device_node *np, const char *stem);
+struct device_node *of_node_get(struct device_node *node);
+void of_node_put(struct device_node *);
+
+int of_property_match_string(const struct device_node *, const char *,
+                             const char *);
+int of_property_read_u32_index(const struct device_node *, const char *, u32,
+                               u32 *);
+
+#define for_each_child_of_node(parent, child) \
+	for (child = of_get_next_child(parent, NULL); child != NULL; \
+	     child = of_get_next_child(parent, child))
+
+struct property {
+	const char      * name;
+	void            * value;
+	struct property * next;
+};
+
+struct device_node {
+	const char           *name;
+	const char           *full_name;
+	struct fwnode_handle  fwnode;
+	struct property      *properties;
+	struct device_node   *parent;
+};
+
+bool of_device_is_available(const struct device_node *device);
+
+int of_device_is_compatible(const struct device_node *device,
+                            const char *compat);
+extern struct device_node *of_get_next_child(const struct device_node *node,
+                                             struct device_node *prev);
+struct device_node *of_get_parent(const struct device_node *node);
+const void *of_get_property(const struct device_node *node, const char *name, int *lenp);
+struct device_node *of_parse_phandle(const struct device_node *np,
+                                     const char *phandle_name, int index);
+bool of_property_read_bool(const struct device_node *np, const char *propname);
+int of_property_read_string(const struct device_node *np, const char *propname,
+                            const char **out_string);
+int of_property_read_u32(const struct device_node *np, const char *propname, u32 *out_value);
+
+bool is_of_node(const struct fwnode_handle *fwnode);
+
+#define to_of_node(__fwnode)						\
+	({								\
+		typeof(__fwnode) __to_of_node_fwnode = (__fwnode);	\
+									\
+		is_of_node(__to_of_node_fwnode) ?			\
+			container_of(__to_of_node_fwnode,		\
+				     struct device_node, fwnode) :	\
+			NULL;						\
+	})
+
+
+/***********************
+ ** linux/of_device.h **
+ ***********************/
+
+const void *of_device_get_match_data(const struct device *dev);
+
+const struct of_device_id *of_match_device(const struct of_device_id *matches,
+                                           const struct device *dev);
+
+
+/******************
+ ** linux/acpi.h **
+ ******************/
+
+bool acpi_driver_match_device(struct device *dev, const struct device_driver *drv);
+int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
+
+int acpi_device_modalias(struct device *, char *, int);
+
+#define ACPI_COMPANION(dev)		(NULL)
+
+const char *acpi_dev_name(struct acpi_device *adev);
+
+int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);
+
+void acpi_device_clear_enumerated(struct acpi_device *);
+
+int acpi_reconfig_notifier_register(struct notifier_block *);
+int acpi_reconfig_notifier_unregister(struct notifier_block *);
+
+/******************
+ ** linux/gpio.h **
+ ******************/
+
+/* make these flag values available regardless of GPIO kconfig options */
+
+#define GPIOF_DIR_OUT	(0 << 0)
+
+#define GPIOF_DIR_IN	(1 << 0)
+
+#define GPIOF_INIT_HIGH	(1 << 1)
+
+#define GPIOF_IN		(GPIOF_DIR_IN)
+
+#define GPIOF_OUT_INIT_HIGH	(GPIOF_DIR_OUT | GPIOF_INIT_HIGH)
+
+#define GPIOF_OPEN_DRAIN	(1 << 3)
+
+void gpio_free(unsigned gpio);
+int gpio_get_value(unsigned int gpio);
+bool gpio_is_valid(int number);
+int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
+void gpio_set_value(unsigned int gpio, int value);
+
+
+/* needed by drivers/gpu/drm/drm_modes.c */
+#include <linux/list_sort.h>
+
+
+/**********************
+ ** drm/drm_device.h **
+ **********************/
+
+struct drm_device;
+
+
+/******************
+ ** linux/kgdb.h **
+ ******************/
+
+#define in_dbg_master() (0)
+
+
+/*************************
+ ** asm-generic/div64.h **
+ *************************/
+
+#define do_div(n,base) ({ \
+		unsigned long __base = (base); \
+		unsigned long __rem; \
+		__rem = ((uint64_t)(n)) % __base; \
+		(n)   = ((uint64_t)(n)) / __base; \
+		__rem; \
+		})
+
+
+/****************
+ ** linux/fb.h **
+ ****************/
+
+extern int fb_get_options(const char *name, char **option);
+
+
+/****************************
+ ** drm/drm_modeset_lock.h **
+ ****************************/
+
+void ww_mutex_init(struct ww_mutex *lock, struct ww_class *ww_class);
+bool ww_mutex_is_locked(struct ww_mutex *lock);
+int  ww_mutex_trylock(struct ww_mutex *lock);
+void ww_acquire_fini(struct ww_acquire_ctx *ctx);
+void ww_acquire_init(struct ww_acquire_ctx *ctx, struct ww_class *ww_class);
+int  ww_mutex_lock_slow_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
+void ww_mutex_unlock(struct ww_mutex *lock);
+int  ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
+void ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
+int  ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
+
+
+/************************
+ ** linux/jump_label.h **
+ ************************/
+
+struct static_key { int dummy; };
+
+#define STATIC_KEY_INIT_FALSE { .dummy = 0 }
+
+extern void static_key_slow_inc(struct static_key *key);
+extern void static_key_slow_dec(struct static_key *key);
+extern bool static_key_false(struct static_key *key);
+
+
+/**********************
+ ** linux/seq_file.h **
+ **********************/
+
+struct seq_file { unsigned dummy; };
+void seq_printf(struct seq_file *m, const char *fmt, ...);
+void seq_puts(struct seq_file *m, const char *s);
+
+
+/*********************
+ ** linux/clk/clk.h **
+ *********************/
+
+struct clk
+{
+	const char * name;
+	unsigned long rate;
+};
+
+struct clk *devm_clk_get(struct device *dev, const char *id);
+
+void clk_disable_unprepare(struct clk *clk);
+struct clk *clk_get_parent(struct clk *clk);
+unsigned long clk_get_rate(struct clk * clk);
+bool clk_is_match(const struct clk *p, const struct clk *q);
+int clk_prepare_enable(struct clk *clk);
+int clk_set_parent(struct clk *clk, struct clk *parent);
+int clk_set_rate(struct clk *clk, unsigned long rate);
+
+
+/**************************
+ ** linux/clk/clk-conf.h **
+ **************************/
+
+static inline int of_clk_set_defaults(struct device_node *node, bool clk_supplier) {
+	return 0; }
+
+
+/****************
+ ** linux/of.h **
+ ****************/
+
+enum {
+	OF_POPULATED     = 3,
+};
+
+void of_node_clear_flag(struct device_node *n, unsigned long flag);
+
+extern int of_alias_get_highest_id(const char *stem);
+
+static inline int of_reconfig_notifier_register(struct notifier_block *nb) {
+	return -EINVAL; }
+static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) {
+	return -EINVAL; }
+
+
+/*********************
+ ** drm/drm_lease.h **
+ *********************/
+
+struct drm_file;
+bool drm_lease_held(struct drm_file *, int);
+bool _drm_lease_held(struct drm_file *, int);
+
+uint32_t drm_lease_filter_crtcs(struct drm_file *, uint32_t);
+
+
+/********************
+ ** linux/rwlock.h **
+ ********************/
+
+typedef unsigned long rwlock_t;
+void rwlock_init(rwlock_t *);
+void read_lock(rwlock_t *);
+void read_unlock(rwlock_t *);
+void write_lock(rwlock_t *);
+void write_unlock(rwlock_t *);
+
+
+/************************
+ ** linux/tracepoint.h **
+ ************************/
+
+#define EXPORT_TRACEPOINT_SYMBOL(name)
+
+void tracepoint_synchronize_unregister(void);
+
+
+/*******************
+ ** linux/ktime.h **
+ *******************/
+
+#define ktime_to_ns(kt) kt
+
+#define ktime_sub_ns(kt, nsval)		((kt) - (nsval))
+
+static inline s64 timeval_to_ns(const struct timeval *tv)
+{
+	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
+		tv->tv_usec * NSEC_PER_USEC;
+}
+
+
+/***********************
+ ** include/lockdep.h **
+ ***********************/
+
+#define MAX_LOCKDEP_SUBCLASSES 8UL
+
+#define lockdep_assert_held(l) do { (void)(l); } while (0)
+
+
+/********************
+ ** linux/bitmap.h **
+ ********************/
+
+extern void bitmap_set(unsigned long *map, unsigned int start, int len);
+
+#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
+
+#define small_const_nbits(nbits) \
+	(__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
+
+static inline int bitmap_empty(const unsigned long *src, unsigned nbits)
+{
+	if (small_const_nbits(nbits))
+		return ! (*src & BITMAP_LAST_WORD_MASK(nbits));
+
+	return find_first_bit(src, nbits) == nbits;
+}
+
+static inline int bitmap_full(const unsigned long *src, unsigned int nbits)
+{
+	if (small_const_nbits(nbits))
+		return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));
+
+	return find_first_zero_bit(src, nbits) == nbits;
+}
+
+static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
+{
+	unsigned int nlongs = BITS_TO_LONGS(nbits);
+	if (!small_const_nbits(nbits)) {
+		unsigned int len = (nlongs - 1) * sizeof(unsigned long);
+		memset(dst, 0xff,  len);
+	}
+	dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);
+}
+
+
+/*****************
+ ** linux/err.h **
+ *****************/
+
+int PTR_ERR_OR_ZERO(__force const void *ptr);
+
+
+/*********************
+ ** linux/preempt.h **
+ *********************/
+
+#define in_interrupt() 1
+
+
+/********************
+ * linux/property.h *
+ ********************/
+
+struct property_entry;
+struct property_entry * property_entries_dup(const struct property_entry *);
+
+int device_add_properties(struct device *, const struct property_entry *);
+void device_remove_properties(struct device *);
+
+int device_property_read_u32(struct device *, const char *, u32 *);
+
+
+/**********************
+ ** linux/rcupdate.h **
+ **********************/
+
+#define kfree_rcu(ptr, offset) kfree(ptr)
+
+#define rcu_access_pointer(p) p
+#define rcu_assign_pointer(p, v) p = v
+#define rcu_dereference(p) p
+#define rcu_dereference_protected(p, c) p
+#define rcu_dereference_raw(p) p
+#define rcu_pointer_handoff(p) (p)
+
+void call_rcu(struct rcu_head *, void (*)(struct rcu_head *));
+
+
+/************************
+ ** drm/drm_os_linux.h **
+ ************************/
+
+#define DRM_WAIT_ON( ret, queue, timeout, condition )       \
+	do {                                                    \
+		DECLARE_WAITQUEUE(entry, current);                  \
+		unsigned long end = jiffies + (timeout);            \
+		add_wait_queue(&(queue), &entry);                   \
+		                                                    \
+		for (;;) {                                          \
+			__set_current_state(TASK_INTERRUPTIBLE);        \
+			if (condition)                                  \
+			break;                                          \
+			if (time_after_eq(jiffies, end)) {              \
+				ret = -EBUSY;                               \
+				break;                                      \
+			}                                               \
+			schedule_timeout((HZ/100 > 1) ? HZ/100 : 1);    \
+			if (signal_pending(current)) {                  \
+				ret = -EINTR;                               \
+				break;                                      \
+			}                                               \
+		}                                                   \
+		__set_current_state(TASK_RUNNING);                  \
+		remove_wait_queue(&(queue), &entry);                \
+	} while (0)
+
+
+/*********************
+ ** drm/drm_sysfs.h **
+ *********************/
+
+void drm_sysfs_hotplug_event(struct drm_device *);
+
+
+/* XXX */
+void put_unused_fd(unsigned int);
+void fd_install(unsigned int, struct file *);
+void fput(struct file *);
+enum { O_CLOEXEC = 0xbadaffe };
+int get_unused_fd_flags(unsigned);
+
+
+/*********************
+ ** linux/irqdesc.h **
+ *********************/
+
+struct irq_desc {
+	struct irq_common_data irq_common_data;
+	struct irq_data        irq_data;
+	irq_flow_handler_t     handle_irq;
+};
+
+int generic_handle_irq(unsigned int);
+
+static inline struct irq_chip *irq_desc_get_chip(struct irq_desc *desc)
+{
+	return desc->irq_data.chip;
+}
+
+static inline void *irq_desc_get_handler_data(struct irq_desc *desc)
+{
+	return desc->irq_common_data.handler_data;
+}
+
+
+/*******************
+ ** Configuration **
+ *******************/
+
+#define CONFIG_I2C                             1
+#define CONFIG_I2C_BOARDINFO                   1
+#define CONFIG_BASE_SMALL                      0
+#define CONFIG_IRQ_DOMAIN                      1
+#define CONFIG_MMU                             1
+#define CONFIG_OF                              1
+#define CONFIG_VIDEOMODE_HELPERS               1
+
+
+/**************************
+ ** Dummy trace funtions **
+ **************************/
+
+#define trace_drm_vblank_event_delivered(...)
+#define trace_drm_vblank_event_queued(...)
+#define trace_drm_vblank_event(...)
+
+#define trace_i2c_read(...)
+#define trace_i2c_write(...)
+#define trace_i2c_reply(...)
+#define trace_i2c_result(...)
+
+#define trace_dma_fence_enable_signal(...) while (0) { }
+#define trace_dma_fence_init(...)           while (0) { }
+#define trace_dma_fence_signaled(...)       while (0) { }
+#define trace_dma_fence_destroy(...)        while (0) { }
+#define trace_dma_fence_wait_start(...)     while (0) { }
+#define trace_dma_fence_wait_end(...)       while (0) { }
+
+
+/***********************
+ ** linux/interrupt.h **
+ ***********************/
+
+void enable_irq(unsigned int);
+void disable_irq(unsigned int);
+int disable_irq_nosync(unsigned int);
+
+
+/*****************************
+ ** linux/platform_device.h **
+ *****************************/
+
+struct platform_device {
+	char            *name;
+	int              id;
+	struct device    dev;
+	u32              num_resources;
+	struct resource *resource;
+};
+
+#define to_platform_device(x) container_of((x), struct platform_device, dev)
+
+int platform_device_add(struct platform_device *pdev);
+int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size);
+struct platform_device *platform_device_alloc(const char *name, int id);
+int platform_device_put(struct platform_device *pdev);
+int platform_device_register(struct platform_device *);
+void platform_device_unregister(struct platform_device *);
+
+static inline void *platform_get_drvdata(const struct platform_device *pdev)
+{
+	return pdev->dev.driver_data;
+}
+
+int platform_get_irq(struct platform_device *dev, unsigned int num);
+
+int platform_get_irq_byname(struct platform_device *dev, const char *name);
+
+struct resource *platform_get_resource(struct platform_device *pdev,
+                                       unsigned int type, unsigned int num);
+
+struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
+
+static inline void platform_set_drvdata(struct platform_device *pdev,
+					void *data)
+{
+	dev_set_drvdata(&pdev->dev, data);
+}
+
+struct platform_driver {
+	int (*probe)(struct platform_device *);
+	int (*remove)(struct platform_device *);
+	struct device_driver driver;
+};
+
+int platform_driver_register(struct platform_driver *);
+void platform_driver_unregister(struct platform_driver *);
+
+#define module_driver(__driver, __register, __unregister, ...) \
+static int __init __driver##_init(void) \
+{ \
+	return __register(&(__driver) , ##__VA_ARGS__); \
+} \
+module_init(__driver##_init); \
+static void __exit __driver##_exit(void) \
+{ \
+	__unregister(&(__driver) , ##__VA_ARGS__); \
+} \
+module_exit(__driver##_exit);
+
+#define module_platform_driver(__platform_driver) \
+	module_driver(__platform_driver, platform_driver_register, \
+			platform_driver_unregister)
+
+/***********************
+ ** uapi/linux/uuid.h **
+ ***********************/
+
+typedef struct {
+	__u8 b[16];
+} uuid_le;
+
+
+/************************
+ ** linux/cpuhotplug.h **
+ ************************/
+
+enum cpuhp_state {
+	CPUHP_RADIX_DEAD = 29,
+};
+
+
+/*******************
+ ** linux/sizes.h **
+ *******************/
+
+enum {
+	SZ_4K = 0x00001000,
+	SZ_16K = 0x00004000,
+};
+
+
+#include <lx_emul/extern_c_end.h>
+
+#endif /* _LX_EMUL_H_ */
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/include/lx_emul_c.h b/repos/dde_linux/src/drivers/framebuffer/imx8/include/lx_emul_c.h
new file mode 100644
index 000000000..8ef5ba858
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/include/lx_emul_c.h
@@ -0,0 +1,62 @@
+/*
+ * \brief  C-declarations needed for device driver environment
+ * \author Stefan Kalkowski
+ * \author Norman Feske
+ * \date   2016-06-17
+ */
+
+#ifndef _LX_EMUL_C_H_
+#define _LX_EMUL_C_H_
+
+#if 0
+#define TRACE \
+	do { \
+		lx_printf("%s not implemented\n", __func__); \
+	} while (0)
+#else
+#define TRACE do { ; } while (0)
+#endif
+
+#define TRACE_AND_STOP \
+	do { \
+		lx_printf("%s not implemented\n", __func__); \
+		BUG(); \
+	} while (0)
+
+#define ASSERT(x) \
+	do { \
+		if (!(x)) { \
+			lx_printf("%s:%u assertion failed\n", __func__, __LINE__); \
+			BUG(); \
+		} \
+	} while (0)
+
+#include <lx_emul/extern_c_begin.h>
+
+struct drm_device;
+struct drm_framebuffer;
+struct drm_display_mode;
+struct drm_connector;
+
+struct lx_c_fb_config {
+	int                      height;
+	int                      width;
+	unsigned                 pitch;
+	unsigned                 bpp;
+	void                   * addr;
+	unsigned long            size;
+	struct drm_framebuffer * lx_fb;
+};
+
+void   lx_c_allocate_framebuffer(struct drm_device *,
+                                 struct lx_c_fb_config *);
+
+void   lx_c_set_mode(struct drm_device *, struct drm_connector *,
+                     struct drm_framebuffer *, struct drm_display_mode *);
+
+void   lx_c_set_driver(struct drm_device *, void *);
+void * lx_c_get_driver(struct drm_device *);
+
+#include <lx_emul/extern_c_end.h>
+
+#endif /* _LX_EMUL_C_H_ */
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/include/platform_device/platform_device.h b/repos/dde_linux/src/drivers/framebuffer/imx8/include/platform_device/platform_device.h
new file mode 100644
index 000000000..bce54ace6
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/include/platform_device/platform_device.h
@@ -0,0 +1,81 @@
+/*
+ * \brief  Platform_device implementation for ARM
+ * \author Sebastian Sumpf
+ * \date   2016-04-25
+ *
+ * Note: Throw away when there exists a plaform device implementation for ARM
+ * in generic code
+ */
+
+/*
+ * Copyright (C) 2016-2017 Genode Labs GmbH
+ *
+ * This file is distributed under the terms of the GNU General Public License
+ * version 2.
+ */
+
+#ifndef _ARM__PLATFORM_DEVICE__PLATFORM_DEVICE_H_
+#define _ARM__PLATFORM_DEVICE__PLATFORM_DEVICE_H_
+
+
+#include <lx_emul/extern_c_begin.h>
+#include <lx_emul/printf.h>
+#include <lx_emul/extern_c_end.h>
+
+#include <lx_kit/malloc.h>
+#include <platform_device/device.h>
+
+#include <irq_session/connection.h>
+#include <util/list.h>
+#include <util/reconstructible.h>
+
+
+namespace Platform { struct Device; }
+
+struct Platform::Device : Platform::Abstract_device, Genode::List<Device>::Element
+{
+	Genode::Env &env;
+
+	unsigned                                      irq_num;
+	Genode::Constructible<Genode::Irq_connection> irq_connection;
+
+	Device(Genode::Env &env, unsigned irq) : env(env), irq_num(irq) { }
+
+	unsigned vendor_id() { return ~0U; }
+	unsigned device_id() { return ~0U; }
+
+	Genode::Irq_session_capability irq(Genode::uint8_t) override
+	{
+		irq_connection.construct(env, irq_num);
+		return irq_connection->cap();
+	}
+
+	Genode::Io_mem_session_capability io_mem(Genode::uint8_t,
+	                                         Genode::Cache_attribute,
+	                                         Genode::addr_t, Genode::size_t) override
+	{
+		lx_printf("%s: not implemented\n", __PRETTY_FUNCTION__);
+		return Genode::Io_mem_session_capability();
+	}
+
+	static Genode::List<Device> &list()
+	{
+		static Genode::List<Device> l;
+		return l;
+	}
+
+	static Device &create(Genode::Env &env, unsigned irq_num)
+	{
+		Device *d;
+		for (d = list().first(); d; d = d->next())
+			if (d->irq_num == irq_num)
+				return *d;
+
+		d = new (Lx::Malloc::mem()) Device(env, irq_num);
+		list().insert(d);
+
+		return *d;
+	}
+};
+
+#endif /* _ARM__PLATFORM_DEVICE__PLATFORM_DEVICE_H_ */
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/lx_emul.cc b/repos/dde_linux/src/drivers/framebuffer/imx8/lx_emul.cc
new file mode 100644
index 000000000..0d0c8cfd4
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/lx_emul.cc
@@ -0,0 +1,1906 @@
+/*
+ * \brief  Emulation of Linux kernel interfaces
+ * \author Norman Feske
+ * \author Stefan Kalkowski
+ * \author Christian Prochaska
+ * \date   2015-08-19
+ */
+
+/*
+ * Copyright (C) 2015-2019 Genode Labs GmbH
+ *
+ * This file is distributed under the terms of the GNU General Public License
+ * version 2.
+ */
+
+/* Genode includes */
+#include <base/attached_io_mem_dataspace.h>
+
+/* local includes */
+#include <component.h>
+
+#include <lx_emul.h>
+#include <lx_emul_c.h>
+
+/* DRM-specific includes */
+#include <lx_emul/extern_c_begin.h>
+#include <drm/drmP.h>
+#include <drm/drm_fb_cma_helper.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_of.h>
+#include "drm_crtc_internal.h"
+#include "drm_internal.h"
+#include <linux/component.h>
+#include <lx_emul/extern_c_end.h>
+
+#include <lx_kit/scheduler.h> /* dependency of lx_emul/impl/completion.h */
+
+#include <lx_emul/impl/completion.h>
+#include <lx_emul/impl/delay.h>
+#include <lx_emul/impl/gfp.h>
+#include <lx_emul/impl/kernel.h>
+#include <lx_emul/impl/mutex.h>
+#include <lx_emul/impl/sched.h>
+#include <lx_emul/impl/slab.h>
+#include <lx_emul/impl/spinlock.h>
+#include <lx_emul/impl/timer.h>
+#include <lx_emul/impl/wait.h> /* dependency of lx_emul/impl/work.h */
+#include <lx_emul/impl/work.h>
+
+#include <lx_kit/irq.h>
+#include <lx_kit/malloc.h>
+
+
+/********************************
+ ** drivers/base/dma-mapping.c **
+ ********************************/
+
+void *dmam_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t gfp)
+{
+	dma_addr_t dma_addr;
+	void *addr;
+	if (size > 2048) {
+		addr = Lx::Malloc::dma().alloc_large(size);
+		dma_addr = (dma_addr_t) Lx::Malloc::dma().phys_addr(addr);
+	} else
+		addr = Lx::Malloc::dma().alloc(size, 12, &dma_addr);
+
+	*dma_handle = dma_addr;
+	return addr;
+}
+
+
+/*****************************
+ ** drivers/base/platform.c **
+ *****************************/
+
+int platform_get_irq(struct platform_device *dev, unsigned int num)
+{
+	struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, 0);
+	return r ? r->start : -1;
+}
+
+int platform_get_irq_byname(struct platform_device *dev, const char *name)
+{
+	struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
+	return r ? r->start : -1;
+}
+
+struct resource *platform_get_resource(struct platform_device *dev,
+                                       unsigned int type, unsigned int num)
+{
+	unsigned i;
+
+	for (i = 0; i < dev->num_resources; i++) {
+		struct resource *r = &dev->resource[i];
+
+		if ((type & r->flags) && num-- == 0)
+			return r;
+	}
+
+	return NULL;
+}
+
+struct resource *platform_get_resource_byname(struct platform_device *dev,
+                                              unsigned int type,
+                                              const char *name)
+{
+	unsigned i;
+
+	for (i = 0; i < dev->num_resources; i++) {
+		struct resource *r = &dev->resource[i];
+
+	if (type == r->flags && !Genode::strcmp(r->name, name))
+		return r;
+	}
+
+	return NULL;
+}
+
+
+static int platform_match(struct device *dev, struct device_driver *drv)
+{
+	if (!dev->name)
+		return 0;
+
+	printk("MATCH %s %s\n", dev->name, drv->name);
+	return (Genode::strcmp(dev->name, drv->name) == 0);
+}
+
+
+#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
+                                 driver))
+
+static int platform_drv_probe(struct device *_dev)
+{
+	struct platform_driver *drv = to_platform_driver(_dev->driver);
+	struct platform_device *dev = to_platform_device(_dev);
+
+	return drv->probe(dev);
+}
+
+
+struct bus_type platform_bus_type = {
+	.name  = "platform",
+};
+
+
+int platform_driver_register(struct platform_driver * drv)
+{
+	/* init platform_bus_type */
+	platform_bus_type.match = platform_match;
+	platform_bus_type.probe = platform_drv_probe;
+
+	drv->driver.bus = &platform_bus_type;
+	if (drv->probe)
+		drv->driver.probe = platform_drv_probe;
+
+	printk("Register: %s\n", drv->driver.name);
+	return driver_register(&drv->driver);
+}
+
+
+int platform_device_add(struct platform_device *pdev)
+{
+	return platform_device_register(pdev);
+}
+
+
+int platform_device_add_data(struct platform_device *pdev, const void *data,
+                             size_t size)
+{
+	void *d = NULL;
+
+	if (data && !(d = kmemdup(data, size, GFP_KERNEL)))
+		return -ENOMEM;
+
+	kfree(pdev->dev.platform_data);
+	pdev->dev.platform_data = d;
+
+	return 0;
+}
+
+
+int platform_device_register(struct platform_device *pdev)
+{
+	pdev->dev.bus  = &platform_bus_type;
+	pdev->dev.name = pdev->name;
+	/*Set parent to ourselfs */
+	if (!pdev->dev.parent)
+		pdev->dev.parent = &pdev->dev;
+	device_add(&pdev->dev);
+
+	return 0;
+}
+
+
+struct platform_device *platform_device_alloc(const char *name, int id)
+{
+	platform_device *pdev = (platform_device *)kzalloc(sizeof(struct platform_device), GFP_KERNEL);
+
+	if (!pdev)
+		return 0;
+
+	int len    = strlen(name);
+	pdev->name = (char *)kzalloc(len + 1, GFP_KERNEL);
+
+	if (!pdev->name) {
+		kfree(pdev);
+		return 0;
+	}
+
+	memcpy(pdev->name, name, len);
+	pdev->name[len] = 0;
+	pdev->id = id;
+	pdev->dev.dma_mask = (u64*)kzalloc(sizeof(u64),  GFP_KERNEL);
+
+	spin_lock_init(&pdev->dev.devres_lock);
+	INIT_LIST_HEAD(&pdev->dev.devres_head);
+
+	return pdev;
+}
+
+
+/***********************
+ ** drivers/clk/clk.c **
+ ***********************/
+
+unsigned long clk_get_rate(struct clk * clk)
+{
+	if (!clk) return 0;
+	return clk->rate;
+}
+
+int clk_set_rate(struct clk *clk, unsigned long rate)
+{
+	if (DEBUG_DRIVER)
+		Genode::warning(__func__, "() not implemented");
+
+	if (!clk) return -1;
+	clk->rate = rate;
+	return 0;
+}
+
+
+/******************************
+ ** drivers/clk/clk-devres.c **
+ ******************************/
+
+struct clk *devm_clk_get(struct device *dev, const char *id)
+{
+	/* numbers from running Linux system */
+
+	static struct clk clocks[] {
+		{ "apb", 133333334 },
+		{ "axi", 800000000 },
+		{ "ipg", 133333334 },
+		{ "pix", 27000000 },
+		{ "rtrm", 400000000 },
+		{ "dtrc", 25000000 },
+	};
+
+	for (unsigned i = 0; i < (sizeof(clocks) / sizeof(struct clk)); i++)
+		if (Genode::strcmp(clocks[i].name, id) == 0)
+			return &clocks[i];
+
+	if (DEBUG_DRIVER)
+		Genode::warning("MISSING CLOCK: ", id);
+
+	return nullptr;
+}
+
+
+/*******************************
+ ** drivers/gpu/drm/drm_drv.c **
+ *******************************/
+
+void drm_dev_printk(const struct device *dev, const char *level,
+                    unsigned int category, const char *function_name,
+                    const char *prefix, const char *format, ...)
+{
+	struct va_format vaf;
+	va_list args;
+
+	if (category && !(drm_debug & category))
+		return;
+
+	va_start(args, format);
+	vaf.fmt = format;
+	vaf.va = &args;
+
+	if (dev)
+		dev_printk(level, dev, "[drm:%s]%s %pV", function_name, prefix,
+			   &vaf);
+	else
+		printk("%s" "[drm:%s]%s %pV", level, function_name, prefix, &vaf);
+
+	va_end(args);
+}
+
+/*****************************************
+ ** drivers/gpu/drm/drm_fb_cma_helper.c **
+ *****************************************/
+
+struct drm_gem_cma_object *drm_fb_cma_get_gem_obj(struct drm_framebuffer *fb,
+						  unsigned int plane)
+{
+	struct drm_gem_object *gem;
+
+	gem = drm_gem_fb_get_obj(fb, plane);
+	if (!gem)
+		return NULL;
+
+	return to_drm_gem_cma_obj(gem);
+}
+
+int drm_fb_cma_prepare_fb(struct drm_plane *plane,
+                          struct drm_plane_state *state)
+{
+	return drm_gem_fb_prepare_fb(plane, state);
+}
+
+
+/*********************************************
+ ** drivers/gpu/drm/imx/hdp/imx-hdp-audio.c **
+ *********************************************/
+
+void imx_hdp_register_audio_driver(struct device *dev)
+{
+	/* not supported */
+}
+
+
+/***********************
+ ** drivers/of/base.c **
+ ***********************/
+
+static struct device_node root_device_node {
+	.name = "",
+	.full_name = "",
+};
+
+static struct device_node hdmi_device_node {
+	.name = "hdmi",
+	.full_name = "hdmi",
+	.parent = &root_device_node
+};
+
+static struct device_node hdmi_endpoint_device_node {
+	.name = "hdmi-endpoint",
+	.full_name = "hdmi-endpoint",
+};
+
+static struct device_node endpoint_device_node {
+	.name = "endpoint",
+	.full_name = "endpoint",
+};
+
+static struct device_node port_device_node {
+	.name = "port",
+	.full_name = "port"
+};
+
+int of_device_is_compatible(const struct device_node *device,
+                            const char *compat)
+{
+	if (!device)
+		return false;
+
+	if (Genode::strcmp(compat, "nxp,imx8mq-dcss") == 0)
+		return true;
+
+	return false;
+}
+
+struct device_node *of_get_next_child(const struct device_node *node,
+                                      struct device_node *prev)
+{
+	if (Genode::strcmp(node->name, "port", strlen(node->name)) == 0) {
+		if (!prev)
+			return &hdmi_endpoint_device_node;
+		return NULL;
+	}
+
+	Genode::error("of_get_next_child(): unhandled node");
+
+	return NULL;
+}
+
+struct device_node *of_get_parent(const struct device_node *node)
+{
+	static device_node dcss_device_node { "dcss", "dcss" };
+
+	if (!node)
+		return NULL;
+
+	if (Genode::strcmp(node->name, "port", strlen("port")) == 0)
+		return &dcss_device_node;
+	
+	Genode::error("of_get_parent(): unhandled node");
+
+	return NULL;
+}
+
+const void *of_get_property(const struct device_node *node, const char *name, int *lenp)
+{
+	for (property * p = node ? node->properties : nullptr; p; p = p->next)
+		if (Genode::strcmp(name, p->name) == 0) return p->value;
+
+	if (DEBUG_DRIVER) Genode::warning("OF property ", name, " not found");
+	return nullptr;
+}
+
+struct device_node *of_parse_phandle(const struct device_node *np, const char *phandle_name, int index)
+{
+	/* device node information from fsl-imx8mq.dtsi */
+
+	static device_node dcss_device_node {
+		.name = "dcss",
+		.full_name = "dcss",
+	};
+
+	static device_node port_device_node {
+		.name = "port",
+		.full_name = "port",
+		.parent = &dcss_device_node
+	};
+
+	if ((Genode::strcmp(phandle_name, "ports", strlen(phandle_name)) == 0) &&
+	    (index == 0))
+		return &port_device_node;
+
+	if (DEBUG_DRIVER)
+		Genode::warning("of_parse_phandle(): unhandled phandle or index");
+
+	return NULL;
+}
+
+
+/*************************
+ ** drivers/of/device.c **
+ *************************/
+
+extern struct dcss_devtype dcss_type_imx8m; 
+
+const void *of_device_get_match_data(const struct device *dev)
+{
+	if (Genode::strcmp(dev->name, "dcss-core", strlen(dev->name)) == 0)
+		return &dcss_type_imx8m;
+
+	return NULL;
+}
+
+const struct of_device_id *of_match_device(const struct of_device_id *matches,
+                                           const struct device *dev)
+{
+	const char * compatible = (const char*) of_get_property(dev->of_node, "compatible", 0);
+
+	for (; matches && matches->compatible[0]; matches++) {
+		if (Genode::strcmp(matches->compatible, compatible) == 0)
+			return matches;
+	}
+	return nullptr;
+}
+
+
+/***************************
+ ** drivers/of/property.c **
+ ***************************/
+
+struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
+                                               struct device_node *prev)
+{
+	if (Genode::strcmp(parent->name, "hdmi", strlen(parent->name)) == 0) {
+
+		if (!prev)
+			return &endpoint_device_node;
+
+		return nullptr;
+	}
+
+	Genode::error(__func__, "(): unhandled parent");
+
+	return nullptr;
+}
+
+struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
+{
+	if ((Genode::strcmp(parent->name, "dcss", strlen(parent->name)) == 0) &&
+	    (id == 0))
+		return &port_device_node;
+
+	Genode::error("of_graph_get_port_by_id(): unhandled parent or id\n");
+
+	return NULL;
+}
+
+struct device_node *of_graph_get_remote_port(const struct device_node *node)
+{
+	if (Genode::strcmp(node->name, "endpoint", strlen(node->name)) == 0)
+		return &port_device_node;
+
+	Genode::error("of_graph_get_remote_port(): unhandled node\n");
+
+	return NULL;
+}
+
+struct device_node *of_graph_get_remote_port_parent(const struct device_node *node)
+{
+	if (Genode::strcmp(node->name, "hdmi-endpoint") == 0)
+		return &hdmi_device_node;
+
+	Genode::error("of_graph_get_remote_port_parent(): unhandled node");
+
+	return NULL;
+}
+
+
+/********************************
+ ** drivers/soc/imx/soc-imx8.c **
+ ********************************/
+
+bool check_hdcp_enabled(void)
+{
+	return false;
+}
+
+bool cpu_is_imx8mq(void)
+{
+	return true;
+}
+
+bool cpu_is_imx8qm(void)
+{
+	return false;
+}
+
+unsigned int imx8_get_soc_revision(void)
+{
+	/* XXX: acquire from firmware if this becomes necessary */
+	return SOC_REVISION;
+}
+
+
+/***********************
+ ** kernel/irq/chip.c **
+ ***********************/
+
+static struct irq_chip *irqsteer_chip = nullptr;
+
+static struct irq_desc irqsteer_irq_desc;
+
+static irqreturn_t irqsteer_irq_handler(int irq, void *data)
+{
+	irqsteer_irq_desc.handle_irq(&irqsteer_irq_desc);
+	return IRQ_HANDLED;
+}
+
+void irq_set_chained_handler_and_data(unsigned int irq,
+                                      irq_flow_handler_t handle,
+                                      void *data)
+{
+	irqsteer_irq_desc.irq_common_data.handler_data = data;
+	irqsteer_irq_desc.irq_data.chip = irqsteer_chip;
+	irqsteer_irq_desc.handle_irq = handle;
+
+	Lx::Irq::irq().request_irq(Platform::Device::create(Lx_kit::env().env(), irq),
+	                           irq, irqsteer_irq_handler, nullptr, nullptr);
+}
+
+
+/*************************
+ ** kernel/irq/devres.c **
+ *************************/
+
+int devm_request_threaded_irq(struct device *dev, unsigned int irq,
+			      irq_handler_t handler, irq_handler_t thread_fn,
+			      unsigned long irqflags, const char *devname,
+			      void *dev_id)
+{
+	if (irq < 32) {
+		Genode::error(__func__, "(): unexpected irq ", irq);
+		return -1;
+	}
+
+	Lx::Irq::irq().request_irq(Platform::Device::create(Lx_kit::env().env(), irq),
+	                           irq, handler, dev_id, thread_fn);
+
+	return 0;
+}
+
+
+/**************************
+ ** kernel/irq/irqdesc.c **
+ **************************/
+
+static irq_handler_t irqsteer_handler[32];
+static void *irqsteer_dev_id[32];
+
+int generic_handle_irq(unsigned int irq)
+{
+	/* only irqsteer irqs (< 32) are expected */
+
+	if (irq > 31) {
+		Genode::error(__func__, "(): unexpected irq ", irq);
+		Genode::sleep_forever();
+	}
+
+	if (!irqsteer_handler[irq]) {
+		Genode::error(__func__, "(): missing handler for irq ", irq);
+		return -1;
+	}
+	
+	irqsteer_handler[irq](irq, irqsteer_dev_id[irq]);
+
+	return 0;
+}
+
+
+/****************************
+ ** kernel/irq/irqdomain.c **
+ ****************************/
+
+struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
+				    irq_hw_number_t hwirq_max, int direct_max,
+				    const struct irq_domain_ops *ops,
+				    void *host_data)
+{
+	static struct irq_domain domain = {
+		.ops = ops,
+		.host_data = host_data,
+	};
+
+	{
+		/* trigger a call of 'irq_set_chip_and_handler()' to get access to the irq_chip struct */
+		static bool mapped = false;
+		if (!mapped) {
+			mapped = true;
+			ops->map(&domain, 0, 0);
+		}
+	}
+
+	return &domain;
+}
+
+
+/*************************
+ ** kernel/irq/manage.c **
+ *************************/
+
+void enable_irq(unsigned int irq)
+{
+	if (irq < 32) {
+		if (!irqsteer_chip)
+			panic("'irqsteer_chip' uninitialized");
+
+		struct irq_data irq_data {
+			.hwirq = irq,
+			.chip = irqsteer_chip,
+			.chip_data = irqsteer_irq_desc.irq_common_data.handler_data,
+		};
+
+		irqsteer_chip->irq_unmask(&irq_data);
+		return;
+	}
+
+	Lx::Irq::irq().enable_irq(irq);
+}
+
+void disable_irq(unsigned int irq)
+{
+	if (irq < 32) {
+		if (!irqsteer_chip)
+			panic("'irqsteer_chip' uninitialized");
+
+		struct irq_data irq_data {
+			.hwirq = irq,
+			.chip = irqsteer_chip,
+			.chip_data = irqsteer_irq_desc.irq_common_data.handler_data,
+		};
+
+		irqsteer_chip->irq_mask(&irq_data);
+		return;
+	}
+
+	Lx::Irq::irq().disable_irq(irq);
+}
+
+int disable_irq_nosync(unsigned int irq)
+{
+	disable_irq(irq);
+	return 0;
+}
+
+
+/******************
+ ** lib/devres.c **
+ ******************/
+
+static void *_ioremap(phys_addr_t phys_addr, unsigned long size, int wc)
+{
+	try {
+		Genode::Attached_io_mem_dataspace *ds = new(Lx::Malloc::mem())
+			Genode::Attached_io_mem_dataspace(Lx_kit::env().env(), phys_addr, size, !!wc);
+		return ds->local_addr<void>();
+	} catch (...) {
+		panic("Failed to request I/O memory: [%lx,%lx)", phys_addr, phys_addr + size);
+		return 0;
+	}
+}
+
+void *devm_ioremap(struct device *dev, resource_size_t offset,
+                   unsigned long size)
+{
+	return _ioremap(offset, size, 0);
+}
+
+void *devm_ioremap_resource(struct device *dev, struct resource *res)
+{
+	return _ioremap(res->start, (res->end - res->start) + 1, 0);
+}
+
+
+/******************
+ ** lib/string.c **
+ ******************/
+
+int strcmp(const char *a,const char *b)
+{
+	return Genode::strcmp(a, b);
+}
+
+
+/************************
+ ** linux/completion.h **
+ ************************/
+
+void reinit_completion(struct completion *work)
+{
+	init_completion(work);
+}
+
+
+/********************
+ ** linux/device.h **
+ ********************/
+
+/**
+ * Simple driver management class
+ */
+class Driver : public Genode::List<Driver>::Element
+{
+	private:
+
+		struct device_driver *_drv; /* Linux driver */
+
+	public:
+
+		Driver(struct device_driver *drv) : _drv(drv)
+		{
+			list()->insert(this);
+		}
+
+		/**
+		 * List of all currently registered drivers
+		 */
+		static Genode::List<Driver> *list()
+		{
+			static Genode::List<Driver> _list;
+			return &_list;
+		}
+
+		/**
+		 * Match device and drivers
+		 */
+		bool match(struct device *dev)
+		{
+			/*
+			 *  Don't try if buses don't match, since drivers often use 'container_of'
+			 *  which might cast the device to non-matching type
+			 */
+			if (_drv->bus != dev->bus)
+				return false;
+
+			return _drv->bus->match ? _drv->bus->match(dev, _drv) : true;
+		}
+
+		/**
+		 * Probe device with driver
+		 */
+		int probe(struct device *dev)
+		{
+			dev->driver = _drv;
+
+			if (dev->bus->probe)
+				return dev->bus->probe(dev);
+			else if (_drv->probe)
+				return _drv->probe(dev);
+
+			return 0;
+		}
+};
+
+
+int driver_register(struct device_driver *drv)
+{
+	new (Lx::Malloc::mem()) Driver(drv);
+	return 0;
+}
+
+
+int device_add(struct device *dev)
+{
+	if (dev->driver)
+		return 0;
+
+	/* foreach driver match and probe device */
+	for (Driver *driver = Driver::list()->first(); driver; driver = driver->next())
+		if (driver->match(dev)) {
+			int ret = driver->probe(dev);
+
+			if (!ret) return 0;
+		}
+
+	return 0;
+}
+
+
+
+/*************************
+ ** linux/dma-mapping.h **
+ *************************/
+
+struct Dma_wc_dataspace : Genode::Attached_ram_dataspace,
+                          Genode::List<Dma_wc_dataspace>::Element
+{
+	Dma_wc_dataspace(size_t size)
+	: Genode::Attached_ram_dataspace(Lx_kit::env().ram(),
+	                                 Lx_kit::env().rm(),
+	                                 size,
+	                                 Genode::Cache_attribute::WRITE_COMBINED) { }
+};
+
+static Genode::List<Dma_wc_dataspace> &_dma_wc_ds_list()
+{
+	static Genode::List<Dma_wc_dataspace> inst;
+	return inst;
+}
+
+void *dma_alloc_wc(struct device *dev, size_t size,
+                   dma_addr_t *dma_addr, gfp_t gfp)
+{
+	Dma_wc_dataspace *dma_wc_ds = new (Lx::Malloc::mem()) Dma_wc_dataspace(size);
+
+	_dma_wc_ds_list().insert(dma_wc_ds);
+
+	*dma_addr = Genode::Dataspace_client(dma_wc_ds->cap()).phys_addr();
+	return dma_wc_ds->local_addr<void>();
+}
+
+void dma_free_wc(struct device *dev, size_t size,
+                 void *cpu_addr, dma_addr_t dma_addr)
+{
+	for (Dma_wc_dataspace *ds = _dma_wc_ds_list().first(); ds; ds = ds->next()) {
+		if (ds->local_addr<void>() == cpu_addr) {
+			_dma_wc_ds_list().remove(ds);
+			destroy(Lx::Malloc::mem(), ds);
+			return;
+		}
+	}
+
+	Genode::error("dma_free_wc(): unknown address");
+}
+
+
+/***********************
+ ** linux/interrupt.h **
+ ***********************/
+
+int devm_request_irq(struct device *dev, unsigned int irq,
+                     irq_handler_t handler, unsigned long irqflags,
+                     const char *devname, void *dev_id)
+{
+	if (irq < 32) {
+		irqsteer_handler[irq] = handler;
+		irqsteer_dev_id[irq] = dev_id;
+		enable_irq(irq);
+	} else
+		Lx::Irq::irq().request_irq(Platform::Device::create(Lx_kit::env().env(), irq),
+		                           irq, handler, dev_id);
+
+	return 0;
+}
+
+
+/*****************
+ ** linux/irq.h **
+ *****************/
+
+void irq_set_chip_and_handler(unsigned int irq, struct irq_chip *chip,
+                              irq_flow_handler_t)
+{
+	irqsteer_chip = chip;
+}
+
+
+/****************
+ ** linux/of.h **
+ ****************/
+
+bool of_property_read_bool(const struct device_node *np, const char *propname)
+{
+	if ((Genode::strcmp(np->name, "hdmi", strlen(np->name)) == 0)) {
+
+		if ((Genode::strcmp(propname, "fsl,cec", strlen(np->name)) == 0) ||
+		    (Genode::strcmp(propname, "fsl,use_digpll_pclock", strlen(np->name)) == 0) ||
+		    (Genode::strcmp(propname, "fsl,no_edid", strlen(np->name)) == 0))
+			return false;
+
+		Genode::error(__func__, "(): unhandled property '", propname,
+		                        "' of device '", Genode::Cstring(np->name), "'");
+
+		return false;
+	}
+
+	Genode::error(__func__, "(): unhandled device '", Genode::Cstring(np->name),
+	                        "' (property: '", Genode::Cstring(propname), "')");
+
+	return false;
+}
+
+int of_property_read_string(const struct device_node *np, const char *propname,
+                            const char **out_string)
+{
+	if (Genode::strcmp(np->name, "hdmi", strlen(np->name)) == 0) {
+
+	    if (Genode::strcmp(propname, "compatible") == 0) {
+			*out_string = "fsl,imx8mq-hdmi";
+			return 0;
+		}
+
+		Genode::error(__func__, "(): unhandled property '", propname,
+		                        "' of device '", Genode::Cstring(np->name), "'");
+		return -1;
+	}
+
+	Genode::error(__func__, "(): unhandled device '", Genode::Cstring(np->name),
+	                        "' (property: '", Genode::Cstring(propname), "')");
+	return -1;
+}
+
+int of_property_read_u32(const struct device_node *np, const char *propname, u32 *out_value)
+{
+
+	if ((Genode::strcmp(np->name, "imx-irqsteer", strlen(np->name)) == 0)) {
+
+		if (Genode::strcmp(propname, "nxp,irqsteer_chans") == 0) {
+
+			*out_value = 2;
+			return 0;
+
+		} else if (Genode::strcmp(propname, "nxp,endian") == 0) {
+
+			*out_value = 1;
+			return 0;
+		}
+
+		Genode::error(__func__, "(): unhandled property '", propname,
+		                        "' of device '", Genode::Cstring(np->name), "'");
+		return -1;
+
+	} else if (Genode::strcmp(np->name, "hdmi", strlen(np->name)) == 0) {
+
+	    if (Genode::strcmp(propname, "hdcp-config") == 0) {
+		    /* no such property in original device tree */
+			return -1;
+		}
+
+		Genode::error(__func__, "(): unhandled property '", propname,
+		                        "' of device '", Genode::Cstring(np->name), "'");
+		return -1;
+	}
+
+	Genode::error(__func__, "(): unhandled device '", Genode::Cstring(np->name),
+	                        "' (property: '", Genode::Cstring(propname), "')");
+
+	return -1;
+}
+
+
+/***************
+ ** mm/util.c **
+ ***************/
+
+void kvfree(const void *p)
+{
+	kfree(p);
+}
+
+
+static struct drm_device * lx_drm_device = nullptr;
+
+struct irq_chip dummy_irq_chip;
+
+enum { MAX_BRIGHTNESS = 100U }; /* we prefer percentage */
+
+struct Mutex_guard
+{
+	struct mutex &_mutex;
+	Mutex_guard(struct mutex &m) : _mutex(m) { mutex_lock(&_mutex); }
+	~Mutex_guard() { mutex_unlock(&_mutex); }
+};
+
+struct Drm_guard
+{
+	drm_device * _dev;
+
+	Drm_guard(drm_device *dev) : _dev(dev)
+	{
+		if (dev) {
+			mutex_lock(&dev->mode_config.mutex);
+			mutex_lock(&dev->mode_config.blob_lock);
+			drm_modeset_lock_all(dev);
+		}
+	}
+
+	~Drm_guard()
+	{
+		if (_dev) {
+			drm_modeset_unlock_all(_dev);
+			mutex_unlock(&_dev->mode_config.mutex);
+			mutex_unlock(&_dev->mode_config.blob_lock);
+		}
+	}
+};
+
+
+template <typename FUNCTOR>
+static inline void lx_for_each_connector(drm_device * dev, FUNCTOR f)
+{
+	struct drm_connector *connector;
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+		f(connector);
+}
+
+
+drm_display_mode *
+Framebuffer::Driver::_preferred_mode(drm_connector *connector,
+                                     unsigned &brightness)
+{
+	using namespace Genode;
+	using Genode::size_t;
+
+	/* try to read configuration for connector */
+	try {
+		Xml_node config = _session.config();
+		Xml_node xn = config.sub_node();
+		for (unsigned i = 0; i < config.num_sub_nodes(); xn = xn.next()) {
+			if (!xn.has_type("connector"))
+				continue;
+
+			typedef String<64> Name;
+			Name const con_policy = xn.attribute_value("name", Name());
+			if (con_policy != connector->name)
+				continue;
+
+			bool enabled = xn.attribute_value("enabled", true);
+			if (!enabled)
+				return nullptr;
+
+			brightness = xn.attribute_value("brightness",
+			                                (unsigned)MAX_BRIGHTNESS + 1);
+
+			unsigned long const width  = xn.attribute_value("width",  0UL);
+			unsigned long const height = xn.attribute_value("height", 0UL);
+			long          const hz     = xn.attribute_value("hz",     0L);
+
+			struct drm_display_mode *mode;
+			list_for_each_entry(mode, &connector->modes, head) {
+			if (mode->hdisplay == (int) width &&
+				mode->vdisplay == (int) height)
+				if (!hz || hz == mode->vrefresh)
+					return mode;
+		};
+		}
+	} catch (...) {
+
+		/**
+		 * If no config is given, we take the most wide mode of a
+		 * connector as long as it is connected at all
+		 */
+		if (connector->status != connector_status_connected)
+			return nullptr;
+
+		struct drm_display_mode *mode = nullptr, *tmp;
+		list_for_each_entry(tmp, &connector->modes, head) {
+			if (!mode || tmp->hdisplay > mode->hdisplay) mode = tmp;
+		};
+		return mode;
+   	}
+
+	return nullptr;
+}
+
+
+void Framebuffer::Driver::finish_initialization()
+{
+	if (!lx_drm_device) {
+		Genode::error("no drm device");
+		return;
+	}
+
+	lx_c_set_driver(lx_drm_device, (void*)this);
+
+	generate_report();
+
+	_session.config_changed();
+}
+
+
+void Framebuffer::Driver::update_mode()
+{
+	using namespace Genode;
+
+	Configuration old = _config;
+	_config = Configuration();
+
+	lx_for_each_connector(lx_drm_device, [&] (drm_connector *c) {
+		unsigned brightness;
+		drm_display_mode * mode = _preferred_mode(c, brightness);
+		if (!mode) return;
+		if (mode->hdisplay > _config._lx.width)  _config._lx.width  = mode->hdisplay;
+		if (mode->vdisplay > _config._lx.height) _config._lx.height = mode->vdisplay;
+
+	});
+
+	lx_c_allocate_framebuffer(lx_drm_device, &_config._lx);
+
+	if (!_config._lx.lx_fb) {
+		Genode::error("updating framebuffer failed");
+		return;
+	}
+
+	{
+		Drm_guard guard(lx_drm_device);
+		lx_for_each_connector(lx_drm_device, [&] (drm_connector *c) {
+			unsigned brightness = MAX_BRIGHTNESS + 1;
+
+			/* set mode */
+			lx_c_set_mode(lx_drm_device, c, _config._lx.lx_fb,
+			              _preferred_mode(c, brightness));
+		});
+	}
+
+	/* force virtual framebuffer size if requested */
+	if (int w = _session.force_width_from_config())
+		_config._lx.width = min(_config._lx.width, w);
+	if (int h = _session.force_height_from_config())
+		_config._lx.height = min(_config._lx.height, h);
+
+	if (old._lx.lx_fb) {
+		if (drm_framebuffer_read_refcount(old._lx.lx_fb) > 1) {
+			/*
+			 * If one sees this message, we are going to leak a lot of
+			 * memory (e.g. framebuffer) and this will cause later on
+			 * resource requests by this driver ...
+			 */
+			Genode::warning("framebuffer refcount ",
+			                drm_framebuffer_read_refcount(old._lx.lx_fb));
+		}
+		drm_framebuffer_remove(old._lx.lx_fb);
+	}
+}
+
+
+void Framebuffer::Driver::generate_report()
+{
+	/* detect mode information per connector */
+	{
+		Mutex_guard mutex(lx_drm_device->mode_config.mutex);
+
+		struct drm_connector *c;
+		list_for_each_entry(c, &lx_drm_device->mode_config.connector_list,
+		                    head)
+		{
+			/*
+			 * All states unequal to disconnected are handled as connected,
+			 * since some displays stay in unknown state if not fill_modes()
+			 * is called at least one time.
+			 */
+			bool connected = c->status != connector_status_disconnected;
+			if ((connected && list_empty(&c->modes)) ||
+			    (!connected && !list_empty(&c->modes)))
+				c->funcs->fill_modes(c, 0, 0);
+		}
+	}
+
+	/* check for report configuration option */
+	try {
+		_reporter.enabled(_session.config().sub_node("report")
+		                 .attribute_value(_reporter.name().string(), false));
+	} catch (...) {
+		_reporter.enabled(false);
+	}
+	if (!_reporter.enabled()) return;
+
+	/* write new report */
+	try {
+		Genode::Reporter::Xml_generator xml(_reporter, [&] ()
+		{
+			Drm_guard guard(lx_drm_device);
+			struct drm_connector *c;
+			list_for_each_entry(c, &lx_drm_device->mode_config.connector_list,
+			                    head) {
+				xml.node("connector", [&] ()
+				{
+					bool connected = c->status == connector_status_connected;
+					xml.attribute("name", c->name);
+					xml.attribute("connected", connected);
+
+					if (!connected) return;
+
+					struct drm_display_mode *mode;
+					list_for_each_entry(mode, &c->modes, head) {
+						xml.node("mode", [&] ()
+						{
+							xml.attribute("width",  mode->hdisplay);
+							xml.attribute("height", mode->vdisplay);
+							xml.attribute("hz",     mode->vrefresh);
+						});
+					}
+				});
+			}
+		});
+	} catch (...) {
+		Genode::warning("Failed to generate report");
+	}
+}
+
+
+extern "C" {
+
+
+/****************************
+ ** kernel/printk/printk.c **
+ ****************************/
+ 
+int oops_in_progress;
+
+
+/********************
+ ** linux/string.h **
+ ********************/
+
+char *strncpy(char *dst, const char* src, size_t n)
+{
+	return Genode::strncpy(dst, src, n);
+}
+
+int strncmp(const char *cs, const char *ct, size_t count)
+{
+	return Genode::strcmp(cs, ct, count);
+}
+
+int memcmp(const void *cs, const void *ct, size_t count)
+{
+	/* original implementation from lib/string.c */
+	const unsigned char *su1, *su2;
+	int res = 0;
+
+	for (su1 = (unsigned char*)cs, su2 = (unsigned char*)ct;
+	     0 < count; ++su1, ++su2, count--)
+		if ((res = *su1 - *su2) != 0)
+			break;
+	return res;
+}
+
+void *memchr_inv(const void *s, int cc, size_t n)
+{
+	if (!s)
+		return NULL;
+
+	uint8_t const c = cc;
+	uint8_t const * start = (uint8_t const *)s;
+
+	for (uint8_t const *i = start; i >= start && i < start + n; i++)
+		if (*i != c)
+			return (void *)i;
+
+	return NULL;
+}
+
+size_t strlen(const char *s)
+{
+	return Genode::strlen(s);
+}
+
+long simple_strtol(const char *cp, char **endp, unsigned int base)
+{
+	unsigned long result = 0;
+	size_t ret = Genode::ascii_to_unsigned(cp, result, base);
+	if (endp) *endp = (char*)cp + ret;
+	return result;
+}
+
+size_t strlcpy(char *dest, const char *src, size_t size)
+{
+	size_t ret = strlen(src);
+
+	if (size) {
+		size_t len = (ret >= size) ? size - 1 : ret;
+		Genode::memcpy(dest, src, len);
+		dest[len] = '\0';
+	}
+	return ret;
+}
+
+
+/*******************
+ ** Kernel memory **
+ *******************/
+
+void *krealloc(const void *p, size_t size, gfp_t flags)
+{
+	/* use const-less version from <impl/slab.h> */
+	return krealloc(const_cast<void*>(p), size, flags);
+}
+
+
+/*******************************
+ ** arch/x86/include/asm/io.h **
+ *******************************/
+
+void memset_io(void *addr, int val, size_t count)
+{
+	memset((void __force *)addr, val, count);
+}
+
+
+/********************
+ ** linux/device.h **
+ ********************/
+
+int dev_set_name(struct device *dev, const char *name, ...)
+{
+	TRACE;
+	return 0;
+}
+
+void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
+{
+	return kzalloc(size, gfp);
+}
+
+
+/***********************
+ ** linux/workqueue.h **
+ ***********************/
+
+struct workqueue_struct *system_wq = nullptr;
+
+struct workqueue_struct *alloc_workqueue(const char *fmt, unsigned int flags,
+                                         int max_active, ...)
+{
+	workqueue_struct *wq = (workqueue_struct *)kzalloc(sizeof(workqueue_struct), 0);
+	Lx::Work *work = Lx::Work::alloc_work_queue(&Lx::Malloc::mem(), fmt);
+	wq->task       = (void *)work;
+
+	return wq;
+}
+
+struct workqueue_struct *alloc_ordered_workqueue(char const *fmt , unsigned int flags, ...)
+{
+	return alloc_workqueue(fmt, flags, 1);
+}
+
+bool mod_delayed_work(struct workqueue_struct *wq, struct delayed_work *dwork,
+                      unsigned long delay)
+{
+	TRACE;
+	return queue_delayed_work(wq, dwork, delay);
+}
+
+void flush_workqueue(struct workqueue_struct *wq)
+{
+	Lx::Task *current = Lx::scheduler().current();
+	if (!current) {
+		Genode::error("BUG: flush_workqueue executed without task");
+		Genode::sleep_forever();
+	}
+
+	Lx::Work *lx_work = (wq && wq->task) ? (Lx::Work*) wq->task
+	                                     : &Lx::Work::work_queue();
+
+	lx_work->flush(*current);
+	Lx::scheduler().current()->block_and_schedule();
+}
+
+
+/***************
+ ** Execution **
+ ***************/
+
+void preempt_enable(void)
+{
+	TRACE;
+}
+
+void preempt_disable(void)
+{
+	TRACE;
+}
+
+void usleep_range(unsigned long min, unsigned long max)
+{
+	udelay(min);
+}
+
+
+/*******************
+ ** linux/timer.h **
+ *******************/
+
+struct callback_timer {
+	void (*function)(unsigned long);
+	unsigned long data;
+};
+
+/*
+ * For compatibility with 4.4.3 drivers, the argument of this callback function
+ * is the 'data' member of the 'timer_list' object, which normally points to
+ * the 'timer_list' object itself when initialized with 'timer_setup()', but
+ * here it was overridden in 'setup_timer()' to point to the 'callback_timer'
+ * object instead.
+ */
+static void timer_callback(struct timer_list *t)
+{
+	struct callback_timer * tc = (struct callback_timer *)t;
+	tc->function(tc->data);
+}
+
+extern "C" void setup_timer(struct timer_list *timer, void (*function)(unsigned long),
+                            unsigned long data)
+{
+	callback_timer * tc = new (Lx::Malloc::mem()) callback_timer;
+	tc->function = function;
+	tc->data     = data;
+
+	timer_setup(timer, timer_callback, 0u);
+	timer->data = (unsigned long)tc;
+}
+
+
+/************************
+ ** DRM implementation **
+ ************************/
+
+unsigned int drm_debug = 0x0;
+
+struct drm_device *drm_dev_alloc(struct drm_driver *driver,
+				 struct device *parent)
+{
+	struct drm_device *dev;
+	int ret;
+
+	dev = (struct drm_device*)kzalloc(sizeof(*dev), GFP_KERNEL);
+	if (!dev)
+		return (struct drm_device*)ERR_PTR(-ENOMEM);
+
+	ret = drm_dev_init(dev, driver, parent);
+	if (ret) {
+		kfree(dev);
+		return (struct drm_device*)ERR_PTR(ret);
+	}
+
+	return dev;
+}
+
+
+int drm_dev_init(struct drm_device *dev, struct drm_driver *driver,
+                 struct device *parent)
+{
+	TRACE;
+
+	kref_init(&dev->ref);
+	dev->dev = parent;
+	dev->driver = driver;
+
+	INIT_LIST_HEAD(&dev->filelist);
+	INIT_LIST_HEAD(&dev->ctxlist);
+	INIT_LIST_HEAD(&dev->vmalist);
+	INIT_LIST_HEAD(&dev->maplist);
+	INIT_LIST_HEAD(&dev->vblank_event_list);
+
+	spin_lock_init(&dev->buf_lock);
+	spin_lock_init(&dev->event_lock);
+	mutex_init(&dev->struct_mutex);
+	mutex_init(&dev->filelist_mutex);
+	mutex_init(&dev->ctxlist_mutex);
+	mutex_init(&dev->master_mutex);
+
+	if (drm_gem_init(dev) != 0)
+		DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
+
+	return 0;
+}
+
+
+void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e)
+{
+	if (e->completion) {
+		complete_all(e->completion);
+		e->completion_release(e->completion);
+		e->completion = NULL;
+	}
+
+	if (e->fence) {
+		TRACE_AND_STOP;
+	}
+}
+
+static void drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type)
+{
+	struct drm_minor *new_minor = (struct drm_minor*)
+		kzalloc(sizeof(struct drm_minor), GFP_KERNEL);
+	ASSERT(new_minor);
+	new_minor->type = type;
+	new_minor->dev = dev;
+	*minor = new_minor;
+}
+
+int drm_dev_register(struct drm_device *dev, unsigned long flags)
+{
+	drm_get_minor(dev, &dev->primary, DRM_MINOR_PRIMARY);
+
+	int ret = 0;
+
+	ASSERT(!lx_drm_device);
+	lx_drm_device = dev;
+
+	dev->registered = true;
+
+	if (dev->driver->load) {
+		ret = dev->driver->load(dev, flags);
+		if (ret)
+			return ret;
+	}
+
+	if (drm_core_check_feature(dev, DRIVER_MODESET))
+		drm_modeset_register_all(dev);
+
+	DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
+		 dev->driver->name, dev->driver->major, dev->driver->minor,
+		 dev->driver->patchlevel, dev->driver->date,
+		 dev->primary->index);
+
+	return 0;
+}
+
+
+/**************************************
+ ** arch/arm64/include/asm/processor.h **
+ **************************************/
+
+void cpu_relax(void)
+{
+	Lx::timer_update_jiffies();
+	asm volatile("yield" ::: "memory");
+}
+
+
+/******************
+ ** linux/kref.h **
+ ******************/
+
+void kref_init(struct kref *kref) {
+	kref->refcount.counter = 1; }
+
+void kref_get(struct kref *kref)
+{
+	if (!kref->refcount.counter)
+		Genode::error(__func__, " kref already zero");
+
+	kref->refcount.counter++;
+}
+
+int kref_put(struct kref *kref, void (*release) (struct kref *kref))
+{
+	if (!kref->refcount.counter) {
+		Genode::error(__func__, " kref already zero");
+		return 1;
+	}
+
+	kref->refcount.counter--;
+	if (kref->refcount.counter == 0) {
+		release(kref);
+		return 1;
+	}
+	return 0;
+}
+
+int kref_put_mutex(struct kref *kref, void (*release)(struct kref *kref), struct mutex *lock)
+{
+	if (kref_put(kref, release)) {
+		mutex_lock(lock);
+		return 1;
+	}
+	return 0;
+}
+
+int kref_get_unless_zero(struct kref *kref)
+{
+	if (!kref->refcount.counter)
+		return 0;
+
+	kref_get(kref);
+	return 1;
+}
+
+void *kmalloc_array(size_t n, size_t size, gfp_t flags)
+{
+	if (size != 0 && n > SIZE_MAX / size) return NULL;
+	return kmalloc(n * size, flags);
+}
+
+unsigned int kref_read(const struct kref *kref)
+{
+	TRACE;
+	return atomic_read(&kref->refcount);
+}
+
+
+/**************************************
+ ** Stubs for non-ported driver code **
+ **************************************/
+
+int drm_sysfs_connector_add(struct drm_connector *connector)
+{
+	TRACE;
+	connector->kdev = (struct device*)
+		kmalloc(sizeof(struct device), GFP_KERNEL);
+	DRM_DEBUG("adding \"%s\" to sysfs\n", connector->name);
+	drm_sysfs_hotplug_event(connector->dev);
+	return 0;
+}
+
+void drm_sysfs_connector_remove(struct drm_connector *connector)
+{
+	kfree(connector->kdev);
+	connector->kdev = nullptr;
+	DRM_DEBUG("removing \"%s\" from sysfs\n", connector->name);
+	drm_sysfs_hotplug_event(connector->dev);
+}
+
+void spin_lock_irq(spinlock_t *lock)
+{
+	TRACE;
+}
+
+void spin_unlock_irq(spinlock_t *lock)
+{
+	TRACE;
+}
+
+int fb_get_options(const char *name, char **option)
+{
+	return 0;
+}
+
+void spin_lock(spinlock_t *lock)
+{
+	TRACE;
+}
+
+struct file *shmem_file_setup(const char *name, loff_t const size,
+                              unsigned long flags)
+{
+	return nullptr;
+}
+
+void fput(struct file *file)
+{
+	if (!file)
+		return;
+
+	if (file->f_mapping) {
+		if (file->f_mapping->my_page) {
+			free_pages((unsigned long)file->f_mapping->my_page->addr, /* unknown order */ 0);
+			file->f_mapping->my_page = nullptr;
+		}
+		kfree(file->f_mapping);
+	}
+	kfree(file);
+}
+
+void ww_mutex_init(struct ww_mutex *lock, struct ww_class *ww_class)
+{
+	lock->ctx = NULL;
+	lock->locked = false;
+}
+
+void ww_acquire_init(struct ww_acquire_ctx *ctx, struct ww_class *ww_class)
+{
+	TRACE;
+}
+
+int  ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+	if (ctx && (lock->ctx == ctx))
+		return -EALREADY;
+
+	if (lock->locked) {
+		Genode::warning(__func__, " already locked");
+		return 1;
+	}
+
+	lock->ctx = ctx;
+	lock->locked = true;
+	return 0;
+}
+
+void ww_mutex_unlock(struct ww_mutex *lock)
+{
+	lock->ctx = NULL;
+	lock->locked = false;
+}
+
+bool ww_mutex_is_locked(struct ww_mutex *lock)
+{
+	return lock->locked;
+}
+
+void ww_acquire_fini(struct ww_acquire_ctx *ctx)
+{
+	TRACE;
+}
+
+void drm_sysfs_hotplug_event(struct drm_device *dev)
+{
+	Framebuffer::Driver * driver = (Framebuffer::Driver*)
+		lx_c_get_driver(lx_drm_device);
+
+	if (driver) {
+		DRM_DEBUG("generating hotplug event\n");
+		driver->generate_report();
+		driver->trigger_reconfiguration();
+	}
+}
+
+#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
+#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
+
+unsigned long find_next_bit(const unsigned long *addr, unsigned long nbits,
+                            unsigned long start)
+{
+	unsigned long tmp;
+
+	if (!nbits || start >= nbits)
+		return nbits;
+
+	tmp = addr[start / BITS_PER_LONG] ^ 0UL;
+
+	/* Handle 1st word. */
+	tmp &= BITMAP_FIRST_WORD_MASK(start);
+	start = round_down(start, BITS_PER_LONG);
+
+	while (!tmp) {
+		start += BITS_PER_LONG;
+		if (start >= nbits)
+			return nbits;
+		tmp = addr[start / BITS_PER_LONG] ^ 0UL;
+	}
+
+	return min(start + __ffs(tmp), nbits);
+}
+
+void bitmap_set(unsigned long *map, unsigned int start, int len)
+{
+	unsigned long *p = map + BIT_WORD(start);
+	const unsigned int size = start + len;
+	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
+	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
+
+	while (len - bits_to_set >= 0) {
+		*p |= mask_to_set;
+		len -= bits_to_set;
+		bits_to_set = BITS_PER_LONG;
+		mask_to_set = ~0UL;
+		p++;
+	}
+	if (len) {
+		mask_to_set &= BITMAP_LAST_WORD_MASK(size);
+		*p |= mask_to_set;
+	}
+}
+
+unsigned long find_next_zero_bit(unsigned long const *addr, unsigned long size,
+                                 unsigned long offset)
+{
+	unsigned long i, j;
+
+	for (i = offset; i < (size / BITS_PER_LONG); i++)
+		if (addr[i] != ~0UL)
+			break;
+
+	if (i == size)
+		return size;
+
+	for (j = 0; j < BITS_PER_LONG; j++)
+		if ((~addr[i]) & (1UL << j))
+			break;
+
+	return (i * BITS_PER_LONG) + j;
+}
+
+unsigned int irq_find_mapping(struct irq_domain *, irq_hw_number_t hwirq)
+{
+	/* only irqsteer irqs (< 32) are expected */
+
+	if (hwirq > 31) {
+		Genode::error(__func__, "(): unexpected hwirq ", hwirq);
+		Genode::sleep_forever();
+	}
+
+	return hwirq;
+}
+
+void drm_printk(const char *level, unsigned int category, const char *format,
+                ...)
+{
+	struct va_format vaf;
+	va_list args;
+
+	if (category && !(drm_debug & category))
+		return;
+
+	va_start(args, format);
+	vaf.fmt = format;
+	vaf.va = &args;
+
+	printk("%s" "[drm:%ps]%s %pV\n",
+	       level, __builtin_return_address(0),
+	       strcmp(level, KERN_ERR) == 0 ? " *ERROR*" : "", &vaf);
+	(void)vaf;
+
+	va_end(args);
+}
+
+int vsnprintf(char *str, size_t size, const char *format, va_list args)
+{
+	Genode::String_console sc(str, size);
+	sc.vprintf(format, args);
+
+	return sc.len();
+}
+
+char *kvasprintf(gfp_t gfp, const char *fmt, va_list ap)
+{
+	size_t const bad_guess = strlen(fmt) + 10;
+	char * const p = (char *)kmalloc(bad_guess, gfp);
+	if (!p)
+		return NULL;
+
+	vsnprintf(p, bad_guess, fmt, ap);
+
+	return p;
+}
+
+static void _completion_timeout(struct timer_list *list)
+{
+	struct process_timer *timeout = from_timer(timeout, list, timer);
+	timeout->task.unblock();
+}
+
+long __wait_completion(struct completion *work, unsigned long timeout)
+{
+	Lx::timer_update_jiffies();
+	unsigned long j = timeout ? jiffies + timeout : 0;
+
+	Lx::Task & cur_task = *Lx::scheduler().current();
+	struct process_timer timer { cur_task };
+
+	if (timeout) {
+		timer_setup(&timer.timer, _completion_timeout, 0);
+		mod_timer(&timer.timer, j);
+	}
+
+	while (!work->done) {
+
+		if (j && j <= jiffies) {
+			lx_log(1, "timeout jiffies %lu", jiffies);
+			return 0;
+		}
+
+		Lx::Task *task = Lx::scheduler().current();
+		work->task = (void *)task;
+		task->block_and_schedule();
+	}
+
+	if (timeout)
+		del_timer(&timer.timer);
+
+	return (j  || j == jiffies) ? 1 : j - jiffies;
+}
+
+} /* extern "C" */
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/lx_emul_c.c b/repos/dde_linux/src/drivers/framebuffer/imx8/lx_emul_c.c
new file mode 100644
index 000000000..0ec36f6dd
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/lx_emul_c.c
@@ -0,0 +1,169 @@
+/*
+ * \brief  Linux emulation C helper functions
+ * \author Stefan Kalkowski
+ * \author Christian Prochaska
+ * \date   2016-03-22
+ */
+
+/*
+ * Copyright (C) 2016-2019 Genode Labs GmbH
+ *
+ * This file is distributed under the terms of the GNU General Public License
+ * version 2.
+ */
+
+
+/* Genode includes */
+#include <lx_emul.h>
+#include <lx_emul_c.h>
+
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_encoder.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_modeset_helper.h>
+#include <imx/imx-drm.h>
+
+void lx_c_allocate_framebuffer(struct drm_device * dev,
+                               struct lx_c_fb_config *c)
+{
+	/* from drm_fbdev_cma_create() */
+
+	struct drm_gem_cma_object *obj;
+
+	c->pitch = c->width * c->bpp;
+	c->size  = c->pitch * c->height;
+
+	obj = drm_gem_cma_create(dev, c->size);
+
+	if (obj == NULL)
+		return;
+
+	c->addr = obj->vaddr;
+
+	/* from drm_gem_fb_alloc() */
+
+	struct drm_framebuffer *fb = kzalloc(sizeof(*fb), GFP_KERNEL);
+
+	if (fb == NULL)
+		goto err;
+
+	struct drm_mode_fb_cmd2 mode_cmd = { 0 };
+
+	mode_cmd.width = c->width;
+	mode_cmd.height = c->height;
+	mode_cmd.pitches[0] = c->pitch;
+	mode_cmd.pixel_format = DRM_FORMAT_XRGB8888;
+
+	drm_helper_mode_fill_fb_struct(dev, fb, &mode_cmd);
+
+	fb->obj[0] = &obj->base;
+
+	static const struct drm_framebuffer_funcs drm_fb_cma_funcs = {
+		.destroy = drm_gem_fb_destroy,
+	};
+
+	if (drm_framebuffer_init(dev, fb, &drm_fb_cma_funcs) != 0) {
+		kfree(fb);
+		goto err;
+	}
+
+	c->lx_fb = fb;
+
+	memset_io(c->addr, 0, c->size);
+
+	return;
+
+err:
+	drm_gem_object_put_unlocked(&obj->base); /* as in drm_gem_cma_create() */
+	return;
+}
+
+
+void lx_c_set_mode(struct drm_device * dev, struct drm_connector * connector,
+                   struct drm_framebuffer *fb, struct drm_display_mode *mode)
+{
+	struct drm_crtc        * crtc    = NULL;
+	struct drm_encoder     * encoder = connector->encoder;
+
+	if (!encoder) {
+		struct drm_encoder *enc;
+		list_for_each_entry(enc, &dev->mode_config.encoder_list, head) {
+			unsigned i;
+			for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
+				if (connector->encoder_ids[i] == enc->base.id) break;
+
+			if (i == DRM_CONNECTOR_MAX_ENCODER) continue;
+
+			bool used = false;
+			struct drm_connector *c;
+			list_for_each_entry(c, &dev->mode_config.connector_list, head) {
+				if (c->encoder == enc) used = true;
+			}
+			if (used) continue;
+			encoder = enc;
+			break;
+		}
+	}
+
+	if (!encoder) {
+		lx_printf("Found no encoder for the connector %s\n", connector->name);
+		return;
+	}
+
+	unsigned used_crtc = 0;
+
+	crtc = encoder->crtc;
+	if (!crtc) {
+		unsigned i = 0;
+		struct drm_crtc *c;
+		list_for_each_entry(c, &dev->mode_config.crtc_list, head) {
+			if (!(encoder->possible_crtcs & (1 << i))) continue;
+			if (c->state->enable) {
+				used_crtc ++;
+				continue;
+			}
+			crtc = c;
+			break;
+		}
+	}
+
+	if (!crtc) {
+		if (mode)
+			lx_printf("Found no crtc for the connector %s used/max %u+1/%u\n",
+			          connector->name, used_crtc, dev->mode_config.num_crtc);
+		return;
+	}
+
+	DRM_DEBUG("%s%s for connector %s\n", mode ? "set mode " : "no mode",
+	          mode ? mode->name : "", connector->name);
+
+	struct drm_mode_set set;
+	set.crtc = crtc;
+	set.x = 0;
+	set.y = 0;
+	set.mode = mode;
+	set.connectors = &connector;
+	set.num_connectors = mode ? 1 : 0;
+	set.fb = mode ? fb : 0;
+
+	uint32_t const ref_cnt_before = drm_framebuffer_read_refcount(fb);
+	int ret = drm_atomic_helper_set_config(&set, dev->mode_config.acquire_ctx);
+	if (ret)
+		lx_printf("Error: set config failed ret=%d refcnt before=%u after=%u\n",
+		          ret, ref_cnt_before, drm_framebuffer_read_refcount(fb));
+}
+
+void lx_c_set_driver(struct drm_device * dev, void * driver)
+{
+	struct imx_drm_device *dev_priv = dev->dev_private;
+	ASSERT(!dev_priv->fbhelper);
+	dev_priv->fbhelper = (struct drm_fbdev_cma *) driver;
+}
+
+
+void* lx_c_get_driver(struct drm_device * dev)
+{
+	struct imx_drm_device *dev_priv = dev->dev_private;
+	return (void*) dev_priv->fbhelper;
+}
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/main.cc b/repos/dde_linux/src/drivers/framebuffer/imx8/main.cc
new file mode 100644
index 000000000..1d4b8b15a
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/main.cc
@@ -0,0 +1,264 @@
+/*
+ * \brief  i.MX8 framebuffer driver
+ * \author Norman Feske
+ * \author Stefan Kalkowski
+ * \author Christian Prochaska
+ * \date   2015-08-19
+ */
+
+/*
+ * Copyright (C) 2015-2019 Genode Labs GmbH
+ *
+ * This file is distributed under the terms of the GNU General Public License
+ * version 2.
+ */
+
+/* Genode includes */
+#include <base/log.h>
+#include <base/component.h>
+#include <base/heap.h>
+#include <base/attached_rom_dataspace.h>
+
+/* Server related local includes */
+#include <component.h>
+
+/* Linux emulation environment includes */
+#include <lx_emul.h>
+#include <lx_kit/env.h>
+#include <lx_kit/malloc.h>
+#include <lx_kit/scheduler.h>
+#include <lx_kit/timer.h>
+#include <lx_kit/irq.h>
+#include <lx_kit/work.h>
+
+/* Linux module functions */
+extern "C" void radix_tree_init(); /* called by start_kernel(void) normally */
+extern "C" void drm_connector_ida_init(); /* called by drm_core_init(void) normally */
+extern "C" int module_irq_imx_irqsteer_init();
+extern "C" int module_imx_drm_pdrv_init();
+extern "C" int module_dcss_driver_init();
+extern "C" int module_dcss_crtc_driver_init();
+extern "C" int module_imx_hdp_imx_platform_driver_init();
+
+
+static void run_linux(void * m);
+
+unsigned long jiffies;
+
+
+struct Main
+{
+	Genode::Env                   &env;
+	Genode::Entrypoint            &ep     { env.ep() };
+	Genode::Attached_rom_dataspace config { env, "config" };
+	Genode::Heap                   heap   { env.ram(), env.rm() };
+	Framebuffer::Root              root   { env, heap, config };
+
+
+	/* Linux task that handles the initialization */
+	Genode::Constructible<Lx::Task> linux;
+
+	Main(Genode::Env &env) : env(env)
+	{
+		Genode::log("--- i.MX8 framebuffer driver ---");
+
+		Lx_kit::construct_env(env);
+
+		LX_MUTEX_INIT(bridge_lock);
+		LX_MUTEX_INIT(core_lock);
+		LX_MUTEX_INIT(component_mutex);
+
+		/* init singleton Lx::Scheduler */
+		Lx::scheduler(&env);
+
+		Lx::malloc_init(env, heap);
+
+		/* init singleton Lx::Timer */
+		Lx::timer(&env, &ep, &heap, &jiffies);
+
+		/* init singleton Lx::Irq */
+		Lx::Irq::irq(&ep, &heap);
+
+		/* init singleton Lx::Work */
+		Lx::Work::work_queue(&heap);
+
+		linux.construct(run_linux, reinterpret_cast<void*>(this),
+		                "linux", Lx::Task::PRIORITY_0, Lx::scheduler());
+
+		/* give all task a first kick before returning */
+		Lx::scheduler().schedule();
+	}
+
+	void announce() { env.parent().announce(ep.manage(root)); }
+
+	Lx::Task &linux_task() { return *linux; }
+};
+
+
+struct Policy_agent
+{
+	Main &main;
+	Genode::Signal_handler<Policy_agent> handler;
+	bool _pending = false;
+
+	void handle()
+	{
+		_pending = true;
+		main.linux_task().unblock();
+		Lx::scheduler().schedule();
+	}
+
+	bool pending()
+	{
+		bool ret = _pending;
+		_pending = false;
+		return ret;
+	}
+
+	Policy_agent(Main &m)
+	: main(m), handler(main.ep, *this, &Policy_agent::handle) {}
+};
+
+
+static void run_linux(void * m)
+{
+	Main * main = reinterpret_cast<Main*>(m);
+
+	system_wq  = alloc_workqueue("system_wq", 0, 0);
+
+	radix_tree_init();
+	drm_connector_ida_init();
+
+	module_irq_imx_irqsteer_init();
+	module_dcss_driver_init();
+	module_imx_drm_pdrv_init();
+	module_dcss_crtc_driver_init();
+	module_imx_hdp_imx_platform_driver_init();
+
+
+	/**
+	 * This device is originally created with the name '32e2d000.irqsteer'
+	 * via 'of_platform_bus_create()'. Here it is called 'imx-irqsteer' to match
+	 * the driver name.
+	 */
+
+	struct platform_device *imx_irqsteer_pdev =
+		platform_device_alloc("imx-irqsteer", 0);
+	
+	static resource imx_irqsteer_resources[] = 	{
+		{ 0x32e2d000, 0x32e2dfff, "imx-irqsteer", IORESOURCE_MEM },
+		{         50,         50, "imx-irqsteer", IORESOURCE_IRQ },
+	};
+
+	imx_irqsteer_pdev->num_resources = 2;
+	imx_irqsteer_pdev->resource = imx_irqsteer_resources;
+
+	imx_irqsteer_pdev->dev.of_node             = (device_node*)kzalloc(sizeof(device_node), 0);
+	imx_irqsteer_pdev->dev.of_node->name       = "imx-irqsteer";
+	imx_irqsteer_pdev->dev.of_node->full_name  = "imx-irqsteer";
+
+	platform_device_register(imx_irqsteer_pdev);
+
+
+	/**
+	 * This device is originally created with the name '32e00000.dcss'
+	 * via 'of_platform_bus_create()'. Here it is called 'dcss-core' to match
+	 * the driver name.
+	 */
+
+	struct platform_device *dcss_pdev =
+		platform_device_alloc("dcss-core", 0);
+
+	static resource dcss_resources[] = 	{
+		{ 0x32e00000, 0x32efffff, "dcss",       IORESOURCE_MEM },
+		{          3,          3, "dpr_dc_ch0", IORESOURCE_IRQ },
+		{          4,          4, "dpr_dc_ch1", IORESOURCE_IRQ },
+		{          5,          5, "dpr_dc_ch2", IORESOURCE_IRQ },
+		{          6,          6, "ctx_ld",     IORESOURCE_IRQ },
+		{          8,          8, "ctxld_kick", IORESOURCE_IRQ },
+		{          9,          9, "dtg_prg1",   IORESOURCE_IRQ },
+		{         16,         16, "dtrc_ch1",   IORESOURCE_IRQ },
+		{         17,         17, "dtrc_ch2",   IORESOURCE_IRQ },
+	};
+
+	dcss_pdev->num_resources = 9;
+	dcss_pdev->resource = dcss_resources;
+
+	dcss_pdev->dev.of_node                    = (device_node*)kzalloc(sizeof(device_node), 0);
+	dcss_pdev->dev.of_node->name              = "dcss";
+	dcss_pdev->dev.of_node->full_name         = "dcss";
+	dcss_pdev->dev.of_node->properties        = (property*)kzalloc(sizeof(property), 0);
+	dcss_pdev->dev.of_node->properties->name  = "disp-dev";
+	dcss_pdev->dev.of_node->properties->value = (void*)"hdmi_disp";
+
+	platform_device_register(dcss_pdev);
+
+
+	/**
+	 * This device is originally created with the name '32c00000.hdmi'
+	 * via 'of_platform_bus_create()'. Here it is called 'i.mx8-hdp' to match
+	 * the driver name.
+	 */
+
+	struct platform_device *hdp_pdev =
+		platform_device_alloc("i.mx8-hdp", 0);
+
+	static resource hdp_resources[] = 	{
+		{ 0x32c00000, 0x32cfffff, "hdp_ctrl",  IORESOURCE_MEM },
+		{ 0x32e40000, 0x32e7ffff, "hdp_crs",   IORESOURCE_MEM },
+		{ 0x32e2f000, 0x32e2f00f, "hdp_reset", IORESOURCE_MEM },
+		{         48,         48, "plug_in",   IORESOURCE_IRQ },
+		{         57,         57, "plug_out",  IORESOURCE_IRQ },
+	};
+
+	hdp_pdev->num_resources = 5;
+	hdp_pdev->resource = hdp_resources;
+
+	hdp_pdev->dev.of_node                    = (device_node*)kzalloc(sizeof(device_node), 0);
+	hdp_pdev->dev.of_node->name              = "hdmi";
+	hdp_pdev->dev.of_node->full_name         = "hdmi";
+	hdp_pdev->dev.of_node->properties        = (property*)kzalloc(sizeof(property), 0);
+	hdp_pdev->dev.of_node->properties->name  = "compatible";
+	hdp_pdev->dev.of_node->properties->value = (void*)"fsl,imx8mq-hdmi";
+
+	platform_device_register(hdp_pdev);
+
+
+	/**
+	 * This device is originally created with the name 'display-subsystem'
+	 * via 'of_platform_bus_create()'. Here it is called 'imx-drm' to match
+	 * the driver name.
+	 */
+
+	struct platform_device *display_subsystem_pdev =
+		platform_device_alloc("imx-drm", 0);
+
+	static device_node display_subsystem_of_node = { "display-subsystem" };
+
+	display_subsystem_pdev->dev.of_node = &display_subsystem_of_node;
+
+	platform_device_register(display_subsystem_pdev);
+
+
+	main->root.session.driver().finish_initialization();
+	main->announce();
+
+	Policy_agent pa(*main);
+	main->root.session.driver().config_sigh(pa.handler);
+	main->config.sigh(pa.handler);
+
+	while (1) {
+		Lx::scheduler().current()->block_and_schedule();
+		while (pa.pending())
+			main->root.session.config_changed();
+	}
+}
+
+
+void Component::construct(Genode::Env &env)
+{
+	/* XXX execute constructors of global statics */
+	env.exec_static_constructors();
+
+	static Main m(env);
+}
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/platform.cc b/repos/dde_linux/src/drivers/framebuffer/imx8/platform.cc
new file mode 100644
index 000000000..e340212ba
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/platform.cc
@@ -0,0 +1,39 @@
+/*
+ * \brief  Platform driver relevant lx_kit backend functions
+ * \author Stefan Kalkowski
+ * \date   2017-11-01
+ *
+ * Taken from the USB driver.
+ */
+
+/*
+ * Copyright (C) 2017 Genode Labs GmbH
+ *
+ * This file is distributed under the terms of the GNU General Public License
+ * version 2.
+ */
+
+#include <base/ram_allocator.h>
+
+#include <lx_kit/backend_alloc.h>
+#include <lx_kit/env.h>
+
+
+/****************************
+ ** lx_kit/backend_alloc.h **
+ ****************************/
+
+void backend_alloc_init(Genode::Env&, Genode::Ram_allocator&,
+						Genode::Allocator&)
+{
+	/* intentionally left blank */
+}
+
+
+Genode::Ram_dataspace_capability
+Lx::backend_alloc(Genode::addr_t size, Genode::Cache_attribute cached) {
+	return Lx_kit::env().env().ram().alloc(size, cached); }
+
+
+void Lx::backend_free(Genode::Ram_dataspace_capability cap) {
+	return Lx_kit::env().env().ram().free(cap); }
diff --git a/repos/dde_linux/src/drivers/framebuffer/imx8/target.mk b/repos/dde_linux/src/drivers/framebuffer/imx8/target.mk
new file mode 100644
index 000000000..c4419b3de
--- /dev/null
+++ b/repos/dde_linux/src/drivers/framebuffer/imx8/target.mk
@@ -0,0 +1,23 @@
+REQUIRES = arm_v8a
+
+TARGET   = imx8_fb_drv
+LIBS     = base imx8_fb_include lx_kit_setjmp imx8_fb_drv
+SRC_CC   = main.cc platform.cc lx_emul.cc
+SRC_C    = dummies.c lx_emul_c.c
+
+# lx_kit
+SRC_CC  += printf.cc \
+           env.cc \
+           irq.cc \
+           malloc.cc \
+           scheduler.cc \
+           timer.cc \
+           work.cc
+
+INC_DIR += $(REP_DIR)/src/include
+
+vpath %.cc $(PRG_DIR)
+vpath %.cc $(REP_DIR)/src/lx_kit
+
+CC_CXX_WARN_STRICT =
+CC_OPT += -Wno-narrowing
diff --git a/repos/dde_linux/src/drivers/nic/fec/lx_emul.h b/repos/dde_linux/src/drivers/nic/fec/lx_emul.h
index e006905f9..0b3b85b30 100644
--- a/repos/dde_linux/src/drivers/nic/fec/lx_emul.h
+++ b/repos/dde_linux/src/drivers/nic/fec/lx_emul.h
@@ -154,8 +154,8 @@ LX_MUTEX_INIT_DECLARE(phy_fixup_lock);
 
 #include <lx_emul/bitops.h>
 #include <lx_emul/atomic.h>
-#include <lx_emul/work.h>
 #include <lx_emul/spinlock.h>
+#include <lx_emul/work.h>
 #include <lx_emul/errno.h>
 #include <lx_emul/string.h>
 #include <lx_emul/module.h>
diff --git a/repos/dde_linux/src/include/lx_emul/work.h b/repos/dde_linux/src/include/lx_emul/work.h
index eb2b3b63b..88b650b1e 100644
--- a/repos/dde_linux/src/include/lx_emul/work.h
+++ b/repos/dde_linux/src/include/lx_emul/work.h
@@ -20,6 +20,7 @@
  ***********************/
 
 enum {
+	WQ_UNBOUND       = 1 << 1,
 	WQ_FREEZABLE     = 1 << 2,
 	WQ_MEM_RECLAIM   = 1 << 3,
 	WQ_HIGHPRI       = 1 << 4,
@@ -147,7 +148,10 @@ enum {
 
 typedef struct wait_queue_entry wait_queue_entry_t;
 typedef int (*wait_queue_func_t)(wait_queue_entry_t *, unsigned, int, void *);
-typedef struct wait_queue_head { void *list; } wait_queue_head_t;
+typedef struct wait_queue_head {
+	spinlock_t  lock;
+	void       *list;
+} wait_queue_head_t;
 struct wait_queue_entry {
 	unsigned int		flags;
 	void			*private;
@@ -176,6 +180,7 @@ void __wake_up(wait_queue_head_t *q, bool all);
 
 #define wake_up(x)                   __wake_up(x, false)
 #define wake_up_all(x)               __wake_up(x, true)
+#define wake_up_all_locked(x)        __wake_up(x, true)
 #define wake_up_interruptible(x)     __wake_up(x, false)
 #define wake_up_interruptible_all(x) __wake_up(x, true)
 
@@ -202,6 +207,7 @@ void ___wait_event(wait_queue_head_t*);
 #define _wait_event(wq, condition) while (!(condition)) { __wait_event(wq); }
 #define wait_event(wq, condition) ({ _wait_event(wq, condition); })
 #define wait_event_interruptible(wq, condition) ({ _wait_event(wq, condition); 0; })
+#define wait_event_interruptible_locked(wq, condition) ({ _wait_event(wq, condition); 0; })
 
 #define _wait_event_timeout(wq, condition, timeout) \
 	({ int res = 1;                                 \
diff --git a/repos/dde_linux/src/lib/wifi/include/lx_emul.h b/repos/dde_linux/src/lib/wifi/include/lx_emul.h
index 8fd54cb31..86d5f4ad6 100644
--- a/repos/dde_linux/src/lib/wifi/include/lx_emul.h
+++ b/repos/dde_linux/src/lib/wifi/include/lx_emul.h
@@ -987,17 +987,8 @@ unsigned long int_sqrt(unsigned long);
  ** linux/workqueue.h **
  ***********************/
 
-struct workqueue_struct; /* XXX fix in lx_emul/work.h */
-
 #include <lx_emul/work.h>
 
-enum {
-	WQ_UNBOUND        = 1<<1,
-	// WQ_MEM_RECLAIM    = 1<<3,
-	// WQ_HIGHPRI        = 1<<4,
-	// WQ_CPU_INTENSIVE  = 1<<5,
-};
-
 extern struct workqueue_struct *system_power_efficient_wq;