From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <SRS0=oHH8=SG=vger.kernel.org=linux-kernel-owner@kernel.org>
X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on
	aws-us-west-2-korg-lkml-1.web.codeaurora.org
X-Spam-Level: 
X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,
	INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED
	autolearn=ham autolearn_force=no version=3.4.0
Received: from mail.kernel.org (mail.kernel.org [198.145.29.99])
	by smtp.lore.kernel.org (Postfix) with ESMTP id DB949C4360F
	for <linux-kernel@archiver.kernel.org>; Thu,  4 Apr 2019 15:24:55 +0000 (UTC)
Received: from vger.kernel.org (vger.kernel.org [209.132.180.67])
	by mail.kernel.org (Postfix) with ESMTP id 73C0C20855
	for <linux-kernel@archiver.kernel.org>; Thu,  4 Apr 2019 15:24:55 +0000 (UTC)
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
        id S1729456AbfDDPYy (ORCPT
        <rfc822;linux-kernel@archiver.kernel.org>);
        Thu, 4 Apr 2019 11:24:54 -0400
Received: from mx1.redhat.com ([209.132.183.28]:44182 "EHLO mx1.redhat.com"
        rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP
        id S1729151AbfDDPYh (ORCPT <rfc822;linux-kernel@vger.kernel.org>);
        Thu, 4 Apr 2019 11:24:37 -0400
Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16])
        (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits))
        (No client certificate requested)
        by mx1.redhat.com (Postfix) with ESMTPS id CDEA23089FE9;
        Thu,  4 Apr 2019 15:24:35 +0000 (UTC)
Received: from sirius.home.kraxel.org (ovpn-116-22.ams2.redhat.com [10.36.116.22])
        by smtp.corp.redhat.com (Postfix) with ESMTP id 8DA768635E;
        Thu,  4 Apr 2019 15:24:33 +0000 (UTC)
Received: by sirius.home.kraxel.org (Postfix, from userid 1000)
        id 68F66A1E3; Thu,  4 Apr 2019 17:24:31 +0200 (CEST)
From:   Gerd Hoffmann <kraxel@redhat.com>
To:     dri-devel@lists.freedesktop.org
Cc:     Gerd Hoffmann <kraxel@redhat.com>,
        Dave Airlie <airlied@redhat.com>,
        David Airlie <airlied@linux.ie>,
        Daniel Vetter <daniel@ffwll.ch>,
        linux-kernel@vger.kernel.org (open list),
        virtualization@lists.linux-foundation.org (open list:DRM DRIVER FOR
        QEMU'S CIRRUS DEVICE)
Subject: [PATCH v2 6/6] drm/cirrus: rewrite and modernize driver.
Date:   Thu,  4 Apr 2019 17:24:30 +0200
Message-Id: <20190404152430.8263-7-kraxel@redhat.com>
In-Reply-To: <20190404152430.8263-1-kraxel@redhat.com>
References: <20190404152430.8263-1-kraxel@redhat.com>
X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16
X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.42]); Thu, 04 Apr 2019 15:24:35 +0000 (UTC)
Sender: linux-kernel-owner@vger.kernel.org
Precedence: bulk
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

Time to kill some bad sample code people are copying from ;)

This is a complete rewrite of the cirrus driver.  The cirrus_mode_set()
function is pretty much the only function which is carried over largely
unmodified.  Everything else is upside down.

It is a single monster patch.  But given that it does some pretty
fundamental changes to the drivers workflow and also reduces the code
size by roughly 70% I think it'll still be alot easier to review than a
longish baby-step patch series.

Changes summary:
 - Given the small amout of video memory (4 MB) the cirrus device has
   the rewritten driver doesn't try to manage buffers there.  Instead
   it will blit (memcpy) the active framebuffer to video memory.
 - All gem objects are stored in main memory and are manged using the
   new shmem helpers.  ttm is out.
 - It supports RG16, RG24 and XR24 formats.  XR24 gets converted to RG24
   or RG16 at blit time if needed, to avoid the pitch becoming larger
   than what the cirrus hardware can handle.
 - The simple display pipeline is used.
 - The generic fbdev emulation is used.
 - It's a atomic driver now.
 - It runs wayland.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 drivers/gpu/drm/cirrus/cirrus_drv.h   | 251 -----------
 drivers/gpu/drm/cirrus/cirrus.c       | 621 ++++++++++++++++++++++++++
 drivers/gpu/drm/cirrus/cirrus_drv.c   | 161 -------
 drivers/gpu/drm/cirrus/cirrus_fbdev.c | 309 -------------
 drivers/gpu/drm/cirrus/cirrus_main.c  | 328 --------------
 drivers/gpu/drm/cirrus/cirrus_mode.c  | 617 -------------------------
 drivers/gpu/drm/cirrus/cirrus_ttm.c   | 343 --------------
 drivers/gpu/drm/cirrus/Kconfig        |   2 +-
 drivers/gpu/drm/cirrus/Makefile       |   3 -
 9 files changed, 622 insertions(+), 2013 deletions(-)
 delete mode 100644 drivers/gpu/drm/cirrus/cirrus_drv.h
 create mode 100644 drivers/gpu/drm/cirrus/cirrus.c
 delete mode 100644 drivers/gpu/drm/cirrus/cirrus_drv.c
 delete mode 100644 drivers/gpu/drm/cirrus/cirrus_fbdev.c
 delete mode 100644 drivers/gpu/drm/cirrus/cirrus_main.c
 delete mode 100644 drivers/gpu/drm/cirrus/cirrus_mode.c
 delete mode 100644 drivers/gpu/drm/cirrus/cirrus_ttm.c

diff --git a/drivers/gpu/drm/cirrus/cirrus_drv.h b/drivers/gpu/drm/cirrus/cirrus_drv.h
deleted file mode 100644
index 828b150cdb20..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_drv.h
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * Copyright 2012 Red Hat
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License version 2. See the file COPYING in the main
- * directory of this archive for more details.
- *
- * Authors: Matthew Garrett
- *          Dave Airlie
- */
-#ifndef __CIRRUS_DRV_H__
-#define __CIRRUS_DRV_H__
-
-#include <video/vga.h>
-
-#include <drm/drm_encoder.h>
-#include <drm/drm_fb_helper.h>
-
-#include <drm/ttm/ttm_bo_api.h>
-#include <drm/ttm/ttm_bo_driver.h>
-#include <drm/ttm/ttm_placement.h>
-#include <drm/ttm/ttm_memory.h>
-#include <drm/ttm/ttm_module.h>
-
-#include <drm/drm_gem.h>
-
-#define DRIVER_AUTHOR		"Matthew Garrett"
-
-#define DRIVER_NAME		"cirrus"
-#define DRIVER_DESC		"qemu Cirrus emulation"
-#define DRIVER_DATE		"20110418"
-
-#define DRIVER_MAJOR		1
-#define DRIVER_MINOR		0
-#define DRIVER_PATCHLEVEL	0
-
-#define CIRRUSFB_CONN_LIMIT 1
-
-#define RREG8(reg) ioread8(((void __iomem *)cdev->rmmio) + (reg))
-#define WREG8(reg, v) iowrite8(v, ((void __iomem *)cdev->rmmio) + (reg))
-#define RREG32(reg) ioread32(((void __iomem *)cdev->rmmio) + (reg))
-#define WREG32(reg, v) iowrite32(v, ((void __iomem *)cdev->rmmio) + (reg))
-
-#define SEQ_INDEX 4
-#define SEQ_DATA 5
-
-#define WREG_SEQ(reg, v)					\
-	do {							\
-		WREG8(SEQ_INDEX, reg);				\
-		WREG8(SEQ_DATA, v);				\
-	} while (0)						\
-
-#define CRT_INDEX 0x14
-#define CRT_DATA 0x15
-
-#define WREG_CRT(reg, v)					\
-	do {							\
-		WREG8(CRT_INDEX, reg);				\
-		WREG8(CRT_DATA, v);				\
-	} while (0)						\
-
-#define GFX_INDEX 0xe
-#define GFX_DATA 0xf
-
-#define WREG_GFX(reg, v)					\
-	do {							\
-		WREG8(GFX_INDEX, reg);				\
-		WREG8(GFX_DATA, v);				\
-	} while (0)						\
-
-/*
- * Cirrus has a "hidden" DAC register that can be accessed by writing to
- * the pixel mask register to reset the state, then reading from the register
- * four times. The next write will then pass to the DAC
- */
-#define VGA_DAC_MASK 0x6
-
-#define WREG_HDR(v)						\
-	do {							\
-		RREG8(VGA_DAC_MASK);					\
-		RREG8(VGA_DAC_MASK);					\
-		RREG8(VGA_DAC_MASK);					\
-		RREG8(VGA_DAC_MASK);					\
-		WREG8(VGA_DAC_MASK, v);					\
-	} while (0)						\
-
-
-#define CIRRUS_MAX_FB_HEIGHT 4096
-#define CIRRUS_MAX_FB_WIDTH 4096
-
-#define CIRRUS_DPMS_CLEARED (-1)
-
-#define to_cirrus_crtc(x) container_of(x, struct cirrus_crtc, base)
-#define to_cirrus_encoder(x) container_of(x, struct cirrus_encoder, base)
-
-struct cirrus_crtc {
-	struct drm_crtc			base;
-	int				last_dpms;
-	bool				enabled;
-};
-
-struct cirrus_fbdev;
-struct cirrus_mode_info {
-	struct cirrus_crtc		*crtc;
-	/* pointer to fbdev info structure */
-	struct cirrus_fbdev		*gfbdev;
-};
-
-struct cirrus_encoder {
-	struct drm_encoder		base;
-	int				last_dpms;
-};
-
-struct cirrus_connector {
-	struct drm_connector		base;
-};
-
-struct cirrus_mc {
-	resource_size_t			vram_size;
-	resource_size_t			vram_base;
-};
-
-struct cirrus_device {
-	struct drm_device		*dev;
-	unsigned long			flags;
-
-	resource_size_t			rmmio_base;
-	resource_size_t			rmmio_size;
-	void __iomem			*rmmio;
-
-	struct cirrus_mc			mc;
-	struct cirrus_mode_info		mode_info;
-
-	int				num_crtc;
-	int fb_mtrr;
-
-	struct {
-		struct ttm_bo_device bdev;
-	} ttm;
-	bool mm_inited;
-};
-
-
-struct cirrus_fbdev {
-	struct drm_fb_helper helper; /* must be first */
-	struct drm_framebuffer *gfb;
-	void *sysram;
-	int size;
-	int x1, y1, x2, y2; /* dirty rect */
-	spinlock_t dirty_lock;
-};
-
-struct cirrus_bo {
-	struct ttm_buffer_object bo;
-	struct ttm_placement placement;
-	struct ttm_bo_kmap_obj kmap;
-	struct drm_gem_object gem;
-	struct ttm_place placements[3];
-	int pin_count;
-};
-#define gem_to_cirrus_bo(gobj) container_of((gobj), struct cirrus_bo, gem)
-
-static inline struct cirrus_bo *
-cirrus_bo(struct ttm_buffer_object *bo)
-{
-	return container_of(bo, struct cirrus_bo, bo);
-}
-
-
-#define to_cirrus_obj(x) container_of(x, struct cirrus_gem_object, base)
-#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT)
-
-				/* cirrus_main.c */
-int cirrus_device_init(struct cirrus_device *cdev,
-		      struct drm_device *ddev,
-		      struct pci_dev *pdev,
-		      uint32_t flags);
-void cirrus_device_fini(struct cirrus_device *cdev);
-void cirrus_gem_free_object(struct drm_gem_object *obj);
-int cirrus_dumb_mmap_offset(struct drm_file *file,
-			    struct drm_device *dev,
-			    uint32_t handle,
-			    uint64_t *offset);
-int cirrus_gem_create(struct drm_device *dev,
-		   u32 size, bool iskernel,
-		      struct drm_gem_object **obj);
-int cirrus_dumb_create(struct drm_file *file,
-		    struct drm_device *dev,
-		       struct drm_mode_create_dumb *args);
-
-int cirrus_framebuffer_init(struct drm_device *dev,
-			    struct drm_framebuffer *gfb,
-			    const struct drm_mode_fb_cmd2 *mode_cmd,
-			    struct drm_gem_object *obj);
-
-bool cirrus_check_framebuffer(struct cirrus_device *cdev, int width, int height,
-			      int bpp, int pitch);
-
-				/* cirrus_display.c */
-int cirrus_modeset_init(struct cirrus_device *cdev);
-void cirrus_modeset_fini(struct cirrus_device *cdev);
-
-				/* cirrus_fbdev.c */
-int cirrus_fbdev_init(struct cirrus_device *cdev);
-void cirrus_fbdev_fini(struct cirrus_device *cdev);
-
-
-
-				/* cirrus_irq.c */
-void cirrus_driver_irq_preinstall(struct drm_device *dev);
-int cirrus_driver_irq_postinstall(struct drm_device *dev);
-void cirrus_driver_irq_uninstall(struct drm_device *dev);
-irqreturn_t cirrus_driver_irq_handler(int irq, void *arg);
-
-				/* cirrus_kms.c */
-int cirrus_driver_load(struct drm_device *dev, unsigned long flags);
-void cirrus_driver_unload(struct drm_device *dev);
-extern struct drm_ioctl_desc cirrus_ioctls[];
-extern int cirrus_max_ioctl;
-
-int cirrus_mm_init(struct cirrus_device *cirrus);
-void cirrus_mm_fini(struct cirrus_device *cirrus);
-void cirrus_ttm_placement(struct cirrus_bo *bo, int domain);
-int cirrus_bo_create(struct drm_device *dev, int size, int align,
-		     uint32_t flags, struct cirrus_bo **pcirrusbo);
-int cirrus_mmap(struct file *filp, struct vm_area_struct *vma);
-
-static inline int cirrus_bo_reserve(struct cirrus_bo *bo, bool no_wait)
-{
-	int ret;
-
-	ret = ttm_bo_reserve(&bo->bo, true, no_wait, NULL);
-	if (ret) {
-		if (ret != -ERESTARTSYS && ret != -EBUSY)
-			DRM_ERROR("reserve failed %p\n", bo);
-		return ret;
-	}
-	return 0;
-}
-
-static inline void cirrus_bo_unreserve(struct cirrus_bo *bo)
-{
-	ttm_bo_unreserve(&bo->bo);
-}
-
-int cirrus_bo_push_sysram(struct cirrus_bo *bo);
-int cirrus_bo_pin(struct cirrus_bo *bo, u32 pl_flag, u64 *gpu_addr);
-
-extern int cirrus_bpp;
-
-#endif				/* __CIRRUS_DRV_H__ */
diff --git a/drivers/gpu/drm/cirrus/cirrus.c b/drivers/gpu/drm/cirrus/cirrus.c
new file mode 100644
index 000000000000..5060e3d854d3
--- /dev/null
+++ b/drivers/gpu/drm/cirrus/cirrus.c
@@ -0,0 +1,621 @@
+/*
+ * Copyright 2012-2019 Red Hat
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License version 2. See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * Authors: Matthew Garrett
+ *	    Dave Airlie
+ *	    Gerd Hoffmann
+ *
+ * Portions of this code derived from cirrusfb.c:
+ * drivers/video/cirrusfb.c - driver for Cirrus Logic chipsets
+ *
+ * Copyright 1999-2001 Jeff Garzik <jgarzik@pobox.com>
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/console.h>
+
+#include <video/vga.h>
+#include <video/cirrus.h>
+
+#include <drm/drm_drv.h>
+#include <drm/drm_file.h>
+#include <drm/drm_ioctl.h>
+#include <drm/drm_vblank.h>
+#include <drm/drm_connector.h>
+
+#include <drm/drm_fourcc.h>
+#include <drm/drm_fb_helper.h>
+#include <drm/drm_probe_helper.h>
+#include <drm/drm_simple_kms_helper.h>
+#include <drm/drm_gem_shmem_helper.h>
+#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_modeset_helper_vtables.h>
+#include <drm/drm_damage_helper.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_atomic_state_helper.h>
+
+#define DRIVER_NAME "cirrus"
+#define DRIVER_DESC "qemu cirrus vga"
+#define DRIVER_DATE "2019"
+#define DRIVER_MAJOR 2
+#define DRIVER_MINOR 0
+
+#define CIRRUS_MAX_PITCH (0x1FF << 3)      /* (4096 - 1) & ~111b bytes */
+#define CIRRUS_VRAM_SIZE (4 * 1024 * 1024) /* 4 MB */
+
+struct cirrus_device {
+	struct drm_device	       dev;
+	struct drm_simple_display_pipe pipe;
+	struct drm_connector	       conn;
+	unsigned int		       cpp;
+	unsigned int		       pitch;
+	void __iomem		       *vram;
+	void __iomem		       *mmio;
+};
+
+/* ------------------------------------------------------------------ */
+/*
+ * The meat of this driver. The core passes us a mode and we have to program
+ * it. The modesetting here is the bare minimum required to satisfy the qemu
+ * emulation of this hardware, and running this against a real device is
+ * likely to result in an inadequately programmed mode. We've already had
+ * the opportunity to modify the mode, so whatever we receive here should
+ * be something that can be correctly programmed and displayed
+ */
+
+#define RREG8(reg) ioread8(((void __iomem *)cirrus->mmio) + (reg))
+#define WREG8(reg, v) iowrite8(v, ((void __iomem *)cirrus->mmio) + (reg))
+#define RREG32(reg) ioread32(((void __iomem *)cirrus->mmio) + (reg))
+#define WREG32(reg, v) iowrite32(v, ((void __iomem *)cirrus->mmio) + (reg))
+
+#define SEQ_INDEX 4
+#define SEQ_DATA 5
+
+#define WREG_SEQ(reg, v)					\
+	do {							\
+		WREG8(SEQ_INDEX, reg);				\
+		WREG8(SEQ_DATA, v);				\
+	} while (0)						\
+
+#define CRT_INDEX 0x14
+#define CRT_DATA 0x15
+
+#define WREG_CRT(reg, v)					\
+	do {							\
+		WREG8(CRT_INDEX, reg);				\
+		WREG8(CRT_DATA, v);				\
+	} while (0)						\
+
+#define GFX_INDEX 0xe
+#define GFX_DATA 0xf
+
+#define WREG_GFX(reg, v)					\
+	do {							\
+		WREG8(GFX_INDEX, reg);				\
+		WREG8(GFX_DATA, v);				\
+	} while (0)						\
+
+#define VGA_DAC_MASK 0x6
+
+#define WREG_HDR(v)						\
+	do {							\
+		RREG8(VGA_DAC_MASK);				\
+		RREG8(VGA_DAC_MASK);				\
+		RREG8(VGA_DAC_MASK);				\
+		RREG8(VGA_DAC_MASK);				\
+		WREG8(VGA_DAC_MASK, v);				\
+	} while (0)						\
+
+
+static int cirrus_convert_to(struct drm_framebuffer *fb)
+{
+	if (fb->format->cpp[0] == 4 && fb->pitches[0] > CIRRUS_MAX_PITCH) {
+		if (fb->width * 3 <= CIRRUS_MAX_PITCH)
+			/* convert from XR24 to RG24 */
+			return 3;
+		else
+			/* convert from XR24 to RG16 */
+			return 2;
+	}
+	return 0;
+}
+
+static int cirrus_cpp(struct drm_framebuffer *fb)
+{
+	int convert_cpp = cirrus_convert_to(fb);
+
+	if (convert_cpp)
+		return convert_cpp;
+	return fb->format->cpp[0];
+}
+
+static int cirrus_pitch(struct drm_framebuffer *fb)
+{
+	int convert_cpp = cirrus_convert_to(fb);
+
+	if (convert_cpp)
+		return convert_cpp * fb->width;
+	return fb->pitches[0];
+}
+
+static int cirrus_mode_set(struct cirrus_device *cirrus,
+			   struct drm_display_mode *mode,
+			   struct drm_framebuffer *fb)
+{
+	int hsyncstart, hsyncend, htotal, hdispend;
+	int vtotal, vdispend;
+	int tmp;
+	int sr07 = 0, hdr = 0;
+
+	htotal = mode->htotal / 8;
+	hsyncend = mode->hsync_end / 8;
+	hsyncstart = mode->hsync_start / 8;
+	hdispend = mode->hdisplay / 8;
+
+	vtotal = mode->vtotal;
+	vdispend = mode->vdisplay;
+
+	vdispend -= 1;
+	vtotal -= 2;
+
+	htotal -= 5;
+	hdispend -= 1;
+	hsyncstart += 1;
+	hsyncend += 1;
+
+	WREG_CRT(VGA_CRTC_V_SYNC_END, 0x20);
+	WREG_CRT(VGA_CRTC_H_TOTAL, htotal);
+	WREG_CRT(VGA_CRTC_H_DISP, hdispend);
+	WREG_CRT(VGA_CRTC_H_SYNC_START, hsyncstart);
+	WREG_CRT(VGA_CRTC_H_SYNC_END, hsyncend);
+	WREG_CRT(VGA_CRTC_V_TOTAL, vtotal & 0xff);
+	WREG_CRT(VGA_CRTC_V_DISP_END, vdispend & 0xff);
+
+	tmp = 0x40;
+	if ((vdispend + 1) & 512)
+		tmp |= 0x20;
+	WREG_CRT(VGA_CRTC_MAX_SCAN, tmp);
+
+	/*
+	 * Overflow bits for values that don't fit in the standard registers
+	 */
+	tmp = 16;
+	if (vtotal & 256)
+		tmp |= 1;
+	if (vdispend & 256)
+		tmp |= 2;
+	if ((vdispend + 1) & 256)
+		tmp |= 8;
+	if (vtotal & 512)
+		tmp |= 32;
+	if (vdispend & 512)
+		tmp |= 64;
+	WREG_CRT(VGA_CRTC_OVERFLOW, tmp);
+
+	tmp = 0;
+
+	/* More overflow bits */
+
+	if ((htotal + 5) & 64)
+		tmp |= 16;
+	if ((htotal + 5) & 128)
+		tmp |= 32;
+	if (vtotal & 256)
+		tmp |= 64;
+	if (vtotal & 512)
+		tmp |= 128;
+
+	WREG_CRT(CL_CRT1A, tmp);
+
+	/* Disable Hercules/CGA compatibility */
+	WREG_CRT(VGA_CRTC_MODE, 0x03);
+
+	WREG8(SEQ_INDEX, 0x7);
+	sr07 = RREG8(SEQ_DATA);
+	sr07 &= 0xe0;
+	hdr = 0;
+
+	cirrus->cpp = cirrus_cpp(fb);
+	switch (cirrus->cpp * 8) {
+	case 8:
+		sr07 |= 0x11;
+		break;
+	case 16:
+		sr07 |= 0x17;
+		hdr = 0xc1;
+		break;
+	case 24:
+		sr07 |= 0x15;
+		hdr = 0xc5;
+		break;
+	case 32:
+		sr07 |= 0x19;
+		hdr = 0xc5;
+		break;
+	default:
+		return -1;
+	}
+
+	WREG_SEQ(0x7, sr07);
+
+	/* Program the pitch */
+	cirrus->pitch = cirrus_pitch(fb);
+	tmp = cirrus->pitch / 8;
+	WREG_CRT(VGA_CRTC_OFFSET, tmp);
+
+	/* Enable extended blanking and pitch bits, and enable full memory */
+	tmp = 0x22;
+	tmp |= (cirrus->pitch >> 7) & 0x10;
+	tmp |= (cirrus->pitch >> 6) & 0x40;
+	WREG_CRT(0x1b, tmp);
+
+	/* Enable high-colour modes */
+	WREG_GFX(VGA_GFX_MODE, 0x40);
+
+	/* And set graphics mode */
+	WREG_GFX(VGA_GFX_MISC, 0x01);
+
+	WREG_HDR(hdr);
+	/* cirrus_crtc_do_set_base(crtc, old_fb, x, y, 0); */
+
+	/* Unblank (needed on S3 resume, vgabios doesn't do it then) */
+	outb(0x20, 0x3c0);
+	return 0;
+}
+
+static int cirrus_fb_blit_rect(struct drm_framebuffer *fb,
+			       struct drm_rect *rect)
+{
+	struct cirrus_device *cirrus = fb->dev->dev_private;
+	void *vmap;
+
+	vmap = drm_gem_shmem_vmap(fb->obj[0]);
+	if (!vmap)
+		return -ENOMEM;
+
+	if (cirrus->cpp == fb->format->cpp[0])
+		drm_fb_memcpy(__io_virt(cirrus->vram),
+			      vmap, fb, rect, true);
+
+	else if (fb->format->cpp[0] == 4 && cirrus->cpp == 2)
+		drm_fb_xrgb8888_to_rgb565(__io_virt(cirrus->vram),
+					  vmap, fb, rect, false, true);
+
+	else if (fb->format->cpp[0] == 4 && cirrus->cpp == 3)
+		drm_fb_xrgb8888_to_rgb888(__io_virt(cirrus->vram),
+					  vmap, fb, rect, true);
+
+	else
+		WARN_ON_ONCE("cpp mismatch");
+
+	drm_gem_shmem_vunmap(fb->obj[0], vmap);
+	return 0;
+}
+
+static int cirrus_fb_blit_fullscreen(struct drm_framebuffer *fb)
+{
+	struct drm_rect fullscreen = {
+		.x1 = 0,
+		.x2 = fb->width,
+		.y1 = 0,
+		.y2 = fb->height,
+	};
+	return cirrus_fb_blit_rect(fb, &fullscreen);
+}
+
+static int cirrus_check_size(int width, int height,
+			     struct drm_framebuffer *fb)
+{
+	int pitch = width * 2;
+
+	if (fb)
+		pitch = cirrus_pitch(fb);
+
+	if (pitch > CIRRUS_MAX_PITCH)
+		return -EINVAL;
+	if (pitch * height > CIRRUS_VRAM_SIZE)
+		return -EINVAL;
+	return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/* cirrus connector						      */
+
+static int cirrus_conn_get_modes(struct drm_connector *conn)
+{
+	int count;
+
+	count = drm_add_modes_noedid(conn,
+				     conn->dev->mode_config.max_width,
+				     conn->dev->mode_config.max_height);
+	drm_set_preferred_mode(conn, 1024, 768);
+	return count;
+}
+
+static const struct drm_connector_helper_funcs cirrus_conn_helper_funcs = {
+	.get_modes = cirrus_conn_get_modes,
+};
+
+static const struct drm_connector_funcs cirrus_conn_funcs = {
+	.fill_modes = drm_helper_probe_single_connector_modes,
+	.destroy = drm_connector_cleanup,
+	.reset = drm_atomic_helper_connector_reset,
+	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
+	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+};
+
+static int cirrus_conn_init(struct cirrus_device *cirrus)
+{
+	drm_connector_helper_add(&cirrus->conn, &cirrus_conn_helper_funcs);
+	return drm_connector_init(&cirrus->dev, &cirrus->conn,
+				  &cirrus_conn_funcs, DRM_MODE_CONNECTOR_VGA);
+
+}
+
+/* ------------------------------------------------------------------ */
+/* cirrus (simple) display pipe					      */
+
+static enum drm_mode_status cirrus_pipe_mode_valid(struct drm_crtc *crtc,
+						   const struct drm_display_mode *mode)
+{
+	if (cirrus_check_size(mode->hdisplay, mode->vdisplay, NULL) < 0)
+		return MODE_BAD;
+	return MODE_OK;
+}
+
+static int cirrus_pipe_check(struct drm_simple_display_pipe *pipe,
+			     struct drm_plane_state *plane_state,
+			     struct drm_crtc_state *crtc_state)
+{
+	struct drm_framebuffer *fb = plane_state->fb;
+
+	if (!fb)
+		return 0;
+	return cirrus_check_size(fb->width, fb->height, fb);
+}
+
+static void cirrus_pipe_enable(struct drm_simple_display_pipe *pipe,
+			       struct drm_crtc_state *crtc_state,
+			       struct drm_plane_state *plane_state)
+{
+	struct cirrus_device *cirrus = pipe->crtc.dev->dev_private;
+
+	cirrus_mode_set(cirrus, &crtc_state->mode, plane_state->fb);
+	cirrus_fb_blit_fullscreen(plane_state->fb);
+}
+
+static void cirrus_pipe_update(struct drm_simple_display_pipe *pipe,
+			       struct drm_plane_state *old_state)
+{
+	struct cirrus_device *cirrus = pipe->crtc.dev->dev_private;
+	struct drm_plane_state *state = pipe->plane.state;
+	struct drm_crtc *crtc = &pipe->crtc;
+	struct drm_rect rect;
+
+	if (pipe->plane.state->fb &&
+	    cirrus->cpp != cirrus_cpp(pipe->plane.state->fb))
+		cirrus_mode_set(cirrus, &crtc->mode,
+				pipe->plane.state->fb);
+
+	if (drm_atomic_helper_damage_merged(old_state, state, &rect))
+		cirrus_fb_blit_rect(pipe->plane.state->fb, &rect);
+
+	if (crtc->state->event) {
+		spin_lock_irq(&crtc->dev->event_lock);
+		drm_crtc_send_vblank_event(crtc, crtc->state->event);
+		spin_unlock_irq(&crtc->dev->event_lock);
+		crtc->state->event = NULL;
+	}
+}
+
+static const struct drm_simple_display_pipe_funcs cirrus_pipe_funcs = {
+	.mode_valid = cirrus_pipe_mode_valid,
+	.check	    = cirrus_pipe_check,
+	.enable	    = cirrus_pipe_enable,
+	.update	    = cirrus_pipe_update,
+};
+
+static const uint32_t cirrus_formats[] = {
+	DRM_FORMAT_RGB565,
+	DRM_FORMAT_RGB888,
+	DRM_FORMAT_XRGB8888,
+};
+
+static const uint64_t cirrus_modifiers[] = {
+	DRM_FORMAT_MOD_LINEAR,
+	DRM_FORMAT_MOD_INVALID
+};
+
+static int cirrus_pipe_init(struct cirrus_device *cirrus)
+{
+	return drm_simple_display_pipe_init(&cirrus->dev,
+					    &cirrus->pipe,
+					    &cirrus_pipe_funcs,
+					    cirrus_formats,
+					    ARRAY_SIZE(cirrus_formats),
+					    cirrus_modifiers,
+					    &cirrus->conn);
+}
+
+/* ------------------------------------------------------------------ */
+/* cirrus framebuffers & mode config				      */
+
+static struct drm_framebuffer*
+cirrus_fb_create(struct drm_device *dev, struct drm_file *file_priv,
+		 const struct drm_mode_fb_cmd2 *mode_cmd)
+{
+	if (mode_cmd->pixel_format != DRM_FORMAT_RGB565 &&
+	    mode_cmd->pixel_format != DRM_FORMAT_RGB888 &&
+	    mode_cmd->pixel_format != DRM_FORMAT_XRGB8888)
+		return ERR_PTR(-EINVAL);
+	if (cirrus_check_size(mode_cmd->width, mode_cmd->height, NULL) < 0)
+		return ERR_PTR(-EINVAL);
+	return drm_gem_fb_create_with_dirty(dev, file_priv, mode_cmd);
+}
+
+static const struct drm_mode_config_funcs cirrus_mode_config_funcs = {
+	.fb_create = cirrus_fb_create,
+	.atomic_check = drm_atomic_helper_check,
+	.atomic_commit = drm_atomic_helper_commit,
+};
+
+static void cirrus_mode_config_init(struct cirrus_device *cirrus)
+{
+	struct drm_device *dev = &cirrus->dev;
+
+	drm_mode_config_init(dev);
+	dev->mode_config.min_width = 0;
+	dev->mode_config.min_height = 0;
+	dev->mode_config.max_width = CIRRUS_MAX_PITCH / 2;
+	dev->mode_config.max_height = 1024;
+	dev->mode_config.preferred_depth = 16;
+	dev->mode_config.prefer_shadow = 0;
+	dev->mode_config.funcs = &cirrus_mode_config_funcs;
+}
+
+/* ------------------------------------------------------------------ */
+
+DEFINE_DRM_GEM_SHMEM_FOPS(cirrus_fops);
+
+static struct drm_driver cirrus_driver = {
+	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC | DRIVER_PRIME,
+
+	.name		 = DRIVER_NAME,
+	.desc		 = DRIVER_DESC,
+	.date		 = DRIVER_DATE,
+	.major		 = DRIVER_MAJOR,
+	.minor		 = DRIVER_MINOR,
+
+	.fops		 = &cirrus_fops,
+	DRM_GEM_SHMEM_DRIVER_OPS,
+};
+
+static int cirrus_pci_probe(struct pci_dev *pdev,
+			    const struct pci_device_id *ent)
+{
+	struct drm_device *dev;
+	struct cirrus_device *cirrus;
+	int ret;
+
+	ret = drm_fb_helper_remove_conflicting_pci_framebuffers(pdev, 0, "cirrusdrmfb");
+	if (ret)
+		return ret;
+
+	ret = pci_enable_device(pdev);
+	if (ret)
+		return ret;
+
+	ret = pci_request_regions(pdev, DRIVER_NAME);
+	if (ret)
+		return ret;
+
+	ret = -ENOMEM;
+	cirrus = kzalloc(sizeof(*cirrus), GFP_KERNEL);
+	if (cirrus == NULL)
+		goto err_pci_release;
+
+	dev = &cirrus->dev;
+	ret = drm_dev_init(dev, &cirrus_driver, &pdev->dev);
+	if (ret)
+		goto err_free_cirrus;
+	dev->dev_private = cirrus;
+
+	ret = -ENOMEM;
+	cirrus->vram = ioremap(pci_resource_start(pdev, 0),
+			       pci_resource_len(pdev, 0));
+	if (cirrus->vram == NULL)
+		goto err_dev_put;
+
+	cirrus->mmio = ioremap(pci_resource_start(pdev, 1),
+			       pci_resource_len(pdev, 1));
+	if (cirrus->mmio == NULL)
+		goto err_unmap_vram;
+
+	cirrus_mode_config_init(cirrus);
+
+	ret = cirrus_conn_init(cirrus);
+	if (ret < 0)
+		goto err_cleanup;
+
+	ret = cirrus_pipe_init(cirrus);
+	if (ret < 0)
+		goto err_cleanup;
+
+	drm_mode_config_reset(dev);
+
+	dev->pdev = pdev;
+	pci_set_drvdata(pdev, dev);
+	ret = drm_dev_register(dev, 0);
+	if (ret)
+		goto err_cleanup;
+
+	drm_fbdev_generic_setup(dev, dev->mode_config.preferred_depth);
+	return 0;
+
+err_cleanup:
+	drm_mode_config_cleanup(dev);
+	iounmap(cirrus->mmio);
+err_unmap_vram:
+	iounmap(cirrus->vram);
+err_dev_put:
+	drm_dev_put(dev);
+err_free_cirrus:
+	kfree(cirrus);
+err_pci_release:
+	pci_release_regions(pdev);
+	return ret;
+}
+
+static void cirrus_pci_remove(struct pci_dev *pdev)
+{
+	struct drm_device *dev = pci_get_drvdata(pdev);
+	struct cirrus_device *cirrus = dev->dev_private;
+
+	drm_dev_unregister(dev);
+	drm_mode_config_cleanup(dev);
+	iounmap(cirrus->mmio);
+	iounmap(cirrus->vram);
+	drm_dev_put(dev);
+	kfree(cirrus);
+	pci_release_regions(pdev);
+}
+
+/* only bind to the cirrus chip in qemu */
+static const struct pci_device_id pciidlist[] = {
+	{ PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_5446,
+	  PCI_SUBVENDOR_ID_REDHAT_QUMRANET, PCI_SUBDEVICE_ID_QEMU,
+	  0, 0, 0 },
+	{ PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_5446,
+	  PCI_VENDOR_ID_XEN, 0x0001,
+	  0, 0, 0 },
+	{ /* end if list */}
+};
+static struct pci_driver cirrus_pci_driver = {
+	.name = DRIVER_NAME,
+	.id_table = pciidlist,
+	.probe = cirrus_pci_probe,
+	.remove = cirrus_pci_remove,
+};
+
+static int __init cirrus_init(void)
+{
+	if (vgacon_text_force())
+		return -EINVAL;
+	return pci_register_driver(&cirrus_pci_driver);
+}
+
+static void __exit cirrus_exit(void)
+{
+	pci_unregister_driver(&cirrus_pci_driver);
+}
+
+module_init(cirrus_init);
+module_exit(cirrus_exit);
+
+MODULE_DEVICE_TABLE(pci, pciidlist);
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpu/drm/cirrus/cirrus_drv.c b/drivers/gpu/drm/cirrus/cirrus_drv.c
deleted file mode 100644
index 8ec880f3a322..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_drv.c
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright 2012 Red Hat <mjg@redhat.com>
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License version 2. See the file COPYING in the main
- * directory of this archive for more details.
- *
- * Authors: Matthew Garrett
- *          Dave Airlie
- */
-#include <linux/module.h>
-#include <linux/console.h>
-#include <drm/drmP.h>
-#include <drm/drm_crtc_helper.h>
-#include <drm/drm_probe_helper.h>
-
-#include "cirrus_drv.h"
-
-int cirrus_modeset = -1;
-int cirrus_bpp = 16;
-
-MODULE_PARM_DESC(modeset, "Disable/Enable modesetting");
-module_param_named(modeset, cirrus_modeset, int, 0400);
-MODULE_PARM_DESC(bpp, "Max bits-per-pixel (default:16)");
-module_param_named(bpp, cirrus_bpp, int, 0400);
-
-/*
- * This is the generic driver code. This binds the driver to the drm core,
- * which then performs further device association and calls our graphics init
- * functions
- */
-
-static struct drm_driver driver;
-
-/* only bind to the cirrus chip in qemu */
-static const struct pci_device_id pciidlist[] = {
-	{ PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_5446,
-	  PCI_SUBVENDOR_ID_REDHAT_QUMRANET, PCI_SUBDEVICE_ID_QEMU,
-	  0, 0, 0 },
-	{ PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_5446, PCI_VENDOR_ID_XEN,
-	  0x0001, 0, 0, 0 },
-	{0,}
-};
-
-
-static int cirrus_pci_probe(struct pci_dev *pdev,
-			    const struct pci_device_id *ent)
-{
-	int ret;
-
-	ret = drm_fb_helper_remove_conflicting_pci_framebuffers(pdev, 0, "cirrusdrmfb");
-	if (ret)
-		return ret;
-
-	return drm_get_pci_dev(pdev, ent, &driver);
-}
-
-static void cirrus_pci_remove(struct pci_dev *pdev)
-{
-	struct drm_device *dev = pci_get_drvdata(pdev);
-
-	drm_put_dev(dev);
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int cirrus_pm_suspend(struct device *dev)
-{
-	struct pci_dev *pdev = to_pci_dev(dev);
-	struct drm_device *drm_dev = pci_get_drvdata(pdev);
-	struct cirrus_device *cdev = drm_dev->dev_private;
-
-	drm_kms_helper_poll_disable(drm_dev);
-
-	if (cdev->mode_info.gfbdev) {
-		console_lock();
-		drm_fb_helper_set_suspend(&cdev->mode_info.gfbdev->helper, 1);
-		console_unlock();
-	}
-
-	return 0;
-}
-
-static int cirrus_pm_resume(struct device *dev)
-{
-	struct pci_dev *pdev = to_pci_dev(dev);
-	struct drm_device *drm_dev = pci_get_drvdata(pdev);
-	struct cirrus_device *cdev = drm_dev->dev_private;
-
-	drm_helper_resume_force_mode(drm_dev);
-
-	if (cdev->mode_info.gfbdev) {
-		console_lock();
-		drm_fb_helper_set_suspend(&cdev->mode_info.gfbdev->helper, 0);
-		console_unlock();
-	}
-
-	drm_kms_helper_poll_enable(drm_dev);
-	return 0;
-}
-#endif
-
-static const struct file_operations cirrus_driver_fops = {
-	.owner = THIS_MODULE,
-	.open = drm_open,
-	.release = drm_release,
-	.unlocked_ioctl = drm_ioctl,
-	.mmap = cirrus_mmap,
-	.poll = drm_poll,
-	.compat_ioctl = drm_compat_ioctl,
-};
-static struct drm_driver driver = {
-	.driver_features = DRIVER_MODESET | DRIVER_GEM,
-	.load = cirrus_driver_load,
-	.unload = cirrus_driver_unload,
-	.fops = &cirrus_driver_fops,
-	.name = DRIVER_NAME,
-	.desc = DRIVER_DESC,
-	.date = DRIVER_DATE,
-	.major = DRIVER_MAJOR,
-	.minor = DRIVER_MINOR,
-	.patchlevel = DRIVER_PATCHLEVEL,
-	.gem_free_object_unlocked = cirrus_gem_free_object,
-	.dumb_create = cirrus_dumb_create,
-	.dumb_map_offset = cirrus_dumb_mmap_offset,
-};
-
-static const struct dev_pm_ops cirrus_pm_ops = {
-	SET_SYSTEM_SLEEP_PM_OPS(cirrus_pm_suspend,
-				cirrus_pm_resume)
-};
-
-static struct pci_driver cirrus_pci_driver = {
-	.name = DRIVER_NAME,
-	.id_table = pciidlist,
-	.probe = cirrus_pci_probe,
-	.remove = cirrus_pci_remove,
-	.driver.pm = &cirrus_pm_ops,
-};
-
-static int __init cirrus_init(void)
-{
-	if (vgacon_text_force() && cirrus_modeset == -1)
-		return -EINVAL;
-
-	if (cirrus_modeset == 0)
-		return -EINVAL;
-	return pci_register_driver(&cirrus_pci_driver);
-}
-
-static void __exit cirrus_exit(void)
-{
-	pci_unregister_driver(&cirrus_pci_driver);
-}
-
-module_init(cirrus_init);
-module_exit(cirrus_exit);
-
-MODULE_DEVICE_TABLE(pci, pciidlist);
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
diff --git a/drivers/gpu/drm/cirrus/cirrus_fbdev.c b/drivers/gpu/drm/cirrus/cirrus_fbdev.c
deleted file mode 100644
index 2e6128069fc3..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_fbdev.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * Copyright 2012 Red Hat
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License version 2. See the file COPYING in the main
- * directory of this archive for more details.
- *
- * Authors: Matthew Garrett
- *          Dave Airlie
- */
-#include <linux/module.h>
-#include <drm/drmP.h>
-#include <drm/drm_util.h>
-#include <drm/drm_fb_helper.h>
-#include <drm/drm_crtc_helper.h>
-
-#include "cirrus_drv.h"
-
-static void cirrus_dirty_update(struct cirrus_fbdev *afbdev,
-			     int x, int y, int width, int height)
-{
-	int i;
-	struct drm_gem_object *obj;
-	struct cirrus_bo *bo;
-	int src_offset, dst_offset;
-	int bpp = afbdev->gfb->format->cpp[0];
-	int ret = -EBUSY;
-	bool unmap = false;
-	bool store_for_later = false;
-	int x2, y2;
-	unsigned long flags;
-
-	obj = afbdev->gfb->obj[0];
-	bo = gem_to_cirrus_bo(obj);
-
-	/*
-	 * try and reserve the BO, if we fail with busy
-	 * then the BO is being moved and we should
-	 * store up the damage until later.
-	 */
-	if (drm_can_sleep())
-		ret = cirrus_bo_reserve(bo, true);
-	if (ret) {
-		if (ret != -EBUSY)
-			return;
-		store_for_later = true;
-	}
-
-	x2 = x + width - 1;
-	y2 = y + height - 1;
-	spin_lock_irqsave(&afbdev->dirty_lock, flags);
-
-	if (afbdev->y1 < y)
-		y = afbdev->y1;
-	if (afbdev->y2 > y2)
-		y2 = afbdev->y2;
-	if (afbdev->x1 < x)
-		x = afbdev->x1;
-	if (afbdev->x2 > x2)
-		x2 = afbdev->x2;
-
-	if (store_for_later) {
-		afbdev->x1 = x;
-		afbdev->x2 = x2;
-		afbdev->y1 = y;
-		afbdev->y2 = y2;
-		spin_unlock_irqrestore(&afbdev->dirty_lock, flags);
-		return;
-	}
-
-	afbdev->x1 = afbdev->y1 = INT_MAX;
-	afbdev->x2 = afbdev->y2 = 0;
-	spin_unlock_irqrestore(&afbdev->dirty_lock, flags);
-
-	if (!bo->kmap.virtual) {
-		ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &bo->kmap);
-		if (ret) {
-			DRM_ERROR("failed to kmap fb updates\n");
-			cirrus_bo_unreserve(bo);
-			return;
-		}
-		unmap = true;
-	}
-	for (i = y; i < y + height; i++) {
-		/* assume equal stride for now */
-		src_offset = dst_offset = i * afbdev->gfb->pitches[0] + (x * bpp);
-		memcpy_toio(bo->kmap.virtual + src_offset, afbdev->sysram + src_offset, width * bpp);
-
-	}
-	if (unmap)
-		ttm_bo_kunmap(&bo->kmap);
-
-	cirrus_bo_unreserve(bo);
-}
-
-static void cirrus_fillrect(struct fb_info *info,
-			 const struct fb_fillrect *rect)
-{
-	struct cirrus_fbdev *afbdev = info->par;
-	drm_fb_helper_sys_fillrect(info, rect);
-	cirrus_dirty_update(afbdev, rect->dx, rect->dy, rect->width,
-			 rect->height);
-}
-
-static void cirrus_copyarea(struct fb_info *info,
-			 const struct fb_copyarea *area)
-{
-	struct cirrus_fbdev *afbdev = info->par;
-	drm_fb_helper_sys_copyarea(info, area);
-	cirrus_dirty_update(afbdev, area->dx, area->dy, area->width,
-			 area->height);
-}
-
-static void cirrus_imageblit(struct fb_info *info,
-			  const struct fb_image *image)
-{
-	struct cirrus_fbdev *afbdev = info->par;
-	drm_fb_helper_sys_imageblit(info, image);
-	cirrus_dirty_update(afbdev, image->dx, image->dy, image->width,
-			 image->height);
-}
-
-
-static struct fb_ops cirrusfb_ops = {
-	.owner = THIS_MODULE,
-	.fb_check_var = drm_fb_helper_check_var,
-	.fb_set_par = drm_fb_helper_set_par,
-	.fb_fillrect = cirrus_fillrect,
-	.fb_copyarea = cirrus_copyarea,
-	.fb_imageblit = cirrus_imageblit,
-	.fb_pan_display = drm_fb_helper_pan_display,
-	.fb_blank = drm_fb_helper_blank,
-	.fb_setcmap = drm_fb_helper_setcmap,
-};
-
-static int cirrusfb_create_object(struct cirrus_fbdev *afbdev,
-			       const struct drm_mode_fb_cmd2 *mode_cmd,
-			       struct drm_gem_object **gobj_p)
-{
-	struct drm_device *dev = afbdev->helper.dev;
-	struct cirrus_device *cdev = dev->dev_private;
-	u32 bpp;
-	u32 size;
-	struct drm_gem_object *gobj;
-	int ret = 0;
-
-	bpp = drm_format_plane_cpp(mode_cmd->pixel_format, 0) * 8;
-
-	if (!cirrus_check_framebuffer(cdev, mode_cmd->width, mode_cmd->height,
-				      bpp, mode_cmd->pitches[0]))
-		return -EINVAL;
-
-	size = mode_cmd->pitches[0] * mode_cmd->height;
-	ret = cirrus_gem_create(dev, size, true, &gobj);
-	if (ret)
-		return ret;
-
-	*gobj_p = gobj;
-	return ret;
-}
-
-static int cirrusfb_create(struct drm_fb_helper *helper,
-			   struct drm_fb_helper_surface_size *sizes)
-{
-	struct cirrus_fbdev *gfbdev =
-		container_of(helper, struct cirrus_fbdev, helper);
-	struct cirrus_device *cdev = gfbdev->helper.dev->dev_private;
-	struct fb_info *info;
-	struct drm_framebuffer *fb;
-	struct drm_mode_fb_cmd2 mode_cmd;
-	void *sysram;
-	struct drm_gem_object *gobj = NULL;
-	int size, ret;
-
-	mode_cmd.width = sizes->surface_width;
-	mode_cmd.height = sizes->surface_height;
-	mode_cmd.pitches[0] = mode_cmd.width * ((sizes->surface_bpp + 7) / 8);
-	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
-							  sizes->surface_depth);
-	size = mode_cmd.pitches[0] * mode_cmd.height;
-
-	ret = cirrusfb_create_object(gfbdev, &mode_cmd, &gobj);
-	if (ret) {
-		DRM_ERROR("failed to create fbcon backing object %d\n", ret);
-		return ret;
-	}
-
-	sysram = vmalloc(size);
-	if (!sysram)
-		return -ENOMEM;
-
-	info = drm_fb_helper_alloc_fbi(helper);
-	if (IS_ERR(info)) {
-		ret = PTR_ERR(info);
-		goto err_vfree;
-	}
-
-	fb = kzalloc(sizeof(*fb), GFP_KERNEL);
-	if (!fb) {
-		ret = -ENOMEM;
-		goto err_drm_gem_object_put_unlocked;
-	}
-
-	ret = cirrus_framebuffer_init(cdev->dev, fb, &mode_cmd, gobj);
-	if (ret)
-		goto err_kfree;
-
-	gfbdev->sysram = sysram;
-	gfbdev->size = size;
-	gfbdev->gfb = fb;
-
-	/* setup helper */
-	gfbdev->helper.fb = fb;
-
-	info->fbops = &cirrusfb_ops;
-
-	drm_fb_helper_fill_info(info, &gfbdev->helper, sizes);
-
-	/* setup aperture base/size for vesafb takeover */
-	info->apertures->ranges[0].base = cdev->dev->mode_config.fb_base;
-	info->apertures->ranges[0].size = cdev->mc.vram_size;
-
-	info->fix.smem_start = cdev->dev->mode_config.fb_base;
-	info->fix.smem_len = cdev->mc.vram_size;
-
-	info->screen_base = sysram;
-	info->screen_size = size;
-
-	info->fix.mmio_start = 0;
-	info->fix.mmio_len = 0;
-
-	DRM_INFO("fb mappable at 0x%lX\n", info->fix.smem_start);
-	DRM_INFO("vram aper at 0x%lX\n", (unsigned long)info->fix.smem_start);
-	DRM_INFO("size %lu\n", (unsigned long)info->fix.smem_len);
-	DRM_INFO("fb depth is %d\n", fb->format->depth);
-	DRM_INFO("   pitch is %d\n", fb->pitches[0]);
-
-	return 0;
-
-err_kfree:
-	kfree(fb);
-err_drm_gem_object_put_unlocked:
-	drm_gem_object_put_unlocked(gobj);
-err_vfree:
-	vfree(sysram);
-	return ret;
-}
-
-static int cirrus_fbdev_destroy(struct drm_device *dev,
-				struct cirrus_fbdev *gfbdev)
-{
-	struct drm_framebuffer *gfb = gfbdev->gfb;
-
-	drm_helper_force_disable_all(dev);
-
-	drm_fb_helper_unregister_fbi(&gfbdev->helper);
-
-	vfree(gfbdev->sysram);
-	drm_fb_helper_fini(&gfbdev->helper);
-	if (gfb)
-		drm_framebuffer_put(gfb);
-
-	return 0;
-}
-
-static const struct drm_fb_helper_funcs cirrus_fb_helper_funcs = {
-	.fb_probe = cirrusfb_create,
-};
-
-int cirrus_fbdev_init(struct cirrus_device *cdev)
-{
-	struct cirrus_fbdev *gfbdev;
-	int ret;
-
-	/*bpp_sel = 8;*/
-	gfbdev = kzalloc(sizeof(struct cirrus_fbdev), GFP_KERNEL);
-	if (!gfbdev)
-		return -ENOMEM;
-
-	cdev->mode_info.gfbdev = gfbdev;
-	spin_lock_init(&gfbdev->dirty_lock);
-
-	drm_fb_helper_prepare(cdev->dev, &gfbdev->helper,
-			      &cirrus_fb_helper_funcs);
-
-	ret = drm_fb_helper_init(cdev->dev, &gfbdev->helper,
-				 CIRRUSFB_CONN_LIMIT);
-	if (ret)
-		return ret;
-
-	ret = drm_fb_helper_single_add_all_connectors(&gfbdev->helper);
-	if (ret)
-		return ret;
-
-	/* disable all the possible outputs/crtcs before entering KMS mode */
-	drm_helper_disable_unused_functions(cdev->dev);
-
-	return drm_fb_helper_initial_config(&gfbdev->helper, cirrus_bpp);
-}
-
-void cirrus_fbdev_fini(struct cirrus_device *cdev)
-{
-	if (!cdev->mode_info.gfbdev)
-		return;
-
-	cirrus_fbdev_destroy(cdev->dev, cdev->mode_info.gfbdev);
-	kfree(cdev->mode_info.gfbdev);
-	cdev->mode_info.gfbdev = NULL;
-}
diff --git a/drivers/gpu/drm/cirrus/cirrus_main.c b/drivers/gpu/drm/cirrus/cirrus_main.c
deleted file mode 100644
index 57f8fe6d020b..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_main.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * Copyright 2012 Red Hat
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License version 2. See the file COPYING in the main
- * directory of this archive for more details.
- *
- * Authors: Matthew Garrett
- *          Dave Airlie
- */
-#include <drm/drmP.h>
-#include <drm/drm_crtc_helper.h>
-#include <drm/drm_gem_framebuffer_helper.h>
-
-#include "cirrus_drv.h"
-
-static const struct drm_framebuffer_funcs cirrus_fb_funcs = {
-	.create_handle = drm_gem_fb_create_handle,
-	.destroy = drm_gem_fb_destroy,
-};
-
-int cirrus_framebuffer_init(struct drm_device *dev,
-			    struct drm_framebuffer *gfb,
-			    const struct drm_mode_fb_cmd2 *mode_cmd,
-			    struct drm_gem_object *obj)
-{
-	int ret;
-
-	drm_helper_mode_fill_fb_struct(dev, gfb, mode_cmd);
-	gfb->obj[0] = obj;
-	ret = drm_framebuffer_init(dev, gfb, &cirrus_fb_funcs);
-	if (ret) {
-		DRM_ERROR("drm_framebuffer_init failed: %d\n", ret);
-		return ret;
-	}
-	return 0;
-}
-
-static struct drm_framebuffer *
-cirrus_user_framebuffer_create(struct drm_device *dev,
-			       struct drm_file *filp,
-			       const struct drm_mode_fb_cmd2 *mode_cmd)
-{
-	struct cirrus_device *cdev = dev->dev_private;
-	struct drm_gem_object *obj;
-	struct drm_framebuffer *fb;
-	u32 bpp;
-	int ret;
-
-	bpp = drm_format_plane_cpp(mode_cmd->pixel_format, 0) * 8;
-
-	if (!cirrus_check_framebuffer(cdev, mode_cmd->width, mode_cmd->height,
-				      bpp, mode_cmd->pitches[0]))
-		return ERR_PTR(-EINVAL);
-
-	obj = drm_gem_object_lookup(filp, mode_cmd->handles[0]);
-	if (obj == NULL)
-		return ERR_PTR(-ENOENT);
-
-	fb = kzalloc(sizeof(*fb), GFP_KERNEL);
-	if (!fb) {
-		drm_gem_object_put_unlocked(obj);
-		return ERR_PTR(-ENOMEM);
-	}
-
-	ret = cirrus_framebuffer_init(dev, fb, mode_cmd, obj);
-	if (ret) {
-		drm_gem_object_put_unlocked(obj);
-		kfree(fb);
-		return ERR_PTR(ret);
-	}
-	return fb;
-}
-
-static const struct drm_mode_config_funcs cirrus_mode_funcs = {
-	.fb_create = cirrus_user_framebuffer_create,
-};
-
-/* Unmap the framebuffer from the core and release the memory */
-static void cirrus_vram_fini(struct cirrus_device *cdev)
-{
-	iounmap(cdev->rmmio);
-	cdev->rmmio = NULL;
-	if (cdev->mc.vram_base)
-		release_mem_region(cdev->mc.vram_base, cdev->mc.vram_size);
-}
-
-/* Map the framebuffer from the card and configure the core */
-static int cirrus_vram_init(struct cirrus_device *cdev)
-{
-	/* BAR 0 is VRAM */
-	cdev->mc.vram_base = pci_resource_start(cdev->dev->pdev, 0);
-	cdev->mc.vram_size = pci_resource_len(cdev->dev->pdev, 0);
-
-	if (!request_mem_region(cdev->mc.vram_base, cdev->mc.vram_size,
-				"cirrusdrmfb_vram")) {
-		DRM_ERROR("can't reserve VRAM\n");
-		return -ENXIO;
-	}
-
-	return 0;
-}
-
-/*
- * Our emulated hardware has two sets of memory. One is video RAM and can
- * simply be used as a linear framebuffer - the other provides mmio access
- * to the display registers. The latter can also be accessed via IO port
- * access, but we map the range and use mmio to program them instead
- */
-
-int cirrus_device_init(struct cirrus_device *cdev,
-		       struct drm_device *ddev,
-		       struct pci_dev *pdev, uint32_t flags)
-{
-	int ret;
-
-	cdev->dev = ddev;
-	cdev->flags = flags;
-
-	/* Hardcode the number of CRTCs to 1 */
-	cdev->num_crtc = 1;
-
-	/* BAR 0 is the framebuffer, BAR 1 contains registers */
-	cdev->rmmio_base = pci_resource_start(cdev->dev->pdev, 1);
-	cdev->rmmio_size = pci_resource_len(cdev->dev->pdev, 1);
-
-	if (!request_mem_region(cdev->rmmio_base, cdev->rmmio_size,
-				"cirrusdrmfb_mmio")) {
-		DRM_ERROR("can't reserve mmio registers\n");
-		return -ENOMEM;
-	}
-
-	cdev->rmmio = ioremap(cdev->rmmio_base, cdev->rmmio_size);
-
-	if (cdev->rmmio == NULL)
-		return -ENOMEM;
-
-	ret = cirrus_vram_init(cdev);
-	if (ret) {
-		release_mem_region(cdev->rmmio_base, cdev->rmmio_size);
-		return ret;
-	}
-
-	return 0;
-}
-
-void cirrus_device_fini(struct cirrus_device *cdev)
-{
-	release_mem_region(cdev->rmmio_base, cdev->rmmio_size);
-	cirrus_vram_fini(cdev);
-}
-
-/*
- * Functions here will be called by the core once it's bound the driver to
- * a PCI device
- */
-
-int cirrus_driver_load(struct drm_device *dev, unsigned long flags)
-{
-	struct cirrus_device *cdev;
-	int r;
-
-	cdev = kzalloc(sizeof(struct cirrus_device), GFP_KERNEL);
-	if (cdev == NULL)
-		return -ENOMEM;
-	dev->dev_private = (void *)cdev;
-
-	r = cirrus_device_init(cdev, dev, dev->pdev, flags);
-	if (r) {
-		dev_err(&dev->pdev->dev, "Fatal error during GPU init: %d\n", r);
-		goto out;
-	}
-
-	r = cirrus_mm_init(cdev);
-	if (r) {
-		dev_err(&dev->pdev->dev, "fatal err on mm init\n");
-		goto out;
-	}
-
-	/*
-	 * cirrus_modeset_init() is initializing/registering the emulated fbdev
-	 * and DRM internals can access/test some of the fields in
-	 * mode_config->funcs as part of the fbdev registration process.
-	 * Make sure dev->mode_config.funcs is properly set to avoid
-	 * dereferencing a NULL pointer.
-	 * FIXME: mode_config.funcs assignment should probably be done in
-	 * cirrus_modeset_init() (that's a common pattern seen in other DRM
-	 * drivers).
-	 */
-	dev->mode_config.funcs = &cirrus_mode_funcs;
-	r = cirrus_modeset_init(cdev);
-	if (r) {
-		dev_err(&dev->pdev->dev, "Fatal error during modeset init: %d\n", r);
-		goto out;
-	}
-
-	return 0;
-out:
-	cirrus_driver_unload(dev);
-	return r;
-}
-
-void cirrus_driver_unload(struct drm_device *dev)
-{
-	struct cirrus_device *cdev = dev->dev_private;
-
-	if (cdev == NULL)
-		return;
-	cirrus_modeset_fini(cdev);
-	cirrus_mm_fini(cdev);
-	cirrus_device_fini(cdev);
-	kfree(cdev);
-	dev->dev_private = NULL;
-}
-
-int cirrus_gem_create(struct drm_device *dev,
-		   u32 size, bool iskernel,
-		   struct drm_gem_object **obj)
-{
-	struct cirrus_bo *cirrusbo;
-	int ret;
-
-	*obj = NULL;
-
-	size = roundup(size, PAGE_SIZE);
-	if (size == 0)
-		return -EINVAL;
-
-	ret = cirrus_bo_create(dev, size, 0, 0, &cirrusbo);
-	if (ret) {
-		if (ret != -ERESTARTSYS)
-			DRM_ERROR("failed to allocate GEM object\n");
-		return ret;
-	}
-	*obj = &cirrusbo->gem;
-	return 0;
-}
-
-int cirrus_dumb_create(struct drm_file *file,
-		    struct drm_device *dev,
-		    struct drm_mode_create_dumb *args)
-{
-	int ret;
-	struct drm_gem_object *gobj;
-	u32 handle;
-
-	args->pitch = args->width * ((args->bpp + 7) / 8);
-	args->size = args->pitch * args->height;
-
-	ret = cirrus_gem_create(dev, args->size, false,
-			     &gobj);
-	if (ret)
-		return ret;
-
-	ret = drm_gem_handle_create(file, gobj, &handle);
-	drm_gem_object_put_unlocked(gobj);
-	if (ret)
-		return ret;
-
-	args->handle = handle;
-	return 0;
-}
-
-static void cirrus_bo_unref(struct cirrus_bo **bo)
-{
-	struct ttm_buffer_object *tbo;
-
-	if ((*bo) == NULL)
-		return;
-
-	tbo = &((*bo)->bo);
-	ttm_bo_put(tbo);
-	*bo = NULL;
-}
-
-void cirrus_gem_free_object(struct drm_gem_object *obj)
-{
-	struct cirrus_bo *cirrus_bo = gem_to_cirrus_bo(obj);
-
-	cirrus_bo_unref(&cirrus_bo);
-}
-
-
-static inline u64 cirrus_bo_mmap_offset(struct cirrus_bo *bo)
-{
-	return drm_vma_node_offset_addr(&bo->bo.vma_node);
-}
-
-int
-cirrus_dumb_mmap_offset(struct drm_file *file,
-		     struct drm_device *dev,
-		     uint32_t handle,
-		     uint64_t *offset)
-{
-	struct drm_gem_object *obj;
-	struct cirrus_bo *bo;
-
-	obj = drm_gem_object_lookup(file, handle);
-	if (obj == NULL)
-		return -ENOENT;
-
-	bo = gem_to_cirrus_bo(obj);
-	*offset = cirrus_bo_mmap_offset(bo);
-
-	drm_gem_object_put_unlocked(obj);
-
-	return 0;
-}
-
-bool cirrus_check_framebuffer(struct cirrus_device *cdev, int width, int height,
-			      int bpp, int pitch)
-{
-	const int max_pitch = 0x1FF << 3; /* (4096 - 1) & ~111b bytes */
-	const int max_size = cdev->mc.vram_size;
-
-	if (bpp > cirrus_bpp)
-		return false;
-	if (bpp > 32)
-		return false;
-
-	if (pitch > max_pitch)
-		return false;
-
-	if (pitch * height > max_size)
-		return false;
-
-	return true;
-}
diff --git a/drivers/gpu/drm/cirrus/cirrus_mode.c b/drivers/gpu/drm/cirrus/cirrus_mode.c
deleted file mode 100644
index b109cd71426f..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_mode.c
+++ /dev/null
@@ -1,617 +0,0 @@
-
-/*
- * Copyright 2012 Red Hat
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License version 2. See the file COPYING in the main
- * directory of this archive for more details.
- *
- * Authors: Matthew Garrett
- *          Dave Airlie
- *
- * Portions of this code derived from cirrusfb.c:
- * drivers/video/cirrusfb.c - driver for Cirrus Logic chipsets
- *
- * Copyright 1999-2001 Jeff Garzik <jgarzik@pobox.com>
- */
-#include <drm/drmP.h>
-#include <drm/drm_crtc_helper.h>
-#include <drm/drm_plane_helper.h>
-#include <drm/drm_probe_helper.h>
-
-#include <video/cirrus.h>
-
-#include "cirrus_drv.h"
-
-#define CIRRUS_LUT_SIZE 256
-
-#define PALETTE_INDEX 0x8
-#define PALETTE_DATA 0x9
-
-/*
- * This file contains setup code for the CRTC.
- */
-
-/*
- * The DRM core requires DPMS functions, but they make little sense in our
- * case and so are just stubs
- */
-
-static void cirrus_crtc_dpms(struct drm_crtc *crtc, int mode)
-{
-	struct drm_device *dev = crtc->dev;
-	struct cirrus_device *cdev = dev->dev_private;
-	u8 sr01, gr0e;
-
-	switch (mode) {
-	case DRM_MODE_DPMS_ON:
-		sr01 = 0x00;
-		gr0e = 0x00;
-		break;
-	case DRM_MODE_DPMS_STANDBY:
-		sr01 = 0x20;
-		gr0e = 0x02;
-		break;
-	case DRM_MODE_DPMS_SUSPEND:
-		sr01 = 0x20;
-		gr0e = 0x04;
-		break;
-	case DRM_MODE_DPMS_OFF:
-		sr01 = 0x20;
-		gr0e = 0x06;
-		break;
-	default:
-		return;
-	}
-
-	WREG8(SEQ_INDEX, 0x1);
-	sr01 |= RREG8(SEQ_DATA) & ~0x20;
-	WREG_SEQ(0x1, sr01);
-
-	WREG8(GFX_INDEX, 0xe);
-	gr0e |= RREG8(GFX_DATA) & ~0x06;
-	WREG_GFX(0xe, gr0e);
-}
-
-static void cirrus_set_start_address(struct drm_crtc *crtc, unsigned offset)
-{
-	struct cirrus_device *cdev = crtc->dev->dev_private;
-	u32 addr;
-	u8 tmp;
-
-	addr = offset >> 2;
-	WREG_CRT(0x0c, (u8)((addr >> 8) & 0xff));
-	WREG_CRT(0x0d, (u8)(addr & 0xff));
-
-	WREG8(CRT_INDEX, 0x1b);
-	tmp = RREG8(CRT_DATA);
-	tmp &= 0xf2;
-	tmp |= (addr >> 16) & 0x01;
-	tmp |= (addr >> 15) & 0x0c;
-	WREG_CRT(0x1b, tmp);
-	WREG8(CRT_INDEX, 0x1d);
-	tmp = RREG8(CRT_DATA);
-	tmp &= 0x7f;
-	tmp |= (addr >> 12) & 0x80;
-	WREG_CRT(0x1d, tmp);
-}
-
-/* cirrus is different - we will force move buffers out of VRAM */
-static int cirrus_crtc_do_set_base(struct drm_crtc *crtc,
-				struct drm_framebuffer *fb,
-				int x, int y, int atomic)
-{
-	struct cirrus_device *cdev = crtc->dev->dev_private;
-	struct cirrus_bo *bo;
-	int ret;
-	u64 gpu_addr;
-
-	/* push the previous fb to system ram */
-	if (!atomic && fb) {
-		bo = gem_to_cirrus_bo(fb->obj[0]);
-		ret = cirrus_bo_reserve(bo, false);
-		if (ret)
-			return ret;
-		cirrus_bo_push_sysram(bo);
-		cirrus_bo_unreserve(bo);
-	}
-
-	bo = gem_to_cirrus_bo(crtc->primary->fb->obj[0]);
-
-	ret = cirrus_bo_reserve(bo, false);
-	if (ret)
-		return ret;
-
-	ret = cirrus_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr);
-	if (ret) {
-		cirrus_bo_unreserve(bo);
-		return ret;
-	}
-
-	if (cdev->mode_info.gfbdev->gfb == crtc->primary->fb) {
-		/* if pushing console in kmap it */
-		ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &bo->kmap);
-		if (ret)
-			DRM_ERROR("failed to kmap fbcon\n");
-	}
-	cirrus_bo_unreserve(bo);
-
-	cirrus_set_start_address(crtc, (u32)gpu_addr);
-	return 0;
-}
-
-static int cirrus_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
-			     struct drm_framebuffer *old_fb)
-{
-	return cirrus_crtc_do_set_base(crtc, old_fb, x, y, 0);
-}
-
-/*
- * The meat of this driver. The core passes us a mode and we have to program
- * it. The modesetting here is the bare minimum required to satisfy the qemu
- * emulation of this hardware, and running this against a real device is
- * likely to result in an inadequately programmed mode. We've already had
- * the opportunity to modify the mode, so whatever we receive here should
- * be something that can be correctly programmed and displayed
- */
-static int cirrus_crtc_mode_set(struct drm_crtc *crtc,
-				struct drm_display_mode *mode,
-				struct drm_display_mode *adjusted_mode,
-				int x, int y, struct drm_framebuffer *old_fb)
-{
-	struct drm_device *dev = crtc->dev;
-	struct cirrus_device *cdev = dev->dev_private;
-	const struct drm_framebuffer *fb = crtc->primary->fb;
-	int hsyncstart, hsyncend, htotal, hdispend;
-	int vtotal, vdispend;
-	int tmp;
-	int sr07 = 0, hdr = 0;
-
-	htotal = mode->htotal / 8;
-	hsyncend = mode->hsync_end / 8;
-	hsyncstart = mode->hsync_start / 8;
-	hdispend = mode->hdisplay / 8;
-
-	vtotal = mode->vtotal;
-	vdispend = mode->vdisplay;
-
-	vdispend -= 1;
-	vtotal -= 2;
-
-	htotal -= 5;
-	hdispend -= 1;
-	hsyncstart += 1;
-	hsyncend += 1;
-
-	WREG_CRT(VGA_CRTC_V_SYNC_END, 0x20);
-	WREG_CRT(VGA_CRTC_H_TOTAL, htotal);
-	WREG_CRT(VGA_CRTC_H_DISP, hdispend);
-	WREG_CRT(VGA_CRTC_H_SYNC_START, hsyncstart);
-	WREG_CRT(VGA_CRTC_H_SYNC_END, hsyncend);
-	WREG_CRT(VGA_CRTC_V_TOTAL, vtotal & 0xff);
-	WREG_CRT(VGA_CRTC_V_DISP_END, vdispend & 0xff);
-
-	tmp = 0x40;
-	if ((vdispend + 1) & 512)
-		tmp |= 0x20;
-	WREG_CRT(VGA_CRTC_MAX_SCAN, tmp);
-
-	/*
-	 * Overflow bits for values that don't fit in the standard registers
-	 */
-	tmp = 16;
-	if (vtotal & 256)
-		tmp |= 1;
-	if (vdispend & 256)
-		tmp |= 2;
-	if ((vdispend + 1) & 256)
-		tmp |= 8;
-	if (vtotal & 512)
-		tmp |= 32;
-	if (vdispend & 512)
-		tmp |= 64;
-	WREG_CRT(VGA_CRTC_OVERFLOW, tmp);
-
-	tmp = 0;
-
-	/* More overflow bits */
-
-	if ((htotal + 5) & 64)
-		tmp |= 16;
-	if ((htotal + 5) & 128)
-		tmp |= 32;
-	if (vtotal & 256)
-		tmp |= 64;
-	if (vtotal & 512)
-		tmp |= 128;
-
-	WREG_CRT(CL_CRT1A, tmp);
-
-	/* Disable Hercules/CGA compatibility */
-	WREG_CRT(VGA_CRTC_MODE, 0x03);
-
-	WREG8(SEQ_INDEX, 0x7);
-	sr07 = RREG8(SEQ_DATA);
-	sr07 &= 0xe0;
-	hdr = 0;
-	switch (fb->format->cpp[0] * 8) {
-	case 8:
-		sr07 |= 0x11;
-		break;
-	case 16:
-		sr07 |= 0x17;
-		hdr = 0xc1;
-		break;
-	case 24:
-		sr07 |= 0x15;
-		hdr = 0xc5;
-		break;
-	case 32:
-		sr07 |= 0x19;
-		hdr = 0xc5;
-		break;
-	default:
-		return -1;
-	}
-
-	WREG_SEQ(0x7, sr07);
-
-	/* Program the pitch */
-	tmp = fb->pitches[0] / 8;
-	WREG_CRT(VGA_CRTC_OFFSET, tmp);
-
-	/* Enable extended blanking and pitch bits, and enable full memory */
-	tmp = 0x22;
-	tmp |= (fb->pitches[0] >> 7) & 0x10;
-	tmp |= (fb->pitches[0] >> 6) & 0x40;
-	WREG_CRT(0x1b, tmp);
-
-	/* Enable high-colour modes */
-	WREG_GFX(VGA_GFX_MODE, 0x40);
-
-	/* And set graphics mode */
-	WREG_GFX(VGA_GFX_MISC, 0x01);
-
-	WREG_HDR(hdr);
-	cirrus_crtc_do_set_base(crtc, old_fb, x, y, 0);
-
-	/* Unblank (needed on S3 resume, vgabios doesn't do it then) */
-	outb(0x20, 0x3c0);
-	return 0;
-}
-
-/*
- * This is called before a mode is programmed. A typical use might be to
- * enable DPMS during the programming to avoid seeing intermediate stages,
- * but that's not relevant to us
- */
-static void cirrus_crtc_prepare(struct drm_crtc *crtc)
-{
-}
-
-static void cirrus_crtc_load_lut(struct drm_crtc *crtc)
-{
-	struct drm_device *dev = crtc->dev;
-	struct cirrus_device *cdev = dev->dev_private;
-	u16 *r, *g, *b;
-	int i;
-
-	if (!crtc->enabled)
-		return;
-
-	r = crtc->gamma_store;
-	g = r + crtc->gamma_size;
-	b = g + crtc->gamma_size;
-
-	for (i = 0; i < CIRRUS_LUT_SIZE; i++) {
-		/* VGA registers */
-		WREG8(PALETTE_INDEX, i);
-		WREG8(PALETTE_DATA, *r++ >> 8);
-		WREG8(PALETTE_DATA, *g++ >> 8);
-		WREG8(PALETTE_DATA, *b++ >> 8);
-	}
-}
-
-/*
- * This is called after a mode is programmed. It should reverse anything done
- * by the prepare function
- */
-static void cirrus_crtc_commit(struct drm_crtc *crtc)
-{
-	cirrus_crtc_load_lut(crtc);
-}
-
-/*
- * The core can pass us a set of gamma values to program. We actually only
- * use this for 8-bit mode so can't perform smooth fades on deeper modes,
- * but it's a requirement that we provide the function
- */
-static int cirrus_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green,
-				 u16 *blue, uint32_t size,
-				 struct drm_modeset_acquire_ctx *ctx)
-{
-	cirrus_crtc_load_lut(crtc);
-
-	return 0;
-}
-
-/* Simple cleanup function */
-static void cirrus_crtc_destroy(struct drm_crtc *crtc)
-{
-	struct cirrus_crtc *cirrus_crtc = to_cirrus_crtc(crtc);
-
-	drm_crtc_cleanup(crtc);
-	kfree(cirrus_crtc);
-}
-
-/* These provide the minimum set of functions required to handle a CRTC */
-static const struct drm_crtc_funcs cirrus_crtc_funcs = {
-	.gamma_set = cirrus_crtc_gamma_set,
-	.set_config = drm_crtc_helper_set_config,
-	.destroy = cirrus_crtc_destroy,
-};
-
-static const struct drm_crtc_helper_funcs cirrus_helper_funcs = {
-	.dpms = cirrus_crtc_dpms,
-	.mode_set = cirrus_crtc_mode_set,
-	.mode_set_base = cirrus_crtc_mode_set_base,
-	.prepare = cirrus_crtc_prepare,
-	.commit = cirrus_crtc_commit,
-};
-
-/* CRTC setup */
-static const uint32_t cirrus_formats_16[] = {
-	DRM_FORMAT_RGB565,
-};
-
-static const uint32_t cirrus_formats_24[] = {
-	DRM_FORMAT_RGB888,
-	DRM_FORMAT_RGB565,
-};
-
-static const uint32_t cirrus_formats_32[] = {
-	DRM_FORMAT_XRGB8888,
-	DRM_FORMAT_ARGB8888,
-	DRM_FORMAT_RGB888,
-	DRM_FORMAT_RGB565,
-};
-
-static struct drm_plane *cirrus_primary_plane(struct drm_device *dev)
-{
-	const uint32_t *formats;
-	uint32_t nformats;
-	struct drm_plane *primary;
-	int ret;
-
-	switch (cirrus_bpp) {
-	case 16:
-		formats = cirrus_formats_16;
-		nformats = ARRAY_SIZE(cirrus_formats_16);
-		break;
-	case 24:
-		formats = cirrus_formats_24;
-		nformats = ARRAY_SIZE(cirrus_formats_24);
-		break;
-	case 32:
-		formats = cirrus_formats_32;
-		nformats = ARRAY_SIZE(cirrus_formats_32);
-		break;
-	default:
-		return NULL;
-	}
-
-	primary = kzalloc(sizeof(*primary), GFP_KERNEL);
-	if (primary == NULL) {
-		DRM_DEBUG_KMS("Failed to allocate primary plane\n");
-		return NULL;
-	}
-
-	ret = drm_universal_plane_init(dev, primary, 0,
-				       &drm_primary_helper_funcs,
-				       formats, nformats,
-				       NULL,
-				       DRM_PLANE_TYPE_PRIMARY, NULL);
-	if (ret) {
-		kfree(primary);
-		primary = NULL;
-	}
-
-	return primary;
-}
-
-static void cirrus_crtc_init(struct drm_device *dev)
-{
-	struct cirrus_device *cdev = dev->dev_private;
-	struct cirrus_crtc *cirrus_crtc;
-	struct drm_plane *primary;
-
-	cirrus_crtc = kzalloc(sizeof(struct cirrus_crtc) +
-			      (CIRRUSFB_CONN_LIMIT * sizeof(struct drm_connector *)),
-			      GFP_KERNEL);
-
-	if (cirrus_crtc == NULL)
-		return;
-
-	primary = cirrus_primary_plane(dev);
-	if (primary == NULL) {
-		kfree(cirrus_crtc);
-		return;
-	}
-
-	drm_crtc_init_with_planes(dev, &cirrus_crtc->base,
-				  primary, NULL,
-				  &cirrus_crtc_funcs, NULL);
-
-	drm_mode_crtc_set_gamma_size(&cirrus_crtc->base, CIRRUS_LUT_SIZE);
-	cdev->mode_info.crtc = cirrus_crtc;
-
-	drm_crtc_helper_add(&cirrus_crtc->base, &cirrus_helper_funcs);
-}
-
-static void cirrus_encoder_mode_set(struct drm_encoder *encoder,
-				struct drm_display_mode *mode,
-				struct drm_display_mode *adjusted_mode)
-{
-}
-
-static void cirrus_encoder_dpms(struct drm_encoder *encoder, int state)
-{
-	return;
-}
-
-static void cirrus_encoder_prepare(struct drm_encoder *encoder)
-{
-}
-
-static void cirrus_encoder_commit(struct drm_encoder *encoder)
-{
-}
-
-static void cirrus_encoder_destroy(struct drm_encoder *encoder)
-{
-	struct cirrus_encoder *cirrus_encoder = to_cirrus_encoder(encoder);
-	drm_encoder_cleanup(encoder);
-	kfree(cirrus_encoder);
-}
-
-static const struct drm_encoder_helper_funcs cirrus_encoder_helper_funcs = {
-	.dpms = cirrus_encoder_dpms,
-	.mode_set = cirrus_encoder_mode_set,
-	.prepare = cirrus_encoder_prepare,
-	.commit = cirrus_encoder_commit,
-};
-
-static const struct drm_encoder_funcs cirrus_encoder_encoder_funcs = {
-	.destroy = cirrus_encoder_destroy,
-};
-
-static struct drm_encoder *cirrus_encoder_init(struct drm_device *dev)
-{
-	struct drm_encoder *encoder;
-	struct cirrus_encoder *cirrus_encoder;
-
-	cirrus_encoder = kzalloc(sizeof(struct cirrus_encoder), GFP_KERNEL);
-	if (!cirrus_encoder)
-		return NULL;
-
-	encoder = &cirrus_encoder->base;
-	encoder->possible_crtcs = 0x1;
-
-	drm_encoder_init(dev, encoder, &cirrus_encoder_encoder_funcs,
-			 DRM_MODE_ENCODER_DAC, NULL);
-	drm_encoder_helper_add(encoder, &cirrus_encoder_helper_funcs);
-
-	return encoder;
-}
-
-
-static int cirrus_vga_get_modes(struct drm_connector *connector)
-{
-	int count;
-
-	/* Just add a static list of modes */
-	if (cirrus_bpp <= 24) {
-		count = drm_add_modes_noedid(connector, 1280, 1024);
-		drm_set_preferred_mode(connector, 1024, 768);
-	} else {
-		count = drm_add_modes_noedid(connector, 800, 600);
-		drm_set_preferred_mode(connector, 800, 600);
-	}
-	return count;
-}
-
-static struct drm_encoder *cirrus_connector_best_encoder(struct drm_connector
-						  *connector)
-{
-	int enc_id = connector->encoder_ids[0];
-	/* pick the encoder ids */
-	if (enc_id)
-		return drm_encoder_find(connector->dev, NULL, enc_id);
-	return NULL;
-}
-
-static void cirrus_connector_destroy(struct drm_connector *connector)
-{
-	drm_connector_cleanup(connector);
-	kfree(connector);
-}
-
-static const struct drm_connector_helper_funcs cirrus_vga_connector_helper_funcs = {
-	.get_modes = cirrus_vga_get_modes,
-	.best_encoder = cirrus_connector_best_encoder,
-};
-
-static const struct drm_connector_funcs cirrus_vga_connector_funcs = {
-	.dpms = drm_helper_connector_dpms,
-	.fill_modes = drm_helper_probe_single_connector_modes,
-	.destroy = cirrus_connector_destroy,
-};
-
-static struct drm_connector *cirrus_vga_init(struct drm_device *dev)
-{
-	struct drm_connector *connector;
-	struct cirrus_connector *cirrus_connector;
-
-	cirrus_connector = kzalloc(sizeof(struct cirrus_connector), GFP_KERNEL);
-	if (!cirrus_connector)
-		return NULL;
-
-	connector = &cirrus_connector->base;
-
-	drm_connector_init(dev, connector,
-			   &cirrus_vga_connector_funcs, DRM_MODE_CONNECTOR_VGA);
-
-	drm_connector_helper_add(connector, &cirrus_vga_connector_helper_funcs);
-
-	drm_connector_register(connector);
-	return connector;
-}
-
-
-int cirrus_modeset_init(struct cirrus_device *cdev)
-{
-	struct drm_encoder *encoder;
-	struct drm_connector *connector;
-	int ret;
-
-	drm_mode_config_init(cdev->dev);
-
-	cdev->dev->mode_config.max_width = CIRRUS_MAX_FB_WIDTH;
-	cdev->dev->mode_config.max_height = CIRRUS_MAX_FB_HEIGHT;
-
-	cdev->dev->mode_config.fb_base = cdev->mc.vram_base;
-	cdev->dev->mode_config.preferred_depth = cirrus_bpp;
-	/* don't prefer a shadow on virt GPU */
-	cdev->dev->mode_config.prefer_shadow = 0;
-
-	cirrus_crtc_init(cdev->dev);
-
-	encoder = cirrus_encoder_init(cdev->dev);
-	if (!encoder) {
-		DRM_ERROR("cirrus_encoder_init failed\n");
-		return -1;
-	}
-
-	connector = cirrus_vga_init(cdev->dev);
-	if (!connector) {
-		DRM_ERROR("cirrus_vga_init failed\n");
-		return -1;
-	}
-
-	drm_connector_attach_encoder(connector, encoder);
-
-	ret = cirrus_fbdev_init(cdev);
-	if (ret) {
-		DRM_ERROR("cirrus_fbdev_init failed\n");
-		return ret;
-	}
-
-	return 0;
-}
-
-void cirrus_modeset_fini(struct cirrus_device *cdev)
-{
-	cirrus_fbdev_fini(cdev);
-	drm_helper_force_disable_all(cdev->dev);
-	drm_mode_config_cleanup(cdev->dev);
-}
diff --git a/drivers/gpu/drm/cirrus/cirrus_ttm.c b/drivers/gpu/drm/cirrus/cirrus_ttm.c
deleted file mode 100644
index e075810b4bd4..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_ttm.c
+++ /dev/null
@@ -1,343 +0,0 @@
-/*
- * Copyright 2012 Red Hat Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- */
-/*
- * Authors: Dave Airlie <airlied@redhat.com>
- */
-#include <drm/drmP.h>
-#include <drm/ttm/ttm_page_alloc.h>
-
-#include "cirrus_drv.h"
-
-static inline struct cirrus_device *
-cirrus_bdev(struct ttm_bo_device *bd)
-{
-	return container_of(bd, struct cirrus_device, ttm.bdev);
-}
-
-static void cirrus_bo_ttm_destroy(struct ttm_buffer_object *tbo)
-{
-	struct cirrus_bo *bo;
-
-	bo = container_of(tbo, struct cirrus_bo, bo);
-
-	drm_gem_object_release(&bo->gem);
-	kfree(bo);
-}
-
-static bool cirrus_ttm_bo_is_cirrus_bo(struct ttm_buffer_object *bo)
-{
-	if (bo->destroy == &cirrus_bo_ttm_destroy)
-		return true;
-	return false;
-}
-
-static int
-cirrus_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
-		     struct ttm_mem_type_manager *man)
-{
-	switch (type) {
-	case TTM_PL_SYSTEM:
-		man->flags = TTM_MEMTYPE_FLAG_MAPPABLE;
-		man->available_caching = TTM_PL_MASK_CACHING;
-		man->default_caching = TTM_PL_FLAG_CACHED;
-		break;
-	case TTM_PL_VRAM:
-		man->func = &ttm_bo_manager_func;
-		man->flags = TTM_MEMTYPE_FLAG_FIXED |
-			TTM_MEMTYPE_FLAG_MAPPABLE;
-		man->available_caching = TTM_PL_FLAG_UNCACHED |
-			TTM_PL_FLAG_WC;
-		man->default_caching = TTM_PL_FLAG_WC;
-		break;
-	default:
-		DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static void
-cirrus_bo_evict_flags(struct ttm_buffer_object *bo, struct ttm_placement *pl)
-{
-	struct cirrus_bo *cirrusbo = cirrus_bo(bo);
-
-	if (!cirrus_ttm_bo_is_cirrus_bo(bo))
-		return;
-
-	cirrus_ttm_placement(cirrusbo, TTM_PL_FLAG_SYSTEM);
-	*pl = cirrusbo->placement;
-}
-
-static int cirrus_bo_verify_access(struct ttm_buffer_object *bo, struct file *filp)
-{
-	struct cirrus_bo *cirrusbo = cirrus_bo(bo);
-
-	return drm_vma_node_verify_access(&cirrusbo->gem.vma_node,
-					  filp->private_data);
-}
-
-static int cirrus_ttm_io_mem_reserve(struct ttm_bo_device *bdev,
-				  struct ttm_mem_reg *mem)
-{
-	struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
-	struct cirrus_device *cirrus = cirrus_bdev(bdev);
-
-	mem->bus.addr = NULL;
-	mem->bus.offset = 0;
-	mem->bus.size = mem->num_pages << PAGE_SHIFT;
-	mem->bus.base = 0;
-	mem->bus.is_iomem = false;
-	if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE))
-		return -EINVAL;
-	switch (mem->mem_type) {
-	case TTM_PL_SYSTEM:
-		/* system memory */
-		return 0;
-	case TTM_PL_VRAM:
-		mem->bus.offset = mem->start << PAGE_SHIFT;
-		mem->bus.base = pci_resource_start(cirrus->dev->pdev, 0);
-		mem->bus.is_iomem = true;
-		break;
-	default:
-		return -EINVAL;
-		break;
-	}
-	return 0;
-}
-
-static void cirrus_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
-{
-}
-
-static void cirrus_ttm_backend_destroy(struct ttm_tt *tt)
-{
-	ttm_tt_fini(tt);
-	kfree(tt);
-}
-
-static struct ttm_backend_func cirrus_tt_backend_func = {
-	.destroy = &cirrus_ttm_backend_destroy,
-};
-
-
-static struct ttm_tt *cirrus_ttm_tt_create(struct ttm_buffer_object *bo,
-					   uint32_t page_flags)
-{
-	struct ttm_tt *tt;
-
-	tt = kzalloc(sizeof(struct ttm_tt), GFP_KERNEL);
-	if (tt == NULL)
-		return NULL;
-	tt->func = &cirrus_tt_backend_func;
-	if (ttm_tt_init(tt, bo, page_flags)) {
-		kfree(tt);
-		return NULL;
-	}
-	return tt;
-}
-
-struct ttm_bo_driver cirrus_bo_driver = {
-	.ttm_tt_create = cirrus_ttm_tt_create,
-	.init_mem_type = cirrus_bo_init_mem_type,
-	.eviction_valuable = ttm_bo_eviction_valuable,
-	.evict_flags = cirrus_bo_evict_flags,
-	.move = NULL,
-	.verify_access = cirrus_bo_verify_access,
-	.io_mem_reserve = &cirrus_ttm_io_mem_reserve,
-	.io_mem_free = &cirrus_ttm_io_mem_free,
-};
-
-int cirrus_mm_init(struct cirrus_device *cirrus)
-{
-	int ret;
-	struct drm_device *dev = cirrus->dev;
-	struct ttm_bo_device *bdev = &cirrus->ttm.bdev;
-
-	ret = ttm_bo_device_init(&cirrus->ttm.bdev,
-				 &cirrus_bo_driver,
-				 dev->anon_inode->i_mapping,
-				 DRM_FILE_PAGE_OFFSET,
-				 true);
-	if (ret) {
-		DRM_ERROR("Error initialising bo driver; %d\n", ret);
-		return ret;
-	}
-
-	ret = ttm_bo_init_mm(bdev, TTM_PL_VRAM,
-			     cirrus->mc.vram_size >> PAGE_SHIFT);
-	if (ret) {
-		DRM_ERROR("Failed ttm VRAM init: %d\n", ret);
-		return ret;
-	}
-
-	arch_io_reserve_memtype_wc(pci_resource_start(dev->pdev, 0),
-				   pci_resource_len(dev->pdev, 0));
-
-	cirrus->fb_mtrr = arch_phys_wc_add(pci_resource_start(dev->pdev, 0),
-					   pci_resource_len(dev->pdev, 0));
-
-	cirrus->mm_inited = true;
-	return 0;
-}
-
-void cirrus_mm_fini(struct cirrus_device *cirrus)
-{
-	struct drm_device *dev = cirrus->dev;
-
-	if (!cirrus->mm_inited)
-		return;
-
-	ttm_bo_device_release(&cirrus->ttm.bdev);
-
-	arch_phys_wc_del(cirrus->fb_mtrr);
-	cirrus->fb_mtrr = 0;
-	arch_io_free_memtype_wc(pci_resource_start(dev->pdev, 0),
-				pci_resource_len(dev->pdev, 0));
-}
-
-void cirrus_ttm_placement(struct cirrus_bo *bo, int domain)
-{
-	u32 c = 0;
-	unsigned i;
-	bo->placement.placement = bo->placements;
-	bo->placement.busy_placement = bo->placements;
-	if (domain & TTM_PL_FLAG_VRAM)
-		bo->placements[c++].flags = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED | TTM_PL_FLAG_VRAM;
-	if (domain & TTM_PL_FLAG_SYSTEM)
-		bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
-	if (!c)
-		bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
-	bo->placement.num_placement = c;
-	bo->placement.num_busy_placement = c;
-	for (i = 0; i < c; ++i) {
-		bo->placements[i].fpfn = 0;
-		bo->placements[i].lpfn = 0;
-	}
-}
-
-int cirrus_bo_create(struct drm_device *dev, int size, int align,
-		  uint32_t flags, struct cirrus_bo **pcirrusbo)
-{
-	struct cirrus_device *cirrus = dev->dev_private;
-	struct cirrus_bo *cirrusbo;
-	size_t acc_size;
-	int ret;
-
-	cirrusbo = kzalloc(sizeof(struct cirrus_bo), GFP_KERNEL);
-	if (!cirrusbo)
-		return -ENOMEM;
-
-	ret = drm_gem_object_init(dev, &cirrusbo->gem, size);
-	if (ret) {
-		kfree(cirrusbo);
-		return ret;
-	}
-
-	cirrusbo->bo.bdev = &cirrus->ttm.bdev;
-
-	cirrus_ttm_placement(cirrusbo, TTM_PL_FLAG_VRAM | TTM_PL_FLAG_SYSTEM);
-
-	acc_size = ttm_bo_dma_acc_size(&cirrus->ttm.bdev, size,
-				       sizeof(struct cirrus_bo));
-
-	ret = ttm_bo_init(&cirrus->ttm.bdev, &cirrusbo->bo, size,
-			  ttm_bo_type_device, &cirrusbo->placement,
-			  align >> PAGE_SHIFT, false, acc_size,
-			  NULL, NULL, cirrus_bo_ttm_destroy);
-	if (ret)
-		return ret;
-
-	*pcirrusbo = cirrusbo;
-	return 0;
-}
-
-static inline u64 cirrus_bo_gpu_offset(struct cirrus_bo *bo)
-{
-	return bo->bo.offset;
-}
-
-int cirrus_bo_pin(struct cirrus_bo *bo, u32 pl_flag, u64 *gpu_addr)
-{
-	struct ttm_operation_ctx ctx = { false, false };
-	int i, ret;
-
-	if (bo->pin_count) {
-		bo->pin_count++;
-		if (gpu_addr)
-			*gpu_addr = cirrus_bo_gpu_offset(bo);
-	}
-
-	cirrus_ttm_placement(bo, pl_flag);
-	for (i = 0; i < bo->placement.num_placement; i++)
-		bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
-	ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
-	if (ret)
-		return ret;
-
-	bo->pin_count = 1;
-	if (gpu_addr)
-		*gpu_addr = cirrus_bo_gpu_offset(bo);
-	return 0;
-}
-
-int cirrus_bo_push_sysram(struct cirrus_bo *bo)
-{
-	struct ttm_operation_ctx ctx = { false, false };
-	int i, ret;
-	if (!bo->pin_count) {
-		DRM_ERROR("unpin bad %p\n", bo);
-		return 0;
-	}
-	bo->pin_count--;
-	if (bo->pin_count)
-		return 0;
-
-	if (bo->kmap.virtual)
-		ttm_bo_kunmap(&bo->kmap);
-
-	cirrus_ttm_placement(bo, TTM_PL_FLAG_SYSTEM);
-	for (i = 0; i < bo->placement.num_placement ; i++)
-		bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
-
-	ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
-	if (ret) {
-		DRM_ERROR("pushing to VRAM failed\n");
-		return ret;
-	}
-	return 0;
-}
-
-int cirrus_mmap(struct file *filp, struct vm_area_struct *vma)
-{
-	struct drm_file *file_priv;
-	struct cirrus_device *cirrus;
-
-	if (unlikely(vma->vm_pgoff < DRM_FILE_PAGE_OFFSET))
-		return -EINVAL;
-
-	file_priv = filp->private_data;
-	cirrus = file_priv->minor->dev->dev_private;
-	return ttm_bo_mmap(filp, vma, &cirrus->ttm.bdev);
-}
diff --git a/drivers/gpu/drm/cirrus/Kconfig b/drivers/gpu/drm/cirrus/Kconfig
index fc78c90ee931..dd4f52a0bc1c 100644
--- a/drivers/gpu/drm/cirrus/Kconfig
+++ b/drivers/gpu/drm/cirrus/Kconfig
@@ -2,7 +2,7 @@ config DRM_CIRRUS_QEMU
 	tristate "Cirrus driver for QEMU emulated device"
 	depends on DRM && PCI && MMU
 	select DRM_KMS_HELPER
-	select DRM_TTM
+	select DRM_GEM_SHMEM_HELPER
 	help
 	 This is a KMS driver for emulated cirrus device in qemu.
 	 It is *NOT* intended for real cirrus devices. This requires
diff --git a/drivers/gpu/drm/cirrus/Makefile b/drivers/gpu/drm/cirrus/Makefile
index 919c0a336c97..acf8971d37a1 100644
--- a/drivers/gpu/drm/cirrus/Makefile
+++ b/drivers/gpu/drm/cirrus/Makefile
@@ -1,4 +1 @@
-cirrus-y  := cirrus_main.o cirrus_mode.o \
-	cirrus_drv.o cirrus_fbdev.o cirrus_ttm.o
-
 obj-$(CONFIG_DRM_CIRRUS_QEMU) += cirrus.o
-- 
2.18.1


From mboxrd@z Thu Jan  1 00:00:00 1970
From: Gerd Hoffmann <kraxel@redhat.com>
Subject: [PATCH v2 6/6] drm/cirrus: rewrite and modernize driver.
Date: Thu,  4 Apr 2019 17:24:30 +0200
Message-ID: <20190404152430.8263-7-kraxel@redhat.com>
References: <20190404152430.8263-1-kraxel@redhat.com>
Mime-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Return-path: <dri-devel-bounces@lists.freedesktop.org>
Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28])
 by gabe.freedesktop.org (Postfix) with ESMTPS id 3E64A6EA12
 for <dri-devel@lists.freedesktop.org>; Thu,  4 Apr 2019 15:24:36 +0000 (UTC)
In-Reply-To: <20190404152430.8263-1-kraxel@redhat.com>
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
To: dri-devel@lists.freedesktop.org
Cc: David Airlie <airlied@linux.ie>, open list <linux-kernel@vger.kernel.org>, "open list:DRM DRIVER FOR QEMU'S CIRRUS DEVICE" <virtualization@lists.linux-foundation.org>, Gerd Hoffmann <kraxel@redhat.com>, Dave Airlie <airlied@redhat.com>
List-Id: dri-devel@lists.freedesktop.org
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