diff --git a/drivers/video/imx/Kconfig b/drivers/video/imx/Kconfig
index c33620e..78eb0f2 100644
--- a/drivers/video/imx/Kconfig
+++ b/drivers/video/imx/Kconfig
@@ -1,7 +1,7 @@
 
 config VIDEO_IPUV3
 	bool "i.MX IPUv3 Core video support"
-	depends on (VIDEO || DM_VIDEO) && (MX5 || MX6)
+	depends on DM_VIDEO && (MX5 || MX6)
 	help
 	  This enables framebuffer driver for i.MX processors working
 	  on the IPUv3(Image Processing Unit) internal graphic processor.
diff --git a/drivers/video/imx/mxc_ipuv3_fb.c b/drivers/video/imx/mxc_ipuv3_fb.c
index 6787201..587d62f 100644
--- a/drivers/video/imx/mxc_ipuv3_fb.c
+++ b/drivers/video/imx/mxc_ipuv3_fb.c
@@ -38,10 +38,6 @@
 static int mxcfb_map_video_memory(struct fb_info *fbi);
 static int mxcfb_unmap_video_memory(struct fb_info *fbi);
 
-#if !CONFIG_IS_ENABLED(DM_VIDEO)
-/* graphics setup */
-static GraphicDevice panel;
-#endif
 static struct fb_videomode const *gmode;
 static uint8_t gdisp;
 static uint32_t gpixfmt;
@@ -391,12 +387,7 @@
 	}
 	fbi->fix.smem_len = roundup(fbi->fix.smem_len, ARCH_DMA_MINALIGN);
 
-#if CONFIG_IS_ENABLED(DM_VIDEO)
 	fbi->screen_base = (char *)gd->video_bottom;
-#else
-	fbi->screen_base = (char *)memalign(ARCH_DMA_MINALIGN,
-					    fbi->fix.smem_len);
-#endif
 
 	fbi->fix.smem_start = (unsigned long)fbi->screen_base;
 	if (fbi->screen_base == 0) {
@@ -410,10 +401,7 @@
 		(uint32_t) fbi->fix.smem_start, fbi->fix.smem_len);
 
 	fbi->screen_size = fbi->fix.smem_len;
-
-#if CONFIG_IS_ENABLED(VIDEO)
 	gd->fb_base = fbi->fix.smem_start;
-#endif
 
 	/* Clear the screen */
 	memset((char *)fbi->screen_base, 0, fbi->fix.smem_len);
@@ -544,18 +532,6 @@
 
 	mxcfb_set_par(fbi);
 
-#if !CONFIG_IS_ENABLED(DM_VIDEO)
-	panel.winSizeX = mode->xres;
-	panel.winSizeY = mode->yres;
-	panel.plnSizeX = mode->xres;
-	panel.plnSizeY = mode->yres;
-
-	panel.frameAdrs = (u32)fbi->screen_base;
-	panel.memSize = fbi->screen_size;
-
-	panel.gdfBytesPP = 2;
-	panel.gdfIndex = GDF_16BIT_565RGB;
-#endif
 #ifdef DEBUG
 	ipu_dump_registers();
 #endif
@@ -584,23 +560,6 @@
 			     &stat->int_stat[i]);
 	}
 }
-
-#if !CONFIG_IS_ENABLED(DM_VIDEO)
-void *video_hw_init(void)
-{
-	int ret;
-
-	ret = ipu_probe();
-	if (ret)
-		puts("Error initializing IPU\n");
-
-	ret = mxcfb_probe(gpixfmt, gdisp, gmode);
-	debug("Framebuffer at 0x%x\n", (unsigned int)panel.frameAdrs);
-	gd->fb_base = panel.frameAdrs;
-
-	return (void *)&panel;
-}
-#endif
 
 int ipuv3_fb_init(struct fb_videomode const *mode,
 		  uint8_t disp,
@@ -613,7 +572,6 @@
 	return 0;
 }
 
-#if CONFIG_IS_ENABLED(DM_VIDEO)
 enum {
 	/* Maximum display size we support */
 	LCD_MAX_WIDTH		= 1920,
@@ -711,4 +669,3 @@
 	.priv_auto_alloc_size = sizeof(struct ipuv3_video_priv),
 	.flags	= DM_FLAG_PRE_RELOC,
 };
-#endif /* CONFIG_DM_VIDEO */
