Re: [RFC] drm: Add Grain Media GM12U320 kms driver

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Thu, Jun 01, 2017 at 01:59:34PM +0200, Hans de Goede wrote:
> Grain-media GM12U320 based devices are mini video projectors using USB for
> both power and video data transport.
> 
> This commit adds a kms driver for these devices, including prime support.
> 
> This driver is based on the existing udl kms driver, and the gm12u320
> fb driver by Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>.
> 
> Signed-off-by: Hans de Goede <hdegoede@xxxxxxxxxx>

Looks like something written yesterday (drm changes fast), bunch of
comments below where you need to modernize your driver. Should result in
piles of code removed.

Cheers, Daniel

> ---
>  MAINTAINERS                                   |   6 +
>  drivers/gpu/drm/Kconfig                       |   2 +
>  drivers/gpu/drm/Makefile                      |   1 +
>  drivers/gpu/drm/gm12u320/Kconfig              |  11 +
>  drivers/gpu/drm/gm12u320/Makefile             |   7 +
>  drivers/gpu/drm/gm12u320/gm12u320_connector.c | 148 ++++++++
>  drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c    | 283 ++++++++++++++
>  drivers/gpu/drm/gm12u320/gm12u320_drv.c       | 157 ++++++++
>  drivers/gpu/drm/gm12u320/gm12u320_drv.h       | 129 +++++++
>  drivers/gpu/drm/gm12u320/gm12u320_encoder.c   |  75 ++++
>  drivers/gpu/drm/gm12u320/gm12u320_fb.c        | 343 +++++++++++++++++
>  drivers/gpu/drm/gm12u320/gm12u320_gem.c       | 237 ++++++++++++
>  drivers/gpu/drm/gm12u320/gm12u320_main.c      | 506 ++++++++++++++++++++++++++
>  drivers/gpu/drm/gm12u320/gm12u320_modeset.c   | 143 ++++++++
>  14 files changed, 2048 insertions(+)
>  create mode 100644 drivers/gpu/drm/gm12u320/Kconfig
>  create mode 100644 drivers/gpu/drm/gm12u320/Makefile
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_connector.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_drv.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_drv.h
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_encoder.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_fb.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_gem.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_main.c
>  create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_modeset.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 053c3bdd1fe5..e1973afc428a 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -4423,6 +4423,12 @@ S:	Supported
>  F:	drivers/gpu/drm/nouveau/
>  F:	include/uapi/drm/nouveau_drm.h
>  
> +DRM DRIVERS FOR GRAIN-MEDIA GM12U320
> +M:	Hans de Goede <hdegoede@xxxxxxxxxx>
> +L:	dri-devel@xxxxxxxxxxxxxxxxxxxxx
> +S:	Supported
> +F:	drivers/gpu/drm/gm12u320/
> +
>  DRM DRIVERS FOR NVIDIA TEGRA
>  M:	Thierry Reding <thierry.reding@xxxxxxxxx>
>  L:	dri-devel@xxxxxxxxxxxxxxxxxxxxx
> diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
> index 78d7fc0ebb57..46898c4dd0d6 100644
> --- a/drivers/gpu/drm/Kconfig
> +++ b/drivers/gpu/drm/Kconfig
> @@ -274,6 +274,8 @@ source "drivers/gpu/drm/meson/Kconfig"
>  
>  source "drivers/gpu/drm/tinydrm/Kconfig"
>  
> +source "drivers/gpu/drm/gm12u320/Kconfig"
> +
>  # Keep legacy drivers last
>  
>  menuconfig DRM_LEGACY
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 59f0f9b696eb..cdec41c52e91 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -96,3 +96,4 @@ obj-y			+= hisilicon/
>  obj-$(CONFIG_DRM_ZTE)	+= zte/
>  obj-$(CONFIG_DRM_MXSFB)	+= mxsfb/
>  obj-$(CONFIG_DRM_TINYDRM) += tinydrm/
> +obj-$(CONFIG_DRM_GM12U320) += gm12u320/
> diff --git a/drivers/gpu/drm/gm12u320/Kconfig b/drivers/gpu/drm/gm12u320/Kconfig
> new file mode 100644
> index 000000000000..67274cb291ed
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/Kconfig
> @@ -0,0 +1,11 @@
> +config DRM_GM12U320
> +	tristate "Grain Media GM12U320 based mini projectors"
> +	depends on DRM
> +	depends on USB_SUPPORT
> +	depends on USB_ARCH_HAS_HCD
> +	select USB
> +	select DRM_KMS_HELPER
> +	help
> +	  This is a KMS driver for Grain Media GM12U320 based usb mini video
> +	  projectors, such as the Acer C120.
> +	  Say M/Y to add support for these devices via drm/kms interfaces.
> diff --git a/drivers/gpu/drm/gm12u320/Makefile b/drivers/gpu/drm/gm12u320/Makefile
> new file mode 100644
> index 000000000000..6234473967b2
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/Makefile
> @@ -0,0 +1,7 @@
> +ccflags-y := -Iinclude/drm
> +
> +gm12u320-y :=	gm12u320_drv.o gm12u320_modeset.o gm12u320_connector.o \
> +		gm12u320_encoder.o gm12u320_main.o gm12u320_fb.o \
> +		gm12u320_gem.o gm12u320_dmabuf.o
> +
> +obj-$(CONFIG_DRM_GM12U320) += gm12u320.o
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_connector.c b/drivers/gpu/drm/gm12u320/gm12u320_connector.c
> new file mode 100644
> index 000000000000..042da07c16c2
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_connector.c
> @@ -0,0 +1,148 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver:
> + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>
> + * Copyright (C) 2009 Roberto De Ioris <roberto@xxxxxxxx>
> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@xxxxxxxxx>
> + * Copyright (C) 2009 Bernie Thompson <bernie@xxxxxxxxxxxx>
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_edid.h>
> +#include <drm/drm_crtc_helper.h>
> +#include "gm12u320_drv.h"
> +
> +/*
> + * Note this assumes this driver is only ever used with the Acer C120, if we
> + * add support for other devices the vendor and model should be parameterized.
> + */
> +static struct edid gm12u320_edid = {
> +	.header		= { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 },
> +	.mfg_id		= { 0x04, 0x72 },	/* "ACR" */
> +	.prod_code	= { 0x20, 0xc1 },	/* C120h */
> +	.mfg_week	= 1,
> +	.mfg_year	= 1,
> +	.version	= 1,			/* EDID 1.3 */
> +	.revision	= 3,			/* EDID 1.3 */
> +	.input		= 0x80,			/* Digital input */
> +	.features	= 0x02,			/* Pref timing in DTD 1 */
> +	.standard_timings = { { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
> +			      { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 } },
> +	.detailed_timings = { {
> +		.pixel_clock = 3383,
> +		/* hactive = 852, hblank = 256 */
> +		.data.pixel_data.hactive_lo = 0x54,
> +		.data.pixel_data.hblank_lo = 0x00,
> +		.data.pixel_data.hactive_hblank_hi = 0x31,
> +		/* vactive = 480, vblank = 28 */
> +		.data.pixel_data.vactive_lo = 0xe0,
> +		.data.pixel_data.vblank_lo = 0x1c,
> +		.data.pixel_data.vactive_vblank_hi = 0x10,
> +		/* hsync offset 40 pw 128, vsync offset 1 pw 4 */
> +		.data.pixel_data.hsync_offset_lo = 0x28,
> +		.data.pixel_data.hsync_pulse_width_lo = 0x80,
> +		.data.pixel_data.vsync_offset_pulse_width_lo = 0x14,
> +		.data.pixel_data.hsync_vsync_offset_pulse_width_hi = 0x00,
> +		/* Digital separate syncs, hsync+, vsync+ */
> +		.data.pixel_data.misc = 0x1e,
> +	}, {
> +		.pixel_clock = 0,
> +		.data.other_data.type = 0xfd, /* Monitor ranges */
> +		.data.other_data.data.range.min_vfreq = 59,
> +		.data.other_data.data.range.max_vfreq = 61,
> +		.data.other_data.data.range.min_hfreq_khz = 29,
> +		.data.other_data.data.range.max_hfreq_khz = 32,
> +		.data.other_data.data.range.pixel_clock_mhz = 4, /* 40 MHz */
> +		.data.other_data.data.range.flags = 0,
> +		.data.other_data.data.range.formula.cvt = {
> +			0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
> +	}, {
> +		.pixel_clock = 0,
> +		.data.other_data.type = 0xfc, /* Model string */
> +		.data.other_data.data.str.str = {
> +			'C', '1', '2', '0', 'P', 'r', 'o', 'j', 'e', 'c',
> +			't', 'o', 'r' },
> +	}, {
> +		.pixel_clock = 0,
> +		.data.other_data.type = 0xfe, /* Unspecified text / padding */
> +		.data.other_data.data.str.str = {
> +			'\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
> +			' ', ' ',  ' ' },
> +	} },
> +	.checksum = 0x40,
> +};
> +
> +static int gm12u320_get_modes(struct drm_connector *connector)
> +{
> +	drm_mode_connector_update_edid_property(connector, &gm12u320_edid);
> +	return drm_add_edid_modes(connector, &gm12u320_edid);
> +}
> +
> +static enum drm_connector_status
> +gm12u320_detect(struct drm_connector *connector, bool force)
> +{
> +	if (drm_device_is_unplugged(connector->dev))
> +		return connector_status_disconnected;
> +
> +	return connector_status_connected;
> +}
> +
> +static struct drm_encoder*
> +gm12u320_best_single_encoder(struct drm_connector *connector)
> +{
> +	int enc_id = connector->encoder_ids[0];
> +
> +	return drm_encoder_find(connector->dev, enc_id);
> +}
> +
> +static int gm12u320_connector_set_property(struct drm_connector *connector,
> +					   struct drm_property *property,
> +					   uint64_t val)
> +{
> +	return 0;
> +}
> +
> +static void gm12u320_connector_destroy(struct drm_connector *connector)
> +{
> +	drm_connector_unregister(connector);
> +	drm_connector_cleanup(connector);
> +	kfree(connector);
> +}
> +
> +static const struct drm_connector_helper_funcs gm12u320_helper_funcs = {
> +	.get_modes = gm12u320_get_modes,
> +	.best_encoder = gm12u320_best_single_encoder,
> +};
> +
> +static const struct drm_connector_funcs gm12u320_connector_funcs = {
> +	.dpms = drm_helper_connector_dpms,
> +	.detect = gm12u320_detect,
> +	.fill_modes = drm_helper_probe_single_connector_modes,
> +	.destroy = gm12u320_connector_destroy,
> +	.set_property = gm12u320_connector_set_property,
> +};
> +
> +int gm12u320_connector_init(struct drm_device *dev,
> +			    struct drm_encoder *encoder)
> +{
> +	struct drm_connector *connector;
> +
> +	connector = kzalloc(sizeof(struct drm_connector), GFP_KERNEL);
> +	if (!connector)
> +		return -ENOMEM;
> +
> +	drm_connector_init(dev, connector, &gm12u320_connector_funcs,
> +			   DRM_MODE_CONNECTOR_Unknown);
> +	drm_connector_helper_add(connector, &gm12u320_helper_funcs);
> +
> +	drm_connector_register(connector);
> +	drm_mode_connector_attach_encoder(connector, encoder);
> +
> +	return 0;
> +}
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c b/drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c
> new file mode 100644
> index 000000000000..b55861e8323c
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c
> @@ -0,0 +1,283 @@
> +/*
> + * Based on the udl dmabuf code:
> + *
> + * Copyright (c) 2014 The Chromium OS Authors
> + *
> + * This program is free software; you can redistribute  it and/or modify it
> + * under  the terms of  the GNU General  Public License as published by the
> + * Free Software Foundation;  either version 2 of the  License, or (at your
> + * option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program. If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <drm/drmP.h>
> +#include "gm12u320_drv.h"
> +#include <linux/shmem_fs.h>
> +#include <linux/dma-buf.h>
> +
> +struct gm12u320_drm_dmabuf_attachment {
> +	struct sg_table sgt;
> +	enum dma_data_direction dir;
> +	bool is_mapped;
> +};
> +
> +static int gm12u320_attach_dma_buf(struct dma_buf *dmabuf,
> +				   struct device *dev,
> +				   struct dma_buf_attachment *attach)
> +{
> +	struct gm12u320_drm_dmabuf_attachment *gm12u320_attach;
> +
> +	DRM_DEBUG_PRIME("[DEV:%s] size:%zd\n", dev_name(attach->dev),
> +			attach->dmabuf->size);
> +
> +	gm12u320_attach = kzalloc(sizeof(*gm12u320_attach), GFP_KERNEL);
> +	if (!gm12u320_attach)
> +		return -ENOMEM;
> +
> +	gm12u320_attach->dir = DMA_NONE;
> +	attach->priv = gm12u320_attach;
> +
> +	return 0;
> +}
> +
> +static void gm12u320_detach_dma_buf(struct dma_buf *dmabuf,
> +				    struct dma_buf_attachment *attach)
> +{
> +	struct gm12u320_drm_dmabuf_attachment *gm12u320_attach = attach->priv;
> +	struct sg_table *sgt;
> +
> +	if (!gm12u320_attach)
> +		return;
> +
> +	DRM_DEBUG_PRIME("[DEV:%s] size:%zd\n", dev_name(attach->dev),
> +			attach->dmabuf->size);
> +
> +	sgt = &gm12u320_attach->sgt;
> +
> +	if (gm12u320_attach->dir != DMA_NONE)
> +		dma_unmap_sg(attach->dev, sgt->sgl, sgt->nents,
> +				gm12u320_attach->dir);
> +
> +	sg_free_table(sgt);
> +	kfree(gm12u320_attach);
> +	attach->priv = NULL;
> +}
> +
> +static struct sg_table *gm12u320_map_dma_buf(struct dma_buf_attachment *attach,
> +					     enum dma_data_direction dir)
> +{
> +	struct gm12u320_drm_dmabuf_attachment *gm12u320_attach = attach->priv;
> +	struct gm12u320_gem_object *obj = to_gm12u320_bo(attach->dmabuf->priv);
> +	struct drm_device *dev = obj->base.dev;
> +	struct scatterlist *rd, *wr;
> +	struct sg_table *sgt = NULL;
> +	unsigned int i;
> +	int page_count;
> +	int nents, ret;
> +
> +	DRM_DEBUG_PRIME("[DEV:%s] size:%zd dir=%d\n", dev_name(attach->dev),
> +			attach->dmabuf->size, dir);
> +
> +	/* just return current sgt if already requested. */
> +	if (gm12u320_attach->dir == dir && gm12u320_attach->is_mapped)
> +		return &gm12u320_attach->sgt;
> +
> +	if (!obj->pages) {
> +		ret = gm12u320_gem_get_pages(obj);
> +		if (ret) {
> +			DRM_ERROR("failed to map pages.\n");
> +			return ERR_PTR(ret);
> +		}
> +	}
> +
> +	page_count = obj->base.size / PAGE_SIZE;
> +	obj->sg = drm_prime_pages_to_sg(obj->pages, page_count);
> +	if (IS_ERR(obj->sg)) {
> +		DRM_ERROR("failed to allocate sgt.\n");
> +		return ERR_CAST(obj->sg);
> +	}
> +
> +	sgt = &gm12u320_attach->sgt;
> +
> +	ret = sg_alloc_table(sgt, obj->sg->orig_nents, GFP_KERNEL);
> +	if (ret) {
> +		DRM_ERROR("failed to alloc sgt.\n");
> +		return ERR_PTR(-ENOMEM);
> +	}
> +
> +	mutex_lock(&dev->struct_mutex);
> +
> +	rd = obj->sg->sgl;
> +	wr = sgt->sgl;
> +	for (i = 0; i < sgt->orig_nents; ++i) {
> +		sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
> +		rd = sg_next(rd);
> +		wr = sg_next(wr);
> +	}
> +
> +	if (dir != DMA_NONE) {
> +		nents = dma_map_sg(attach->dev, sgt->sgl, sgt->orig_nents, dir);
> +		if (!nents) {
> +			DRM_ERROR("failed to map sgl with iommu.\n");
> +			sg_free_table(sgt);
> +			sgt = ERR_PTR(-EIO);
> +			goto err_unlock;
> +		}
> +	}
> +
> +	gm12u320_attach->is_mapped = true;
> +	gm12u320_attach->dir = dir;
> +	attach->priv = gm12u320_attach;
> +
> +err_unlock:
> +	mutex_unlock(&dev->struct_mutex);
> +	return sgt;
> +}
> +
> +static void gm12u320_unmap_dma_buf(struct dma_buf_attachment *attach,
> +				   struct sg_table *sgt,
> +				   enum dma_data_direction dir)
> +{
> +	/* Nothing to do. */
> +	DRM_DEBUG_PRIME("[DEV:%s] size:%zd dir:%d\n", dev_name(attach->dev),
> +			attach->dmabuf->size, dir);
> +}
> +
> +static void *gm12u320_dmabuf_kmap(struct dma_buf *dma_buf,
> +				  unsigned long page_num)
> +{
> +	/* TODO */
> +
> +	return NULL;
> +}
> +
> +static void *gm12u320_dmabuf_kmap_atomic(struct dma_buf *dma_buf,
> +					 unsigned long page_num)
> +{
> +	/* TODO */
> +
> +	return NULL;
> +}
> +
> +static void gm12u320_dmabuf_kunmap(struct dma_buf *dma_buf,
> +				   unsigned long page_num, void *addr)
> +{
> +	/* TODO */
> +}
> +
> +static void gm12u320_dmabuf_kunmap_atomic(struct dma_buf *dma_buf,
> +					  unsigned long page_num,
> +					  void *addr)
> +{
> +	/* TODO */
> +}
> +
> +static int gm12u320_dmabuf_mmap(struct dma_buf *dma_buf,
> +				struct vm_area_struct *vma)
> +{
> +	/* TODO */
> +
> +	return -EINVAL;
> +}

I'm not a friend of dummy functions and todos. The core should reject this
all correctly for you, please remove these hooks. Or fix up the core to do
that for you.

> +static struct dma_buf_ops gm12u320_dmabuf_ops = {
> +	.attach			= gm12u320_attach_dma_buf,
> +	.detach			= gm12u320_detach_dma_buf,
> +	.map_dma_buf		= gm12u320_map_dma_buf,
> +	.unmap_dma_buf		= gm12u320_unmap_dma_buf,
> +	.map			= gm12u320_dmabuf_kmap,
> +	.map_atomic		= gm12u320_dmabuf_kmap_atomic,
> +	.unmap			= gm12u320_dmabuf_kunmap,
> +	.unmap_atomic		= gm12u320_dmabuf_kunmap_atomic,
> +	.mmap			= gm12u320_dmabuf_mmap,
> +	.release		= drm_gem_dmabuf_release,
> +};
> +
> +struct dma_buf *gm12u320_gem_prime_export(struct drm_device *dev,
> +				     struct drm_gem_object *obj, int flags)
> +{
> +	DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
> +
> +	exp_info.ops = &gm12u320_dmabuf_ops;
> +	exp_info.size = obj->size;
> +	exp_info.flags = flags;
> +	exp_info.priv = obj;
> +
> +	return drm_gem_dmabuf_export(dev, &exp_info);
> +}
> +
> +static int gm12u320_prime_create(struct drm_device *dev,
> +				 size_t size, struct sg_table *sg,
> +				 struct gm12u320_gem_object **obj_p)
> +{
> +	struct gm12u320_gem_object *obj;
> +	int npages;
> +
> +	npages = size / PAGE_SIZE;
> +
> +	*obj_p = NULL;
> +	obj = gm12u320_gem_alloc_object(dev, npages * PAGE_SIZE);
> +	if (!obj)
> +		return -ENOMEM;
> +
> +	obj->sg = sg;
> +	obj->pages = drm_malloc_ab(npages, sizeof(struct page *));
> +	if (obj->pages == NULL) {
> +		DRM_ERROR("obj pages is NULL %d\n", npages);
> +		return -ENOMEM;
> +	}
> +
> +	drm_prime_sg_to_page_addr_arrays(sg, obj->pages, NULL, npages);
> +
> +	*obj_p = obj;
> +	return 0;
> +}
> +
> +struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev,
> +						 struct dma_buf *dma_buf)
> +{
> +	struct dma_buf_attachment *attach;
> +	struct sg_table *sg;
> +	struct gm12u320_gem_object *uobj;
> +	int ret;
> +
> +	/* need to attach */
> +	get_device(dev->dev);
> +	attach = dma_buf_attach(dma_buf, dev->dev);
> +	if (IS_ERR(attach)) {
> +		put_device(dev->dev);
> +		return ERR_CAST(attach);
> +	}
> +
> +	get_dma_buf(dma_buf);
> +
> +	sg = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
> +	if (IS_ERR(sg)) {
> +		ret = PTR_ERR(sg);
> +		goto fail_detach;
> +	}
> +
> +	ret = gm12u320_prime_create(dev, dma_buf->size, sg, &uobj);
> +	if (ret)
> +		goto fail_unmap;
> +
> +	uobj->base.import_attach = attach;
> +	uobj->flags = GM12U320_BO_WC;
> +
> +	return &uobj->base;
> +
> +fail_unmap:
> +	dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
> +fail_detach:
> +	dma_buf_detach(dma_buf, attach);
> +	dma_buf_put(dma_buf);
> +	put_device(dev->dev);
> +	return ERR_PTR(ret);
> +}

Not sure, but is there some room for more shared helpers for non-cma gem
objects when using prime? For cma this is all dead easy, but we now also
have a pile of simple shmem-gem drivers that would justify a bit more
helpers here I think ...

Can be a follow-up thing ofc.

> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_drv.c b/drivers/gpu/drm/gm12u320/gm12u320_drv.c
> new file mode 100644
> index 000000000000..eb1e52a9b485
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_drv.c
> @@ -0,0 +1,157 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#include <linux/module.h>
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc_helper.h>
> +#include "gm12u320_drv.h"
> +
> +static int gm12u320_driver_set_busid(struct drm_device *d, struct drm_master *m)
> +{
> +	return 0;
> +}

This just died.

> +
> +static const struct vm_operations_struct gm12u320_gem_vm_ops = {
> +	.fault = gm12u320_gem_fault,
> +	.open = drm_gem_vm_open,
> +	.close = drm_gem_vm_close,
> +};
> +
> +static const struct file_operations gm12u320_driver_fops = {
> +	.owner = THIS_MODULE,
> +	.open = drm_open,
> +	.mmap = gm12u320_drm_gem_mmap,
> +	.poll = drm_poll,
> +	.read = drm_read,
> +	.unlocked_ioctl	= drm_ioctl,
> +	.release = drm_release,
> +	.compat_ioctl = drm_compat_ioctl,
> +	.llseek = noop_llseek,
> +};
> +
> +static struct drm_driver driver = {
> +	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
> +	.load = gm12u320_driver_load,
> +	.unload = gm12u320_driver_unload,

load/unload are deprecated, pls read the kerneldoc for how this should be
done using drm_dev_init and friends.

> +	.set_busid = gm12u320_driver_set_busid,
> +
> +	/* gem hooks */
> +	.gem_free_object = gm12u320_gem_free_object,
> +	.gem_vm_ops = &gm12u320_gem_vm_ops,
> +
> +	.dumb_create = gm12u320_dumb_create,
> +	.dumb_map_offset = gm12u320_gem_mmap,
> +	.dumb_destroy = drm_gem_dumb_destroy,
> +	.fops = &gm12u320_driver_fops,
> +
> +	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
> +	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
> +	.gem_prime_export = gm12u320_gem_prime_export,
> +	.gem_prime_import = gm12u320_gem_prime_import,
> +
> +	.name = DRIVER_NAME,
> +	.desc = DRIVER_DESC,
> +	.date = DRIVER_DATE,
> +	.major = DRIVER_MAJOR,
> +	.minor = DRIVER_MINOR,
> +	.patchlevel = DRIVER_PATCHLEVEL,
> +};
> +
> +static int gm12u320_usb_probe(struct usb_interface *interface,
> +			      const struct usb_device_id *id)
> +{
> +	struct usb_device *udev = interface_to_usbdev(interface);
> +	struct drm_device *dev;
> +	int r;
> +
> +	/*
> +	 * The gm12u320 presents itself to the system as 2 usb mass-storage
> +	 * interfaces, for the second one we proceed successully with binding,
> +	 * but otherwise ignore it.
> +	 */
> +	if (interface->cur_altsetting->desc.bInterfaceNumber != 0)
> +		return 0;
> +
> +	dev = drm_dev_alloc(&driver, &interface->dev);
> +	if (IS_ERR(dev))
> +		return PTR_ERR(dev);
> +
> +	r = drm_dev_register(dev, (unsigned long)udev);
> +	if (r)
> +		goto err_free;
> +
> +	usb_set_intfdata(interface, dev);
> +	DRM_INFO("Initialized gm12u320 on minor %d\n", dev->primary->index);
> +
> +	return 0;
> +
> +err_free:
> +	drm_dev_unref(dev);
> +	return r;
> +}
> +
> +static void gm12u320_usb_disconnect(struct usb_interface *interface)
> +{
> +	struct drm_device *dev = usb_get_intfdata(interface);
> +
> +	if (!dev)
> +		return;
> +
> +	drm_kms_helper_poll_disable(dev);
> +	gm12u320_fbdev_unplug(dev);
> +	gm12u320_stop_fb_update(dev);
> +	drm_unplug_dev(dev);
> +}
> +
> +#ifdef CONFIG_PM
> +
> +int gm12u320_suspend(struct usb_interface *interface, pm_message_t message)
> +{
> +	struct drm_device *dev = usb_get_intfdata(interface);
> +
> +	if (!dev)
> +		return 0;
> +
> +	gm12u320_stop_fb_update(dev);
> +	return 0;
> +}
> +
> +int gm12u320_resume(struct usb_interface *interface)
> +{
> +	struct drm_device *dev = usb_get_intfdata(interface);
> +
> +	if (!dev)
> +		return 0;
> +
> +	gm12u320_set_ecomode(dev);
> +	gm12u320_start_fb_update(dev);
> +	return 0;
> +}
> +#endif
> +
> +static struct usb_device_id id_table[] = {
> +	{ USB_DEVICE(0x1de1, 0xc102) },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(usb, id_table);
> +
> +static struct usb_driver gm12u320_driver = {
> +	.name = "gm12u320",
> +	.probe = gm12u320_usb_probe,
> +	.disconnect = gm12u320_usb_disconnect,
> +	.id_table = id_table,
> +#ifdef CONFIG_PM
> +	.suspend = gm12u320_suspend,
> +	.resume = gm12u320_resume,
> +	.reset_resume = gm12u320_resume,
> +#endif
> +};
> +
> +module_usb_driver(gm12u320_driver);
> +MODULE_AUTHOR("Hans de Goede <hdegoede@xxxxxxxxxx>");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_drv.h b/drivers/gpu/drm/gm12u320/gm12u320_drv.h
> new file mode 100644
> index 000000000000..8955a2ad753a
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_drv.h
> @@ -0,0 +1,129 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver:
> + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>
> + * Copyright (C) 2009 Roberto De Ioris <roberto@xxxxxxxx>
> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@xxxxxxxxx>
> + * Copyright (C) 2009 Bernie Thompson <bernie@xxxxxxxxxxxx>
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#ifndef GM12U320_DRV_H
> +#define GM12U320_DRV_H
> +
> +#include <linux/usb.h>
> +#include <linux/spinlock.h>
> +#include <drm/drm_gem.h>
> +
> +#define DRIVER_NAME		"gm12u320"
> +#define DRIVER_DESC		"Grain Media GM12U320 USB projector display"
> +#define DRIVER_DATE		"20150107"
> +
> +#define DRIVER_MAJOR		0
> +#define DRIVER_MINOR		0
> +#define DRIVER_PATCHLEVEL	1
> +
> +#define GM12U320_BO_CACHEABLE	(1 << 0)
> +#define GM12U320_BO_WC		(1 << 1)
> +
> +/*
> + * The DLP has an actual width of 854 pixels, but that is not a multiple
> + * of 4, breaking things left and right, so we export a width of 852.
> + */
> +#define GM12U320_USER_WIDTH	852
> +#define GM12U320_REAL_WIDTH	854
> +#define GM12U320_HEIGHT		480
> +
> +#define GM12U320_BLOCK_COUNT	20
> +
> +struct gm12u320_device;
> +
> +struct gm12u320_fbdev;
> +
> +struct gm12u320_device {
> +	struct device *dev;
> +	struct usb_device *udev;
> +	struct drm_device *ddev;
> +	struct gm12u320_fbdev *fbdev;
> +	unsigned char *cmd_buf;
> +	unsigned char *data_buf[GM12U320_BLOCK_COUNT];
> +	struct {
> +		bool run;
> +		struct workqueue_struct *workq;
> +		struct work_struct work;
> +		wait_queue_head_t waitq;
> +		struct mutex lock;
> +		struct gm12u320_framebuffer *fb;
> +		int x1;
> +		int x2;
> +		int y1;
> +		int y2;
> +	} fb_update;
> +};
> +
> +struct gm12u320_gem_object {
> +	struct drm_gem_object base;
> +	struct page **pages;
> +	void *vmapping;
> +	struct sg_table *sg;
> +	unsigned int flags;
> +};
> +
> +#define to_gm12u320_bo(x) container_of(x, struct gm12u320_gem_object, base)
> +
> +struct gm12u320_framebuffer {
> +	struct drm_framebuffer base;
> +	struct gm12u320_gem_object *obj;
> +};
> +
> +#define to_gm12u320_fb(x) container_of(x, struct gm12u320_framebuffer, base)
> +
> +/* modeset */
> +int gm12u320_modeset_init(struct drm_device *dev);
> +void gm12u320_modeset_cleanup(struct drm_device *dev);
> +int gm12u320_connector_init(struct drm_device *dev,
> +			    struct drm_encoder *encoder);
> +
> +struct drm_encoder *gm12u320_encoder_init(struct drm_device *dev);
> +
> +int gm12u320_driver_load(struct drm_device *dev, unsigned long flags);
> +void gm12u320_driver_unload(struct drm_device *dev);
> +
> +int gm12u320_fbdev_init(struct drm_device *dev);
> +void gm12u320_fbdev_cleanup(struct drm_device *dev);
> +void gm12u320_fbdev_unplug(struct drm_device *dev);
> +struct drm_framebuffer *
> +gm12u320_fb_user_fb_create(struct drm_device *dev, struct drm_file *file,
> +			   const struct drm_mode_fb_cmd2 *mode_cmd);
> +
> +int gm12u320_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
> +			 struct drm_mode_create_dumb *args);
> +int gm12u320_gem_mmap(struct drm_file *file_priv, struct drm_device *dev,
> +		      uint32_t handle, uint64_t *offset);
> +
> +struct gm12u320_gem_object *
> +gm12u320_gem_alloc_object(struct drm_device *dev, size_t size);
> +void gm12u320_gem_free_object(struct drm_gem_object *gem_obj);
> +struct dma_buf *gm12u320_gem_prime_export(struct drm_device *dev,
> +				      struct drm_gem_object *obj, int flags);
> +struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev,
> +						 struct dma_buf *dma_buf);
> +
> +int gm12u320_gem_get_pages(struct gm12u320_gem_object *obj);
> +void gm12u320_gem_put_pages(struct gm12u320_gem_object *obj);
> +int gm12u320_gem_vmap(struct gm12u320_gem_object *obj);
> +void gm12u320_gem_vunmap(struct gm12u320_gem_object *obj);
> +int gm12u320_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
> +int gm12u320_gem_fault(struct vm_fault *vmf);
> +
> +void gm12u320_fb_mark_dirty(struct gm12u320_framebuffer *fb,
> +			    int x1, int x2, int y1, int y2);
> +void gm12u320_start_fb_update(struct drm_device *dev);
> +void gm12u320_stop_fb_update(struct drm_device *dev);
> +int gm12u320_set_ecomode(struct drm_device *dev);
> +
> +#endif
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_encoder.c b/drivers/gpu/drm/gm12u320/gm12u320_encoder.c
> new file mode 100644
> index 000000000000..085f05b06674
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_encoder.c
> @@ -0,0 +1,75 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver:
> + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>
> + * Copyright (C) 2009 Roberto De Ioris <roberto@xxxxxxxx>
> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@xxxxxxxxx>
> + * Copyright (C) 2009 Bernie Thompson <bernie@xxxxxxxxxxxx>
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_crtc_helper.h>
> +#include "gm12u320_drv.h"
> +
> +/* dummy encoder */
> +static void gm12u320_enc_destroy(struct drm_encoder *encoder)
> +{
> +	drm_encoder_cleanup(encoder);
> +	kfree(encoder);
> +}
> +
> +static void gm12u320_encoder_disable(struct drm_encoder *encoder)
> +{
> +}
> +
> +static void gm12u320_encoder_prepare(struct drm_encoder *encoder)
> +{
> +}
> +
> +static void gm12u320_encoder_commit(struct drm_encoder *encoder)
> +{
> +}
> +
> +static void gm12u320_encoder_mode_set(struct drm_encoder *encoder,
> +				 struct drm_display_mode *mode,
> +				 struct drm_display_mode *adjusted_mode)
> +{
> +}
> +
> +static void
> +gm12u320_encoder_dpms(struct drm_encoder *encoder, int mode)
> +{
> +}
> +
> +static const struct drm_encoder_helper_funcs gm12u320_helper_funcs = {
> +	.dpms = gm12u320_encoder_dpms,
> +	.prepare = gm12u320_encoder_prepare,
> +	.mode_set = gm12u320_encoder_mode_set,
> +	.commit = gm12u320_encoder_commit,
> +	.disable = gm12u320_encoder_disable,
> +};
> +
> +static const struct drm_encoder_funcs gm12u320_enc_funcs = {
> +	.destroy = gm12u320_enc_destroy,
> +};
> +
> +struct drm_encoder *gm12u320_encoder_init(struct drm_device *dev)
> +{
> +	struct drm_encoder *encoder;
> +
> +	encoder = kzalloc(sizeof(struct drm_encoder), GFP_KERNEL);
> +	if (!encoder)
> +		return NULL;
> +
> +	drm_encoder_init(dev, encoder, &gm12u320_enc_funcs,
> +			 DRM_MODE_ENCODER_TMDS, NULL);
> +	drm_encoder_helper_add(encoder, &gm12u320_helper_funcs);
> +	encoder->possible_crtcs = 1;
> +	return encoder;
> +}
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_fb.c b/drivers/gpu/drm/gm12u320/gm12u320_fb.c
> new file mode 100644
> index 000000000000..8b7605f76af9
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_fb.c
> @@ -0,0 +1,343 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver:
> + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>
> + * Copyright (C) 2009 Roberto De Ioris <roberto@xxxxxxxx>
> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@xxxxxxxxx>
> + * Copyright (C) 2009 Bernie Thompson <bernie@xxxxxxxxxxxx>
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/fb.h>
> +
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_crtc_helper.h>
> +#include "gm12u320_drv.h"
> +
> +#include <drm/drm_fb_helper.h>
> +
> +struct gm12u320_fbdev {
> +	struct drm_fb_helper helper;
> +	struct gm12u320_framebuffer fb;
> +};
> +
> +void gm12u320_fb_mark_dirty(struct gm12u320_framebuffer *fb,
> +			    int x1, int x2, int y1, int y2)
> +{
> +	struct drm_device *dev = fb->base.dev;
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +	struct gm12u320_framebuffer *old_fb = NULL;
> +	bool wakeup = false;
> +
> +	mutex_lock(&gm12u320->fb_update.lock);
> +
> +	if (gm12u320->fb_update.fb != fb) {
> +		gm12u320->fb_update.x1 = x1;
> +		gm12u320->fb_update.x2 = x2;
> +		gm12u320->fb_update.y1 = y1;
> +		gm12u320->fb_update.y2 = y2;
> +		old_fb = gm12u320->fb_update.fb;
> +		gm12u320->fb_update.fb = fb;
> +		drm_framebuffer_reference(&gm12u320->fb_update.fb->base);
> +		wakeup = true;
> +	} else {
> +		gm12u320->fb_update.x1 = min(gm12u320->fb_update.x1, x1);
> +		gm12u320->fb_update.x2 = max(gm12u320->fb_update.x2, x2);
> +		gm12u320->fb_update.y1 = min(gm12u320->fb_update.y1, y1);
> +		gm12u320->fb_update.y2 = max(gm12u320->fb_update.y2, y2);
> +	}
> +
> +	mutex_unlock(&gm12u320->fb_update.lock);
> +
> +	if (wakeup)
> +		wake_up(&gm12u320->fb_update.waitq);
> +
> +	if (old_fb)
> +		drm_framebuffer_unreference(&old_fb->base);
> +}
> +
> +static int gm12u320_fb_open(struct fb_info *info, int user)
> +{
> +	struct gm12u320_fbdev *fbdev = info->par;
> +	struct drm_device *ddev = fbdev->fb.base.dev;
> +
> +	/* If the USB device is gone, we don't accept new opens */
> +	if (drm_device_is_unplugged(ddev))
> +		return -ENODEV;
> +
> +	return 0;
> +}
> +
> +static struct fb_ops gm12u320_fb_ops = {
> +	.owner = THIS_MODULE,
> +	DRM_FB_HELPER_DEFAULT_OPS,
> +	.fb_fillrect = drm_fb_helper_sys_fillrect,
> +	.fb_copyarea = drm_fb_helper_sys_copyarea,
> +	.fb_imageblit = drm_fb_helper_sys_imageblit,
> +	.fb_open = gm12u320_fb_open,
> +};
> +
> +#ifdef CONFIG_DRM_FBDEV_EMULATION
> +static struct fb_deferred_io gm12u320_fb_defio = {
> +	.delay = HZ / 30,
> +	.deferred_io = drm_fb_helper_deferred_io,
> +};
> +#endif
> +
> +static int gm12u320_user_framebuffer_dirty(struct drm_framebuffer *drm_fb,
> +					   struct drm_file *file,
> +					   unsigned flags, unsigned color,
> +					   struct drm_clip_rect *clips,
> +					   unsigned num_clips)
> +{
> +	struct gm12u320_framebuffer *fb = to_gm12u320_fb(drm_fb);
> +	int x1, x2, y1, y2;
> +
> +	if (num_clips == 0)
> +		return 0;
> +
> +	x1 = clips->x1;
> +	x2 = clips->x2;
> +	y1 = clips->y1;
> +	y2 = clips->y2;
> +
> +	while (--num_clips) {
> +		clips++;
> +		x1 = min_t(int, x1, (int)clips->x1);
> +		x2 = max_t(int, x2, (int)clips->x2);
> +		y1 = min_t(int, y1, (int)clips->y1);
> +		y2 = max_t(int, y2, (int)clips->y2);
> +	}
> +
> +	gm12u320_fb_mark_dirty(fb, x1, x2, y1, y2);
> +
> +	return 0;
> +}
> +
> +static void gm12u320_user_framebuffer_destroy(struct drm_framebuffer *drm_fb)
> +{
> +	struct gm12u320_framebuffer *fb = to_gm12u320_fb(drm_fb);
> +
> +	if (fb->obj)
> +		drm_gem_object_unreference_unlocked(&fb->obj->base);
> +
> +	drm_framebuffer_cleanup(drm_fb);
> +	kfree(fb);
> +}
> +
> +static const struct drm_framebuffer_funcs gm12u320fb_funcs = {
> +	.destroy = gm12u320_user_framebuffer_destroy,
> +	.dirty = gm12u320_user_framebuffer_dirty,
> +};
> +
> +static int
> +gm12u320_framebuffer_init(struct drm_device *dev,
> +			  struct gm12u320_framebuffer *fb,
> +			  const struct drm_mode_fb_cmd2 *mode_cmd,
> +			  struct gm12u320_gem_object *obj)
> +{
> +	int ret;
> +
> +	fb->obj = obj;
> +	drm_helper_mode_fill_fb_struct(dev, &fb->base, mode_cmd);
> +	ret = drm_framebuffer_init(dev, &fb->base, &gm12u320fb_funcs);
> +	return ret;
> +}
> +
> +static int gm12u320fb_create(struct drm_fb_helper *helper,
> +			     struct drm_fb_helper_surface_size *sizes)
> +{
> +	struct gm12u320_fbdev *fbdev =
> +		container_of(helper, struct gm12u320_fbdev, helper);
> +	struct drm_device *dev = fbdev->helper.dev;
> +	struct fb_info *info;
> +	struct drm_framebuffer *drm_fb;
> +	struct drm_mode_fb_cmd2 mode_cmd;
> +	struct gm12u320_gem_object *obj;
> +	uint32_t size;
> +	int ret = 0;
> +
> +	if (sizes->surface_bpp == 24)
> +		sizes->surface_bpp = 32;
> +
> +	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;
> +	size = ALIGN(size, PAGE_SIZE);
> +
> +	obj = gm12u320_gem_alloc_object(dev, size);
> +	if (!obj)
> +		goto out;
> +
> +	ret = gm12u320_gem_vmap(obj);
> +	if (ret) {
> +		DRM_ERROR("failed to vmap fb\n");
> +		goto out_gfree;
> +	}
> +
> +	info = drm_fb_helper_alloc_fbi(helper);
> +	if (IS_ERR(info)) {
> +		ret = PTR_ERR(info);
> +		goto out_gfree;
> +	}
> +	info->par = fbdev;
> +
> +	ret = gm12u320_framebuffer_init(dev, &fbdev->fb, &mode_cmd, obj);
> +	if (ret)
> +		goto out_gfree;
> +
> +	drm_fb = &fbdev->fb.base;
> +
> +	fbdev->helper.fb = drm_fb;
> +
> +	strcpy(info->fix.id, "gm12u320drmfb");
> +
> +	info->screen_base = fbdev->fb.obj->vmapping;
> +	info->fix.smem_len = size;
> +	info->fix.smem_start = (unsigned long)fbdev->fb.obj->vmapping;
> +
> +	info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT;
> +	info->fbops = &gm12u320_fb_ops;
> +	drm_fb_helper_fill_fix(info, drm_fb->pitches[0], drm_fb->format->depth);
> +	drm_fb_helper_fill_var(info, &fbdev->helper,
> +			       sizes->fb_width, sizes->fb_height);
> +#ifdef CONFIG_DRM_FBDEV_EMULATION
> +	info->fbdefio = &gm12u320_fb_defio;
> +	fb_deferred_io_init(info);
> +#endif
> +
> +	DRM_DEBUG_KMS("allocated %dx%d vmal %p\n",
> +		      drm_fb->width, drm_fb->height,
> +		      fbdev->fb.obj->vmapping);
> +
> +	return ret;
> +
> +out_gfree:
> +	drm_gem_object_unreference_unlocked(&fbdev->fb.obj->base);
> +out:
> +	return ret;
> +}
> +
> +static const struct drm_fb_helper_funcs gm12u320_fb_helper_funcs = {
> +	.fb_probe = gm12u320fb_create,
> +};
> +
> +static void gm12u320_fbdev_destroy(struct drm_device *dev,
> +				   struct gm12u320_fbdev *fbdev)
> +{
> +#ifdef CONFIG_DRM_FBDEV_EMULATION
> +	fb_deferred_io_cleanup(fbdev->helper.fbdev);
> +#endif
> +	drm_fb_helper_unregister_fbi(&fbdev->helper);
> +	drm_fb_helper_fini(&fbdev->helper);
> +	drm_framebuffer_unregister_private(&fbdev->fb.base);
> +	drm_framebuffer_cleanup(&fbdev->fb.base);
> +	drm_gem_object_unreference_unlocked(&fbdev->fb.obj->base);
> +}
> +
> +int gm12u320_fbdev_init(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +	struct gm12u320_fbdev *fbdev;
> +	int ret;
> +
> +	fbdev = kzalloc(sizeof(struct gm12u320_fbdev), GFP_KERNEL);
> +	if (!fbdev)
> +		return -ENOMEM;
> +
> +	gm12u320->fbdev = fbdev;
> +
> +	drm_fb_helper_prepare(dev, &fbdev->helper, &gm12u320_fb_helper_funcs);
> +
> +	ret = drm_fb_helper_init(dev, &fbdev->helper, 1);
> +	if (ret)
> +		goto free;
> +
> +	ret = drm_fb_helper_single_add_all_connectors(&fbdev->helper);
> +	if (ret)
> +		goto fini;
> +
> +	/* disable all the possible outputs/crtcs before entering KMS mode */
> +	drm_helper_disable_unused_functions(dev);
> +
> +	ret = drm_fb_helper_initial_config(&fbdev->helper, 32);
> +	if (ret)
> +		goto fini;
> +
> +	return 0;
> +
> +fini:
> +	drm_fb_helper_fini(&fbdev->helper);
> +free:
> +	kfree(fbdev);
> +	return ret;
> +}
> +
> +void gm12u320_fbdev_cleanup(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +
> +	if (!gm12u320->fbdev)
> +		return;
> +
> +	gm12u320_fbdev_destroy(dev, gm12u320->fbdev);
> +	kfree(gm12u320->fbdev);
> +	gm12u320->fbdev = NULL;
> +}
> +
> +void gm12u320_fbdev_unplug(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +
> +	if (!gm12u320->fbdev)
> +		return;
> +
> +	drm_fb_helper_unlink_fbi(&gm12u320->fbdev->helper);
> +}
> +
> +struct drm_framebuffer *
> +gm12u320_fb_user_fb_create(struct drm_device *dev,
> +			   struct drm_file *file,
> +			   const struct drm_mode_fb_cmd2 *mode_cmd)
> +{
> +	struct drm_gem_object *obj;
> +	struct gm12u320_framebuffer *fb;
> +	int ret;
> +	uint32_t size;
> +
> +	obj = drm_gem_object_lookup(file, mode_cmd->handles[0]);
> +	if (obj == NULL)
> +		return ERR_PTR(-ENOENT);
> +
> +	size = mode_cmd->pitches[0] * mode_cmd->height;
> +	size = ALIGN(size, PAGE_SIZE);
> +
> +	if (size > obj->size) {
> +		DRM_ERROR("object size not sufficient for fb %d %zu %d %d\n",
> +			  size, obj->size, mode_cmd->pitches[0],
> +			  mode_cmd->height);
> +		return ERR_PTR(-ENOMEM);
> +	}
> +
> +	fb = kzalloc(sizeof(*fb), GFP_KERNEL);
> +	if (fb == NULL)
> +		return ERR_PTR(-ENOMEM);
> +
> +	ret = gm12u320_framebuffer_init(dev, fb, mode_cmd, to_gm12u320_bo(obj));
> +	if (ret) {
> +		kfree(fb);
> +		return ERR_PTR(-EINVAL);
> +	}
> +	return &fb->base;
> +}
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_gem.c b/drivers/gpu/drm/gm12u320/gm12u320_gem.c
> new file mode 100644
> index 000000000000..7bc576fae177
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_gem.c
> @@ -0,0 +1,237 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#include <drm/drmP.h>
> +#include "gm12u320_drv.h"
> +#include <linux/shmem_fs.h>
> +#include <linux/dma-buf.h>
> +
> +struct gm12u320_gem_object *
> +gm12u320_gem_alloc_object(struct drm_device *dev, size_t size)
> +{
> +	struct gm12u320_gem_object *obj;
> +
> +	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
> +	if (obj == NULL)
> +		return NULL;
> +
> +	if (drm_gem_object_init(dev, &obj->base, size) != 0) {
> +		kfree(obj);
> +		return NULL;
> +	}
> +
> +	obj->flags = GM12U320_BO_CACHEABLE;
> +	return obj;
> +}
> +
> +static int gm12u320_gem_create(struct drm_file *file, struct drm_device *dev,
> +			       uint64_t size, uint32_t *handle_p)
> +{
> +	struct gm12u320_gem_object *obj;
> +	int ret;
> +	u32 handle;
> +
> +	size = roundup(size, PAGE_SIZE);
> +
> +	obj = gm12u320_gem_alloc_object(dev, size);
> +	if (obj == NULL)
> +		return -ENOMEM;
> +
> +	ret = drm_gem_handle_create(file, &obj->base, &handle);
> +	if (ret) {
> +		drm_gem_object_release(&obj->base);
> +		kfree(obj);
> +		return ret;
> +	}
> +
> +	drm_gem_object_unreference_unlocked(&obj->base);
> +	*handle_p = handle;
> +	return 0;
> +}
> +
> +static void update_vm_cache_attr(struct gm12u320_gem_object *obj,
> +				 struct vm_area_struct *vma)
> +{
> +	DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
> +
> +	/* non-cacheable as default. */
> +	if (obj->flags & GM12U320_BO_CACHEABLE) {
> +		vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
> +	} else if (obj->flags & GM12U320_BO_WC) {
> +		vma->vm_page_prot =
> +			pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
> +	} else {
> +		vma->vm_page_prot =
> +			pgprot_noncached(vm_get_page_prot(vma->vm_flags));
> +	}
> +}
> +
> +int gm12u320_dumb_create(struct drm_file *file, struct drm_device *dev,
> +			 struct drm_mode_create_dumb *args)
> +{
> +	args->pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
> +	args->size = args->pitch * args->height;
> +	return gm12u320_gem_create(file, dev,
> +			      args->size, &args->handle);
> +}
> +
> +int gm12u320_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
> +{
> +	int ret;
> +
> +	ret = drm_gem_mmap(filp, vma);
> +	if (ret)
> +		return ret;
> +
> +	vma->vm_flags &= ~VM_PFNMAP;
> +	vma->vm_flags |= VM_MIXEDMAP;
> +
> +	update_vm_cache_attr(to_gm12u320_bo(vma->vm_private_data), vma);
> +
> +	return ret;
> +}
> +
> +int gm12u320_gem_fault(struct vm_fault *vmf)
> +{
> +	struct vm_area_struct *vma = vmf->vma;
> +	struct gm12u320_gem_object *obj = to_gm12u320_bo(vma->vm_private_data);
> +	unsigned int page_offset;
> +	struct page *page;
> +	int ret = 0;
> +
> +	page_offset = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
> +
> +	if (!obj->pages)
> +		return VM_FAULT_SIGBUS;
> +
> +	page = obj->pages[page_offset];
> +	ret = vm_insert_page(vma, vmf->address, page);
> +	switch (ret) {
> +	case -EAGAIN:
> +	case 0:
> +	case -ERESTARTSYS:
> +		return VM_FAULT_NOPAGE;
> +	case -ENOMEM:
> +		return VM_FAULT_OOM;
> +	default:
> +		return VM_FAULT_SIGBUS;
> +	}
> +}

Same plea for some standard mmap shmem-gem helpers as for prime helpers?

> +int gm12u320_gem_get_pages(struct gm12u320_gem_object *obj)
> +{
> +	struct page **pages;
> +
> +	if (obj->pages)
> +		return 0;
> +
> +	pages = drm_gem_get_pages(&obj->base);
> +	if (IS_ERR(pages))
> +		return PTR_ERR(pages);
> +
> +	obj->pages = pages;
> +
> +	return 0;
> +}
> +
> +void gm12u320_gem_put_pages(struct gm12u320_gem_object *obj)
> +{
> +	if (obj->base.import_attach) {
> +		drm_free_large(obj->pages);
> +		obj->pages = NULL;
> +		return;
> +	}
> +
> +	drm_gem_put_pages(&obj->base, obj->pages, false, false);
> +	obj->pages = NULL;
> +}
> +
> +int gm12u320_gem_vmap(struct gm12u320_gem_object *obj)
> +{
> +	int page_count = obj->base.size / PAGE_SIZE;
> +	int ret;
> +
> +	if (obj->base.import_attach) {
> +		obj->vmapping = dma_buf_vmap(obj->base.import_attach->dmabuf);
> +		if (!obj->vmapping)
> +			return -ENOMEM;
> +		return 0;
> +	}
> +
> +	ret = gm12u320_gem_get_pages(obj);
> +	if (ret)
> +		return ret;
> +
> +	obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL);
> +	if (!obj->vmapping)
> +		return -ENOMEM;
> +	return 0;
> +}
> +
> +void gm12u320_gem_vunmap(struct gm12u320_gem_object *obj)
> +{
> +	if (obj->base.import_attach) {
> +		dma_buf_vunmap(obj->base.import_attach->dmabuf, obj->vmapping);
> +		return;
> +	}
> +
> +	vunmap(obj->vmapping);
> +
> +	gm12u320_gem_put_pages(obj);
> +}
> +
> +void gm12u320_gem_free_object(struct drm_gem_object *gem_obj)
> +{
> +	struct gm12u320_gem_object *obj = to_gm12u320_bo(gem_obj);
> +
> +	if (obj->vmapping)
> +		gm12u320_gem_vunmap(obj);
> +
> +	if (gem_obj->import_attach) {
> +		drm_prime_gem_destroy(gem_obj, obj->sg);
> +		put_device(gem_obj->dev->dev);
> +	}
> +
> +	if (obj->pages)
> +		gm12u320_gem_put_pages(obj);
> +
> +	drm_gem_free_mmap_offset(gem_obj);
> +}
> +
> +/* the dumb interface doesn't work with the GEM straight MMAP
> +   interface, it expects to do MMAP on the drm fd, like normal */
> +int gm12u320_gem_mmap(struct drm_file *file, struct drm_device *dev,
> +		      uint32_t handle, uint64_t *offset)
> +{
> +	struct gm12u320_gem_object *gobj;
> +	struct drm_gem_object *obj;
> +	int ret = 0;
> +
> +	mutex_lock(&dev->struct_mutex);
> +	obj = drm_gem_object_lookup(file, handle);
> +	if (obj == NULL) {
> +		ret = -ENOENT;
> +		goto unlock;
> +	}
> +	gobj = to_gm12u320_bo(obj);
> +
> +	ret = gm12u320_gem_get_pages(gobj);
> +	if (ret)
> +		goto out;
> +	ret = drm_gem_create_mmap_offset(obj);
> +	if (ret)
> +		goto out;
> +
> +	*offset = drm_vma_node_offset_addr(&gobj->base.vma_node);
> +
> +out:
> +	drm_gem_object_unreference(&gobj->base);
> +unlock:
> +	mutex_unlock(&dev->struct_mutex);
> +	return ret;
> +}
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_main.c b/drivers/gpu/drm/gm12u320/gm12u320_main.c
> new file mode 100644
> index 000000000000..6b9ab9d6d15b
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_main.c
> @@ -0,0 +1,506 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver:
> + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>
> + * Copyright (C) 2009 Roberto De Ioris <roberto@xxxxxxxx>
> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@xxxxxxxxx>
> + * Copyright (C) 2009 Bernie Thompson <bernie@xxxxxxxxxxxx>
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +#include <drm/drmP.h>
> +#include <linux/dma-buf.h>
> +#include "gm12u320_drv.h"
> +
> +static bool eco_mode;
> +module_param(eco_mode, bool, 0644);
> +MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)");
> +
> +#define MISC_RCV_EPT			1
> +#define DATA_RCV_EPT			2
> +#define DATA_SND_EPT			3
> +#define MISC_SND_EPT			4
> +
> +#define DATA_BLOCK_HEADER_SIZE		84
> +#define DATA_BLOCK_CONTENT_SIZE		64512
> +#define DATA_BLOCK_FOOTER_SIZE		20
> +#define DATA_BLOCK_SIZE			(DATA_BLOCK_HEADER_SIZE + \
> +					 DATA_BLOCK_CONTENT_SIZE + \
> +					 DATA_BLOCK_FOOTER_SIZE)
> +#define DATA_LAST_BLOCK_CONTENT_SIZE	4032
> +#define DATA_LAST_BLOCK_SIZE		(DATA_BLOCK_HEADER_SIZE + \
> +					 DATA_LAST_BLOCK_CONTENT_SIZE + \
> +					 DATA_BLOCK_FOOTER_SIZE)
> +
> +#define CMD_SIZE			31
> +#define READ_STATUS_SIZE		13
> +#define MISC_VALUE_SIZE			4
> +
> +#define CMD_TIMEOUT			200
> +#define DATA_TIMEOUT			1000
> +#define IDLE_TIMEOUT			2000
> +#define FIRST_FRAME_TIMEOUT		2000
> +
> +#define MISC_REQ_GET_SET_ECO_A		0xff
> +#define MISC_REQ_GET_SET_ECO_B		0x35
> +/* Windows driver does once evert second, with with arg d = 1, others 0 */
> +#define MISC_REQ_UNKNOWN1_A		0xff
> +#define MISC_REQ_UNKNOWN1_B		0x38
> +/* Windows driver does this on init, with arg a, b = 0, c = 0xa0, d = 4 */
> +#define MISC_REQ_UNKNOWN2_A		0xa5
> +#define MISC_REQ_UNKNOWN2_B		0x00
> +
> +static const char cmd_data[CMD_SIZE] = {
> +	0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
> +	0x68, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x10, 0xff,
> +	0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x80, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
> +};
> +
> +static const char cmd_draw[CMD_SIZE] = {
> +	0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfe,
> +	0x00, 0x00, 0x00, 0xc0, 0xd1, 0x05, 0x00, 0x40,
> +	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
> +};
> +
> +static const char cmd_misc[CMD_SIZE] = {
> +	0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00,
> +	0x04, 0x00, 0x00, 0x00, 0x80, 0x01, 0x10, 0xfd,
> +	0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
> +};
> +
> +static const char data_block_header[DATA_BLOCK_HEADER_SIZE] = {
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x04, 0x15, 0x00, 0x00, 0xfc, 0x00, 0x00,
> +	0x01, 0x00, 0x00, 0xdb
> +};
> +
> +static const char data_last_block_header[DATA_BLOCK_HEADER_SIZE] = {
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x2a, 0x00, 0x20, 0x00, 0xc0, 0x0f, 0x00, 0x00,
> +	0x01, 0x00, 0x00, 0xd7
> +};
> +
> +static const char data_block_footer[DATA_BLOCK_FOOTER_SIZE] = {
> +	0xfb, 0x14, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
> +	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +	0x80, 0x00, 0x00, 0x4f
> +};
> +
> +static int gm12u320_usb_alloc(struct gm12u320_device *gm12u320)
> +{
> +	int i, block_size;
> +	const char *hdr;
> +
> +	gm12u320->cmd_buf = kmalloc(CMD_SIZE, GFP_KERNEL);
> +	if (!gm12u320->cmd_buf)
> +		return -ENOMEM;
> +
> +	for (i = 0; i < GM12U320_BLOCK_COUNT; i++) {
> +		if (i == GM12U320_BLOCK_COUNT - 1) {
> +			block_size = DATA_LAST_BLOCK_SIZE;
> +			hdr = data_last_block_header;
> +		} else {
> +			block_size = DATA_BLOCK_SIZE;
> +			hdr = data_block_header;
> +		}
> +
> +		gm12u320->data_buf[i] = kzalloc(block_size, GFP_KERNEL);
> +		if (!gm12u320->data_buf[i])
> +			return -ENOMEM;
> +
> +		memcpy(gm12u320->data_buf[i], hdr, DATA_BLOCK_HEADER_SIZE);
> +		memcpy(gm12u320->data_buf[i] +
> +				(block_size - DATA_BLOCK_FOOTER_SIZE),
> +		       data_block_footer, DATA_BLOCK_FOOTER_SIZE);
> +	}
> +
> +	return 0;
> +}
> +
> +static void gm12u320_usb_free(struct gm12u320_device *gm12u320)
> +{
> +	int i;
> +
> +	for (i = 0; i < GM12U320_BLOCK_COUNT; i++)
> +		kfree(gm12u320->data_buf[i]);
> +
> +	kfree(gm12u320->cmd_buf);
> +}
> +
> +static int gm12u320_misc_request(struct gm12u320_device *gm12u320,
> +				 u8 req_a, u8 req_b,
> +				 u8 arg_a, u8 arg_b, u8 arg_c, u8 arg_d)
> +{
> +	int ret, len;
> +	u8 *buf, val;
> +
> +	buf = kmalloc(CMD_SIZE, GFP_KERNEL);
> +	if (!buf)
> +		return -ENOMEM;
> +
> +	memcpy(buf, &cmd_misc, CMD_SIZE);
> +	buf[20] = req_a;
> +	buf[21] = req_b;
> +	buf[22] = arg_a;
> +	buf[23] = arg_b;
> +	buf[24] = arg_c;
> +	buf[25] = arg_d;
> +
> +	/* Send request */
> +	ret = usb_bulk_msg(gm12u320->udev,
> +			   usb_sndbulkpipe(gm12u320->udev, MISC_SND_EPT),
> +			   buf, CMD_SIZE, &len, CMD_TIMEOUT);
> +	if (ret || len != CMD_SIZE) {
> +		dev_err(&gm12u320->udev->dev, "Misc. req. error %d\n", ret);
> +		ret = -EIO;
> +		goto leave;
> +	}
> +
> +	/* Read value */
> +	ret = usb_bulk_msg(gm12u320->udev,
> +			   usb_rcvbulkpipe(gm12u320->udev, MISC_RCV_EPT),
> +			   buf, MISC_VALUE_SIZE, &len, DATA_TIMEOUT);
> +	if (ret || len != MISC_VALUE_SIZE) {
> +		dev_err(&gm12u320->udev->dev, "Misc. value error %d\n", ret);
> +		ret = -EIO;
> +		goto leave;
> +	}
> +	val = buf[0];
> +
> +	/* Read status */
> +	ret = usb_bulk_msg(gm12u320->udev,
> +			   usb_rcvbulkpipe(gm12u320->udev, MISC_RCV_EPT),
> +			   buf, READ_STATUS_SIZE, &len, CMD_TIMEOUT);
> +	if (ret || len != READ_STATUS_SIZE) {
> +		dev_err(&gm12u320->udev->dev, "Misc. status error %d\n", ret);
> +		ret = -EIO;
> +		goto leave;
> +	}
> +
> +	ret = val;
> +leave:
> +	kfree(buf);
> +	return ret;
> +}
> +
> +void gm12u320_32bpp_to_24bpp_packed(u8 *dst, u8 *src, int len)
> +{
> +	while (len--) {
> +		*dst++ = *src++;
> +		*dst++ = *src++;
> +		*dst++ = *src++;
> +		src++;
> +	}
> +}
> +
> +static void gm12u320_copy_fb_to_blocks(struct gm12u320_framebuffer *fb,
> +				       int x1, int x2, int y1, int y2)
> +{
> +	struct drm_device *dev = fb->base.dev;
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +	int block, dst_offset, len, remain, ret;
> +	u8 *src;
> +
> +	if (fb->obj->base.import_attach) {
> +		ret = dma_buf_begin_cpu_access(
> +			fb->obj->base.import_attach->dmabuf, DMA_FROM_DEVICE);
> +		if (ret) {
> +			DRM_ERROR("dma_buf_begin_cpu_access err: %d\n", ret);
> +			return;
> +		}
> +	}
> +
> +	if (!fb->obj->vmapping) {
> +		ret = gm12u320_gem_vmap(fb->obj);
> +		if (ret) {
> +			DRM_ERROR("failed to vmap fb: %d\n", ret);
> +			goto end_cpu_access;
> +		}
> +	}
> +
> +	src = fb->obj->vmapping + y1 * fb->base.pitches[0] + x1 * 4;
> +
> +	x1 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2;
> +	x2 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2;
> +
> +	for (; y1 < y2; y1++) {
> +		remain = 0;
> +		len = (x2 - x1) * 3;
> +		dst_offset = (y1 * GM12U320_REAL_WIDTH + x1) * 3;
> +		block = dst_offset / DATA_BLOCK_CONTENT_SIZE;
> +		dst_offset %= DATA_BLOCK_CONTENT_SIZE;
> +
> +		if ((dst_offset + len) > DATA_BLOCK_CONTENT_SIZE) {
> +			remain = dst_offset + len - DATA_BLOCK_CONTENT_SIZE;
> +			len = DATA_BLOCK_CONTENT_SIZE - dst_offset;
> +		}
> +
> +		dst_offset += DATA_BLOCK_HEADER_SIZE;
> +		len /= 3;
> +
> +		gm12u320_32bpp_to_24bpp_packed(
> +			gm12u320->data_buf[block] + dst_offset,
> +			src, len);
> +
> +		if (remain) {
> +			block++;
> +			dst_offset = DATA_BLOCK_HEADER_SIZE;
> +			gm12u320_32bpp_to_24bpp_packed(
> +				gm12u320->data_buf[block] + dst_offset,
> +				src + len * 4, remain / 3);
> +		}
> +		src += fb->base.pitches[0];
> +	}
> +
> +end_cpu_access:
> +	if (fb->obj->base.import_attach) {
> +		ret = dma_buf_end_cpu_access(
> +			fb->obj->base.import_attach->dmabuf, DMA_FROM_DEVICE);
> +		if (ret)
> +			DRM_ERROR("dma_buf_end_cpu_access err: %d\n", ret);
> +	}
> +}
> +
> +static int gm12u320_fb_update_ready(struct gm12u320_device *gm12u320)
> +{
> +	int ret;
> +
> +	mutex_lock(&gm12u320->fb_update.lock);
> +	ret = !gm12u320->fb_update.run || gm12u320->fb_update.fb != NULL;
> +	mutex_unlock(&gm12u320->fb_update.lock);
> +
> +	return ret;
> +}
> +
> +static void gm12u320_fb_update_work(struct work_struct *work)
> +{
> +	struct gm12u320_device *gm12u320 =
> +		container_of(work, struct gm12u320_device, fb_update.work);
> +	int draw_status_timeout = FIRST_FRAME_TIMEOUT;
> +	int block, block_size, len, x1, x2, y1, y2;
> +	struct gm12u320_framebuffer *fb;
> +	int frame = 0;
> +	int ret = 0;
> +
> +	while (gm12u320->fb_update.run) {
> +		mutex_lock(&gm12u320->fb_update.lock);
> +		fb = gm12u320->fb_update.fb;
> +		x1 = gm12u320->fb_update.x1;
> +		x2 = gm12u320->fb_update.x2;
> +		y1 = gm12u320->fb_update.y1;
> +		y2 = gm12u320->fb_update.y2;
> +		gm12u320->fb_update.fb = NULL;
> +		mutex_unlock(&gm12u320->fb_update.lock);
> +
> +		if (fb) {
> +			gm12u320_copy_fb_to_blocks(fb, x1, x2, y1, y2);
> +			drm_framebuffer_unreference(&fb->base);
> +		}
> +
> +		for (block = 0; block < GM12U320_BLOCK_COUNT; block++) {
> +			if (block == GM12U320_BLOCK_COUNT - 1)
> +				block_size = DATA_LAST_BLOCK_SIZE;
> +			else
> +				block_size = DATA_BLOCK_SIZE;
> +
> +			/* Send data command to device */
> +			memcpy(gm12u320->cmd_buf, cmd_data, CMD_SIZE);
> +			gm12u320->cmd_buf[8] = block_size & 0xff;
> +			gm12u320->cmd_buf[9] = block_size >> 8;
> +			gm12u320->cmd_buf[20] = 0xfc - block * 4;
> +			gm12u320->cmd_buf[21] = block | (frame << 7);
> +
> +			ret = usb_bulk_msg(gm12u320->udev,
> +				usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT),
> +				gm12u320->cmd_buf, CMD_SIZE, &len,
> +				CMD_TIMEOUT);
> +			if (ret || len != CMD_SIZE)
> +				goto err;
> +
> +			/* Send data block to device */
> +			ret = usb_bulk_msg(gm12u320->udev,
> +				usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT),
> +				gm12u320->data_buf[block], block_size,
> +				&len, DATA_TIMEOUT);
> +			if (ret || len != block_size)
> +				goto err;
> +
> +			/* Read status */
> +			ret = usb_bulk_msg(gm12u320->udev,
> +				usb_rcvbulkpipe(gm12u320->udev, DATA_RCV_EPT),
> +				gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
> +				CMD_TIMEOUT);
> +			if (ret || len != READ_STATUS_SIZE)
> +				goto err;
> +		}
> +
> +		/* Send draw command to device */
> +		memcpy(gm12u320->cmd_buf, cmd_draw, CMD_SIZE);
> +		ret = usb_bulk_msg(gm12u320->udev,
> +			usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT),
> +			gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT);
> +		if (ret || len != CMD_SIZE)
> +			goto err;
> +
> +		/* Read status */
> +		ret = usb_bulk_msg(gm12u320->udev,
> +			usb_rcvbulkpipe(gm12u320->udev, DATA_RCV_EPT),
> +			gm12u320->cmd_buf, READ_STATUS_SIZE, &len,
> +			draw_status_timeout);
> +		if (ret || len != READ_STATUS_SIZE)
> +			goto err;
> +
> +		draw_status_timeout = CMD_TIMEOUT;
> +		frame = !frame;
> +
> +		/*
> +		 * We must draw a frame every 2s otherwise the projector
> +		 * switches back to showing its logo.
> +		 */
> +		wait_event_timeout(gm12u320->fb_update.waitq,
> +				   gm12u320_fb_update_ready(gm12u320),
> +				   msecs_to_jiffies(IDLE_TIMEOUT));
> +	}
> +	return;
> +err:
> +	/* Do not log errors caused by module unload or device unplug */
> +	if (ret != -ECONNRESET && ret != -ESHUTDOWN)
> +		dev_err(&gm12u320->udev->dev, "Frame update error: %d\n", ret);
> +}
> +
> +void gm12u320_start_fb_update(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +
> +	mutex_lock(&gm12u320->fb_update.lock);
> +	gm12u320->fb_update.run = true;
> +	mutex_unlock(&gm12u320->fb_update.lock);
> +
> +	queue_work(gm12u320->fb_update.workq, &gm12u320->fb_update.work);
> +}
> +
> +void gm12u320_stop_fb_update(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +
> +	mutex_lock(&gm12u320->fb_update.lock);
> +	gm12u320->fb_update.run = false;
> +	mutex_unlock(&gm12u320->fb_update.lock);
> +
> +	wake_up(&gm12u320->fb_update.waitq);
> +	cancel_work_sync(&gm12u320->fb_update.work);
> +
> +	mutex_lock(&gm12u320->fb_update.lock);
> +	if (gm12u320->fb_update.fb) {
> +		drm_framebuffer_unreference(&gm12u320->fb_update.fb->base);
> +		gm12u320->fb_update.fb = NULL;
> +	}
> +	mutex_unlock(&gm12u320->fb_update.lock);
> +}
> +
> +int gm12u320_driver_load(struct drm_device *dev, unsigned long flags)
> +{
> +	struct usb_device *udev = (void *)flags;
> +	struct gm12u320_device *gm12u320;
> +	int ret = -ENOMEM;
> +
> +	DRM_DEBUG("\n");
> +	gm12u320 = kzalloc(sizeof(struct gm12u320_device), GFP_KERNEL);
> +	if (!gm12u320)
> +		return -ENOMEM;
> +
> +	gm12u320->udev = udev;
> +	gm12u320->ddev = dev;
> +	dev->dev_private = gm12u320;
> +
> +	INIT_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work);
> +	mutex_init(&gm12u320->fb_update.lock);
> +	init_waitqueue_head(&gm12u320->fb_update.waitq);
> +
> +	ret = gm12u320_set_ecomode(dev);
> +	if (ret)
> +		goto err;
> +
> +	gm12u320->fb_update.workq = create_singlethread_workqueue(DRIVER_NAME);
> +	if (!gm12u320->fb_update.workq) {
> +		ret = -ENOMEM;
> +		goto err;
> +	}
> +
> +	ret = gm12u320_usb_alloc(gm12u320);
> +	if (ret)
> +		goto err_wq;
> +
> +	DRM_DEBUG("\n");
> +	ret = gm12u320_modeset_init(dev);
> +	if (ret)
> +		goto err_usb;
> +
> +	ret = gm12u320_fbdev_init(dev);
> +	if (ret)
> +		goto err_modeset;
> +
> +	ret = drm_vblank_init(dev, 1);
> +	if (ret)
> +		goto err_fb;
> +
> +	gm12u320_start_fb_update(dev);
> +
> +	return 0;
> +
> +err_fb:
> +	gm12u320_fbdev_cleanup(dev);
> +err_modeset:
> +	gm12u320_modeset_cleanup(dev);
> +err_usb:
> +	gm12u320_usb_free(gm12u320);
> +err_wq:
> +	destroy_workqueue(gm12u320->fb_update.workq);
> +err:
> +	kfree(gm12u320);
> +	DRM_ERROR("%d\n", ret);
> +	return ret;
> +}
> +
> +void gm12u320_driver_unload(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +
> +	drm_vblank_cleanup(dev);
> +	gm12u320_fbdev_cleanup(dev);
> +	gm12u320_modeset_cleanup(dev);
> +	gm12u320_usb_free(gm12u320);
> +	destroy_workqueue(gm12u320->fb_update.workq);
> +	kfree(gm12u320);
> +}
> +
> +int gm12u320_set_ecomode(struct drm_device *dev)
> +{
> +	struct gm12u320_device *gm12u320 = dev->dev_private;
> +
> +	return gm12u320_misc_request(gm12u320, MISC_REQ_GET_SET_ECO_A,
> +				     MISC_REQ_GET_SET_ECO_B, 0x01 /* set */,
> +				     eco_mode ? 0x01 : 0x00, 0x00, 0x01);
> +}
> diff --git a/drivers/gpu/drm/gm12u320/gm12u320_modeset.c b/drivers/gpu/drm/gm12u320/gm12u320_modeset.c
> new file mode 100644
> index 000000000000..bb3122295d15
> --- /dev/null
> +++ b/drivers/gpu/drm/gm12u320/gm12u320_modeset.c
> @@ -0,0 +1,143 @@
> +/*
> + * Copyright (C) 2012-2016 Red Hat Inc.
> + *
> + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver:
> + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn@xxxxxxxxx>
> + * Copyright (C) 2009 Roberto De Ioris <roberto@xxxxxxxx>
> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@xxxxxxxxx>
> + * Copyright (C) 2009 Bernie Thompson <bernie@xxxxxxxxxxxx>
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License v2. See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_crtc_helper.h>
> +#include <drm/drm_plane_helper.h>
> +#include "gm12u320_drv.h"
> +
> +static void gm12u320_crtc_dpms(struct drm_crtc *crtc, int mode)
> +{
> +}
> +
> +static int gm12u320_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 gm12u320_framebuffer *fb = to_gm12u320_fb(crtc->primary->fb);
> +
> +	gm12u320_fb_mark_dirty(fb, 0, GM12U320_USER_WIDTH, 0, GM12U320_HEIGHT);
> +	return 0;
> +}
> +
> +
> +static void gm12u320_crtc_disable(struct drm_crtc *crtc)
> +{
> +}
> +
> +static void gm12u320_crtc_destroy(struct drm_crtc *crtc)
> +{
> +	drm_crtc_cleanup(crtc);
> +	kfree(crtc);
> +}
> +
> +static int gm12u320_crtc_page_flip(struct drm_crtc *crtc,
> +				   struct drm_framebuffer *drm_fb,
> +				   struct drm_pending_vblank_event *event,
> +				   uint32_t page_flip_flags,
> +				   struct drm_modeset_acquire_ctx *ctx)
> +{
> +	struct gm12u320_framebuffer *fb = to_gm12u320_fb(drm_fb);
> +	struct drm_device *dev = crtc->dev;
> +	unsigned long flags;
> +
> +	gm12u320_fb_mark_dirty(fb, 0, GM12U320_USER_WIDTH, 0, GM12U320_HEIGHT);
> +
> +	spin_lock_irqsave(&dev->event_lock, flags);
> +	if (event)
> +		drm_crtc_send_vblank_event(crtc, event);
> +	spin_unlock_irqrestore(&dev->event_lock, flags);
> +
> +	crtc->primary->fb = drm_fb;
> +
> +	return 0;
> +}
> +
> +static void gm12u320_crtc_prepare(struct drm_crtc *crtc)
> +{
> +}
> +
> +static void gm12u320_crtc_commit(struct drm_crtc *crtc)
> +{
> +	gm12u320_crtc_dpms(crtc, DRM_MODE_DPMS_ON);
> +}
> +
> +static const struct drm_crtc_helper_funcs gm12u320_helper_funcs = {
> +	.dpms = gm12u320_crtc_dpms,
> +	.mode_set = gm12u320_crtc_mode_set,
> +	.prepare = gm12u320_crtc_prepare,
> +	.commit = gm12u320_crtc_commit,
> +	.disable = gm12u320_crtc_disable,
> +};
> +
> +static const struct drm_crtc_funcs gm12u320_crtc_funcs = {
> +	.set_config = drm_crtc_helper_set_config,
> +	.destroy = gm12u320_crtc_destroy,
> +	.page_flip = gm12u320_crtc_page_flip,
> +};
> +
> +static int gm12u320_crtc_init(struct drm_device *dev)
> +{
> +	struct drm_crtc *crtc;
> +
> +	crtc = kzalloc(sizeof(struct drm_crtc) +
> +		       sizeof(struct drm_connector *), GFP_KERNEL);
> +	if (crtc == NULL)
> +		return -ENOMEM;
> +
> +	drm_crtc_init(dev, crtc, &gm12u320_crtc_funcs);
> +	drm_crtc_helper_add(crtc, &gm12u320_helper_funcs);
> +
> +	return 0;
> +}
> +
> +static const struct drm_mode_config_funcs gm12u320_mode_funcs = {
> +	.fb_create = gm12u320_fb_user_fb_create,
> +	.output_poll_changed = NULL,
> +};

Submitting a non-atomic driver for inclusions in todays time! tsk ...

Also, this is a prime example of hw that wants to use the simple display
pipe helpers, which gives you atomic and all the new gizmos for free.

> +
> +int gm12u320_modeset_init(struct drm_device *dev)
> +{
> +	struct drm_encoder *encoder;
> +
> +	drm_mode_config_init(dev);
> +
> +	dev->mode_config.min_width = GM12U320_USER_WIDTH;
> +	dev->mode_config.min_height = GM12U320_HEIGHT;
> +
> +	dev->mode_config.max_width = 2048;
> +	dev->mode_config.max_height = 2048;
> +
> +	dev->mode_config.prefer_shadow = 0;
> +	dev->mode_config.preferred_depth = 24;
> +
> +	dev->mode_config.funcs = &gm12u320_mode_funcs;
> +
> +	gm12u320_crtc_init(dev);
> +
> +	encoder = gm12u320_encoder_init(dev);
> +
> +	gm12u320_connector_init(dev, encoder);
> +
> +	return 0;
> +}
> +
> +void gm12u320_modeset_cleanup(struct drm_device *dev)
> +{
> +	drm_mode_config_cleanup(dev);
> +}
> -- 
> 2.13.0
> 
> _______________________________________________
> dri-devel mailing list
> dri-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/dri-devel

-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
dri-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/dri-devel





[Index of Archives]     [Linux DRI Users]     [Linux Intel Graphics]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]
  Powered by Linux