bcm27xx: add kernel 5.10 support

Rebased RPi foundation patches on linux 5.10.59, removed applied and reverted
patches, wireless patches and defconfig patches.

bcm2708: boot tested on RPi B+ v1.2
bcm2709: boot tested on RPi 4B v1.1 4G
bcm2711: boot tested on RPi 4B v1.1 4G

Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>

1 files changed, 2676 insertions, 0 deletions

diff --git a/target/linux/bcm27xx/patches-5.10/950-0709-drm-Add-GUD-USB-Display-driver.patch b/target/linux/bcm27xx/patches-5.10/950-0709-drm-Add-GUD-USB-Display-driver.patch
new file mode 100644
index 0000000000..cb05ed3e3e
--- /dev/null
+++ b/target/linux/bcm27xx/patches-5.10/950-0709-drm-Add-GUD-USB-Display-driver.patch
@@ -0,0 +1,2676 @@
+From 140a4e12d8ec470fe0807931893d3d48ffda46b3 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
+Date: Sat, 13 Mar 2021 12:25:45 +0100
+Subject: [PATCH] drm: Add GUD USB Display driver
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+[ Upstream commit 40e1a70b4aedf2859a1829991b48ef0ebe650bf2 ]
+
+This adds a USB display driver with the intention that it can be
+used with future USB interfaced low end displays/adapters. The Linux
+gadget device driver will serve as the canonical device implementation.
+
+The following DRM properties are supported:
+- Plane rotation
+- Connector TV properties
+
+There is also support for backlight brightness exposed as a backlight
+device.
+
+Display modes can be made available to the host driver either as DRM
+display modes or through EDID. If both are present, EDID is just passed
+on to userspace.
+
+Performance is preferred over color depth, so if the device supports
+RGB565, DRM_CAP_DUMB_PREFERRED_DEPTH will return 16.
+
+If the device transfer buffer can't fit an uncompressed framebuffer
+update, the update is split up into parts that do fit.
+
+Optimal user experience is achieved by providing damage reports either by
+setting FB_DAMAGE_CLIPS on pageflips or calling DRM_IOCTL_MODE_DIRTYFB.
+
+LZ4 compression is used if the device supports it.
+
+The driver supports a one bit monochrome transfer format: R1. This is not
+implemented in the gadget driver. It is added in preparation for future
+monochrome e-ink displays.
+
+The driver is MIT licensed to smooth the path for any BSD port of the
+driver.
+
+v2:
+- Use devm_drm_dev_alloc() and drmm_mode_config_init()
+- drm_fbdev_generic_setup: Use preferred_bpp=0, 16 was a copy paste error
+- The drm_backlight_helper is dropped, copy in the code
+- Support protocol version backwards compatibility for device
+
+v3:
+- Use donated Openmoko USB pid
+- Use direct compression from framebuffer when pitch matches, not only on
+  full frames, so split updates can benefit
+- Use __le16 in struct gud_drm_req_get_connector_status
+- Set edid property when the device only provides edid
+- Clear compression fields in struct gud_drm_req_set_buffer
+- Fix protocol version negotiation
+- Remove mode->vrefresh, it's calculated
+
+v4:
+- Drop the status req polling which was a workaround for something that
+  turned out to be a dwc2 udc driver problem
+- Add a flag for the Linux gadget to require a status request on
+  SET operations. Other devices will only get status req on STALL errors
+- Use protocol specific error codes (Peter)
+- Add a flag for devices that want to receive the entire framebuffer on
+  each flush (Lubomir)
+- Retry a failed framebuffer flush
+- If mode has changed wait for worker and clear pending damage before
+  queuing up new damage, fb width/height might have changed
+- Increase error counter on bulk transfer failures
+- Use DRM_MODE_CONNECTOR_USB
+- Handle R1 kmalloc error (Peter)
+- Don't try and replicate the USB get descriptor request standard for the
+  display descriptor (Peter)
+- Make max_buffer_size optional (Peter), drop the pow2 requirement since
+  it's not necessary anymore.
+- Don't pre-alloc a control request buffer, it was only 4k
+- Let gud.h describe the whole protocol explicitly and don't let DRM
+  leak into it (Peter)
+- Drop display mode .hskew and .vscan from the protocol
+- Shorten names: s/GUD_DRM_/GUD_/ s/gud_drm_/gud_/ (Peter)
+- Fix gud_pipe_check() connector picking when switching connector
+- Drop gud_drm_driver_gem_create_object() cached is default now
+- Retrieve USB device from struct drm_device.dev instead of keeping a
+  pointer
+- Honour fb->offsets[0]
+- Fix mode fetching when connector status is forced
+- Check EDID length reported by the device
+- Use drm_do_get_edid() so userspace can overrride EDID
+- Set epoch counter to signal connector status change
+- gud_drm_driver can be const now
+
+v5:
+- GUD_DRM_FORMAT_R1: Use non-human ascii values (Daniel)
+- Change name to: GUD USB Display (Thomas, Simon)
+- Change one __u32 -> __le32 in protocol header
+- Always log fb flush errors, unless the previous one failed
+- Run backlight update in a worker to avoid upsetting lockdep (Daniel)
+- Drop backlight_ops.get_brightness, there's no readback from the device
+  so it doesn't really add anything.
+- Set dma mask, needed by dma-buf importers
+
+v6:
+- Use obj-y in Makefile (Peter)
+- Fix missing le32_to_cpu() when using GUD_DISPLAY_MAGIC (Peter)
+- Set initial brightness on backlight device
+
+v7:
+- LZ4_compress_default() can return zero, check for that
+- Fix memory leak in gud_pipe_check() error path (Peter)
+- Improve debug and error messages (Peter)
+- Don't pass length in protocol structs (Peter)
+- Pass USB interface to gud_usb_control_msg() et al. (Peter)
+- Improve gud_connector_fill_properties() (Peter)
+- Add GUD_PIXEL_FORMAT_RGB111 (Peter)
+- Remove GUD_REQ_SET_VERSION (Peter)
+- Fix DRM_IOCTL_MODE_OBJ_SETPROPERTY and the rotation property
+- Fix dma-buf import (Thomas)
+
+v8:
+- Forgot to filter RGB111 from reaching userspace
+- Handle a device that only returns unknown device properties (Peter)
+- s/GUD_PIXEL_FORMAT_RGB111/GUD_PIXEL_FORMAT_XRGB1111/ (Peter)
+- Fix R1 and XRGB1111 format conversion
+- Add FIXME about Big Endian being broken (Peter, Ilia)
+
+Cc: Lubomir Rintel <lkundrak@v3.sk>
+Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch>
+Reviewed-by: Peter Stuge <peter@stuge.se>
+Tested-by: Peter Stuge <peter@stuge.se>
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+Link: https://patchwork.freedesktop.org/patch/msgid/20210313112545.37527-4-noralf@tronnes.org
+[ backport changes:
+  - Remove include drm_gem_atomic_helper.h
+  - s/drm_gem_simple_display_pipe_prepare_fb/drm_gem_fb_simple_display_pipe_prepare_fb/
+  - Remove const from gud_drm_driver
+  - Change drm_gem_shmem_{vmap,vunmap} signatures
+  - Add gud_gem_create_object() to get cached memory mapping.
+]
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ MAINTAINERS                         |   8 +
+ drivers/gpu/drm/Kconfig             |   2 +
+ drivers/gpu/drm/Makefile            |   1 +
+ drivers/gpu/drm/gud/Kconfig         |  14 +
+ drivers/gpu/drm/gud/Makefile        |   4 +
+ drivers/gpu/drm/gud/gud_connector.c | 729 ++++++++++++++++++++++++++++
+ drivers/gpu/drm/gud/gud_drv.c       | 674 +++++++++++++++++++++++++
+ drivers/gpu/drm/gud/gud_internal.h  | 154 ++++++
+ drivers/gpu/drm/gud/gud_pipe.c      | 551 +++++++++++++++++++++
+ include/drm/gud.h                   | 333 +++++++++++++
+ 10 files changed, 2470 insertions(+)
+ create mode 100644 drivers/gpu/drm/gud/Kconfig
+ create mode 100644 drivers/gpu/drm/gud/Makefile
+ create mode 100644 drivers/gpu/drm/gud/gud_connector.c
+ create mode 100644 drivers/gpu/drm/gud/gud_drv.c
+ create mode 100644 drivers/gpu/drm/gud/gud_internal.h
+ create mode 100644 drivers/gpu/drm/gud/gud_pipe.c
+ create mode 100644 include/drm/gud.h
+
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -5525,6 +5525,14 @@ S:	Maintained
+ F:	Documentation/devicetree/bindings/display/panel/feiyang,fy07024di26a30d.yaml
+ F:	drivers/gpu/drm/panel/panel-feiyang-fy07024di26a30d.c
+ 
++DRM DRIVER FOR GENERIC USB DISPLAY
++M:	Noralf Trønnes <noralf@tronnes.org>
++S:	Maintained
++W:	https://github.com/notro/gud/wiki
++T:	git git://anongit.freedesktop.org/drm/drm-misc
++F:	drivers/gpu/drm/gud/
++F:	include/drm/gud.h
++
+ DRM DRIVER FOR GRAIN MEDIA GM12U320 PROJECTORS
+ M:	Hans de Goede <hdegoede@redhat.com>
+ S:	Maintained
+--- a/drivers/gpu/drm/Kconfig
++++ b/drivers/gpu/drm/Kconfig
+@@ -392,6 +392,8 @@ source "drivers/gpu/drm/tidss/Kconfig"
+ 
+ source "drivers/gpu/drm/xlnx/Kconfig"
+ 
++source "drivers/gpu/drm/gud/Kconfig"
++
+ # Keep legacy drivers last
+ 
+ menuconfig DRM_LEGACY
+--- a/drivers/gpu/drm/Makefile
++++ b/drivers/gpu/drm/Makefile
+@@ -124,3 +124,4 @@ obj-$(CONFIG_DRM_ASPEED_GFX) += aspeed/
+ obj-$(CONFIG_DRM_MCDE) += mcde/
+ obj-$(CONFIG_DRM_TIDSS) += tidss/
+ obj-y			+= xlnx/
++obj-y			+= gud/
+--- /dev/null
++++ b/drivers/gpu/drm/gud/Kconfig
+@@ -0,0 +1,14 @@
++# SPDX-License-Identifier: GPL-2.0
++
++config DRM_GUD
++	tristate "GUD USB Display"
++	depends on DRM && USB
++	select LZ4_COMPRESS
++	select DRM_KMS_HELPER
++	select DRM_GEM_SHMEM_HELPER
++	select BACKLIGHT_CLASS_DEVICE
++	help
++	  This is a DRM display driver for GUD USB Displays or display
++	  adapters.
++
++	  If M is selected the module will be called gud.
+--- /dev/null
++++ b/drivers/gpu/drm/gud/Makefile
+@@ -0,0 +1,4 @@
++# SPDX-License-Identifier: GPL-2.0
++
++gud-y				:= gud_drv.o gud_pipe.o gud_connector.o
++obj-$(CONFIG_DRM_GUD)		+= gud.o
+--- /dev/null
++++ b/drivers/gpu/drm/gud/gud_connector.c
+@@ -0,0 +1,729 @@
++// SPDX-License-Identifier: MIT
++/*
++ * Copyright 2020 Noralf Trønnes
++ */
++
++#include <linux/backlight.h>
++#include <linux/workqueue.h>
++
++#include <drm/drm_atomic.h>
++#include <drm/drm_atomic_state_helper.h>
++#include <drm/drm_connector.h>
++#include <drm/drm_drv.h>
++#include <drm/drm_encoder.h>
++#include <drm/drm_file.h>
++#include <drm/drm_modeset_helper_vtables.h>
++#include <drm/drm_print.h>
++#include <drm/drm_probe_helper.h>
++#include <drm/drm_simple_kms_helper.h>
++#include <drm/gud.h>
++
++#include "gud_internal.h"
++
++struct gud_connector {
++	struct drm_connector connector;
++	struct drm_encoder encoder;
++	struct backlight_device *backlight;
++	struct work_struct backlight_work;
++
++	/* Supported properties */
++	u16 *properties;
++	unsigned int num_properties;
++
++	/* Initial gadget tv state if applicable, applied on state reset */
++	struct drm_tv_connector_state initial_tv_state;
++
++	/*
++	 * Initial gadget backlight brightness if applicable, applied on state reset.
++	 * The value -ENODEV is used to signal no backlight.
++	 */
++	int initial_brightness;
++};
++
++static inline struct gud_connector *to_gud_connector(struct drm_connector *connector)
++{
++	return container_of(connector, struct gud_connector, connector);
++}
++
++static void gud_conn_err(struct drm_connector *connector, const char *msg, int ret)
++{
++	dev_err(connector->dev->dev, "%s: %s (ret=%d)\n", connector->name, msg, ret);
++}
++
++/*
++ * Use a worker to avoid taking kms locks inside the backlight lock.
++ * Other display drivers use backlight within their kms locks.
++ * This avoids inconsistent locking rules, which would upset lockdep.
++ */
++static void gud_connector_backlight_update_status_work(struct work_struct *work)
++{
++	struct gud_connector *gconn = container_of(work, struct gud_connector, backlight_work);
++	struct drm_connector *connector = &gconn->connector;
++	struct drm_connector_state *connector_state;
++	struct drm_device *drm = connector->dev;
++	struct drm_modeset_acquire_ctx ctx;
++	struct drm_atomic_state *state;
++	int idx, ret;
++
++	if (!drm_dev_enter(drm, &idx))
++		return;
++
++	state = drm_atomic_state_alloc(drm);
++	if (!state) {
++		ret = -ENOMEM;
++		goto exit;
++	}
++
++	drm_modeset_acquire_init(&ctx, 0);
++	state->acquire_ctx = &ctx;
++retry:
++	connector_state = drm_atomic_get_connector_state(state, connector);
++	if (IS_ERR(connector_state)) {
++		ret = PTR_ERR(connector_state);
++		goto out;
++	}
++
++	/* Reuse tv.brightness to avoid having to subclass */
++	connector_state->tv.brightness = gconn->backlight->props.brightness;
++
++	ret = drm_atomic_commit(state);
++out:
++	if (ret == -EDEADLK) {
++		drm_atomic_state_clear(state);
++		drm_modeset_backoff(&ctx);
++		goto retry;
++	}
++
++	drm_atomic_state_put(state);
++
++	drm_modeset_drop_locks(&ctx);
++	drm_modeset_acquire_fini(&ctx);
++exit:
++	drm_dev_exit(idx);
++
++	if (ret)
++		dev_err(drm->dev, "Failed to update backlight, err=%d\n", ret);
++}
++
++static int gud_connector_backlight_update_status(struct backlight_device *bd)
++{
++	struct drm_connector *connector = bl_get_data(bd);
++	struct gud_connector *gconn = to_gud_connector(connector);
++
++	/* The USB timeout is 5 seconds so use system_long_wq for worst case scenario */
++	queue_work(system_long_wq, &gconn->backlight_work);
++
++	return 0;
++}
++
++static const struct backlight_ops gud_connector_backlight_ops = {
++	.update_status	= gud_connector_backlight_update_status,
++};
++
++static int gud_connector_backlight_register(struct gud_connector *gconn)
++{
++	struct drm_connector *connector = &gconn->connector;
++	struct backlight_device *bd;
++	const char *name;
++	const struct backlight_properties props = {
++		.type = BACKLIGHT_RAW,
++		.scale = BACKLIGHT_SCALE_NON_LINEAR,
++		.max_brightness = 100,
++		.brightness = gconn->initial_brightness,
++	};
++
++	name = kasprintf(GFP_KERNEL, "card%d-%s-backlight",
++			 connector->dev->primary->index, connector->name);
++	if (!name)
++		return -ENOMEM;
++
++	bd = backlight_device_register(name, connector->kdev, connector,
++				       &gud_connector_backlight_ops, &props);
++	kfree(name);
++	if (IS_ERR(bd))
++		return PTR_ERR(bd);
++
++	gconn->backlight = bd;
++
++	return 0;
++}
++
++static int gud_connector_detect(struct drm_connector *connector,
++				struct drm_modeset_acquire_ctx *ctx, bool force)
++{
++	struct gud_device *gdrm = to_gud_device(connector->dev);
++	int idx, ret;
++	u8 status;
++
++	if (!drm_dev_enter(connector->dev, &idx))
++		return connector_status_disconnected;
++
++	if (force) {
++		ret = gud_usb_set(gdrm, GUD_REQ_SET_CONNECTOR_FORCE_DETECT,
++				  connector->index, NULL, 0);
++		if (ret) {
++			ret = connector_status_unknown;
++			goto exit;
++		}
++	}
++
++	ret = gud_usb_get_u8(gdrm, GUD_REQ_GET_CONNECTOR_STATUS, connector->index, &status);
++	if (ret) {
++		ret = connector_status_unknown;
++		goto exit;
++	}
++
++	switch (status & GUD_CONNECTOR_STATUS_CONNECTED_MASK) {
++	case GUD_CONNECTOR_STATUS_DISCONNECTED:
++		ret = connector_status_disconnected;
++		break;
++	case GUD_CONNECTOR_STATUS_CONNECTED:
++		ret = connector_status_connected;
++		break;
++	default:
++		ret = connector_status_unknown;
++		break;
++	};
++
++	if (status & GUD_CONNECTOR_STATUS_CHANGED)
++		connector->epoch_counter += 1;
++exit:
++	drm_dev_exit(idx);
++
++	return ret;
++}
++
++struct gud_connector_get_edid_ctx {
++	void *buf;
++	size_t len;
++	bool edid_override;
++};
++
++static int gud_connector_get_edid_block(void *data, u8 *buf, unsigned int block, size_t len)
++{
++	struct gud_connector_get_edid_ctx *ctx = data;
++	size_t start = block * EDID_LENGTH;
++
++	ctx->edid_override = false;
++
++	if (start + len > ctx->len)
++		return -1;
++
++	memcpy(buf, ctx->buf + start, len);
++
++	return 0;
++}
++
++static int gud_connector_get_modes(struct drm_connector *connector)
++{
++	struct gud_device *gdrm = to_gud_device(connector->dev);
++	struct gud_display_mode_req *reqmodes = NULL;
++	struct gud_connector_get_edid_ctx edid_ctx;
++	unsigned int i, num_modes = 0;
++	struct edid *edid = NULL;
++	int idx, ret;
++
++	if (!drm_dev_enter(connector->dev, &idx))
++		return 0;
++
++	edid_ctx.edid_override = true;
++	edid_ctx.buf = kmalloc(GUD_CONNECTOR_MAX_EDID_LEN, GFP_KERNEL);
++	if (!edid_ctx.buf)
++		goto out;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_CONNECTOR_EDID, connector->index,
++			  edid_ctx.buf, GUD_CONNECTOR_MAX_EDID_LEN);
++	if (ret > 0 && ret % EDID_LENGTH) {
++		gud_conn_err(connector, "Invalid EDID size", ret);
++	} else if (ret > 0) {
++		edid_ctx.len = ret;
++		edid = drm_do_get_edid(connector, gud_connector_get_edid_block, &edid_ctx);
++	}
++
++	kfree(edid_ctx.buf);
++	drm_connector_update_edid_property(connector, edid);
++
++	if (edid && edid_ctx.edid_override)
++		goto out;
++
++	reqmodes = kmalloc_array(GUD_CONNECTOR_MAX_NUM_MODES, sizeof(*reqmodes), GFP_KERNEL);
++	if (!reqmodes)
++		goto out;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_CONNECTOR_MODES, connector->index,
++			  reqmodes, GUD_CONNECTOR_MAX_NUM_MODES * sizeof(*reqmodes));
++	if (ret <= 0)
++		goto out;
++	if (ret % sizeof(*reqmodes)) {
++		gud_conn_err(connector, "Invalid display mode array size", ret);
++		goto out;
++	}
++
++	num_modes = ret / sizeof(*reqmodes);
++
++	for (i = 0; i < num_modes; i++) {
++		struct drm_display_mode *mode;
++
++		mode = drm_mode_create(connector->dev);
++		if (!mode) {
++			num_modes = i;
++			goto out;
++		}
++
++		gud_to_display_mode(mode, &reqmodes[i]);
++		drm_mode_probed_add(connector, mode);
++	}
++out:
++	if (!num_modes)
++		num_modes = drm_add_edid_modes(connector, edid);
++
++	kfree(reqmodes);
++	kfree(edid);
++	drm_dev_exit(idx);
++
++	return num_modes;
++}
++
++static int gud_connector_atomic_check(struct drm_connector *connector,
++				      struct drm_atomic_state *state)
++{
++	struct drm_connector_state *new_state;
++	struct drm_crtc_state *new_crtc_state;
++	struct drm_connector_state *old_state;
++
++	new_state = drm_atomic_get_new_connector_state(state, connector);
++	if (!new_state->crtc)
++		return 0;
++
++	old_state = drm_atomic_get_old_connector_state(state, connector);
++	new_crtc_state = drm_atomic_get_new_crtc_state(state, new_state->crtc);
++
++	if (old_state->tv.margins.left != new_state->tv.margins.left ||
++	    old_state->tv.margins.right != new_state->tv.margins.right ||
++	    old_state->tv.margins.top != new_state->tv.margins.top ||
++	    old_state->tv.margins.bottom != new_state->tv.margins.bottom ||
++	    old_state->tv.mode != new_state->tv.mode ||
++	    old_state->tv.brightness != new_state->tv.brightness ||
++	    old_state->tv.contrast != new_state->tv.contrast ||
++	    old_state->tv.flicker_reduction != new_state->tv.flicker_reduction ||
++	    old_state->tv.overscan != new_state->tv.overscan ||
++	    old_state->tv.saturation != new_state->tv.saturation ||
++	    old_state->tv.hue != new_state->tv.hue)
++		new_crtc_state->connectors_changed = true;
++
++	return 0;
++}
++
++static const struct drm_connector_helper_funcs gud_connector_helper_funcs = {
++	.detect_ctx = gud_connector_detect,
++	.get_modes = gud_connector_get_modes,
++	.atomic_check = gud_connector_atomic_check,
++};
++
++static int gud_connector_late_register(struct drm_connector *connector)
++{
++	struct gud_connector *gconn = to_gud_connector(connector);
++
++	if (gconn->initial_brightness < 0)
++		return 0;
++
++	return gud_connector_backlight_register(gconn);
++}
++
++static void gud_connector_early_unregister(struct drm_connector *connector)
++{
++	struct gud_connector *gconn = to_gud_connector(connector);
++
++	backlight_device_unregister(gconn->backlight);
++	cancel_work_sync(&gconn->backlight_work);
++}
++
++static void gud_connector_destroy(struct drm_connector *connector)
++{
++	struct gud_connector *gconn = to_gud_connector(connector);
++
++	drm_connector_cleanup(connector);
++	kfree(gconn->properties);
++	kfree(gconn);
++}
++
++static void gud_connector_reset(struct drm_connector *connector)
++{
++	struct gud_connector *gconn = to_gud_connector(connector);
++
++	drm_atomic_helper_connector_reset(connector);
++	connector->state->tv = gconn->initial_tv_state;
++	/* Set margins from command line */
++	drm_atomic_helper_connector_tv_reset(connector);
++	if (gconn->initial_brightness >= 0)
++		connector->state->tv.brightness = gconn->initial_brightness;
++}
++
++static const struct drm_connector_funcs gud_connector_funcs = {
++	.fill_modes = drm_helper_probe_single_connector_modes,
++	.late_register = gud_connector_late_register,
++	.early_unregister = gud_connector_early_unregister,
++	.destroy = gud_connector_destroy,
++	.reset = gud_connector_reset,
++	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
++	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
++};
++
++/*
++ * The tv.mode property is shared among the connectors and its enum names are
++ * driver specific. This means that if more than one connector uses tv.mode,
++ * the enum names has to be the same.
++ */
++static int gud_connector_add_tv_mode(struct gud_device *gdrm, struct drm_connector *connector)
++{
++	size_t buf_len = GUD_CONNECTOR_TV_MODE_MAX_NUM * GUD_CONNECTOR_TV_MODE_NAME_LEN;
++	const char *modes[GUD_CONNECTOR_TV_MODE_MAX_NUM];
++	unsigned int i, num_modes;
++	char *buf;
++	int ret;
++
++	buf = kmalloc(buf_len, GFP_KERNEL);
++	if (!buf)
++		return -ENOMEM;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_CONNECTOR_TV_MODE_VALUES,
++			  connector->index, buf, buf_len);
++	if (ret < 0)
++		goto free;
++	if (!ret || ret % GUD_CONNECTOR_TV_MODE_NAME_LEN) {
++		ret = -EIO;
++		goto free;
++	}
++
++	num_modes = ret / GUD_CONNECTOR_TV_MODE_NAME_LEN;
++	for (i = 0; i < num_modes; i++)
++		modes[i] = &buf[i * GUD_CONNECTOR_TV_MODE_NAME_LEN];
++
++	ret = drm_mode_create_tv_properties(connector->dev, num_modes, modes);
++free:
++	kfree(buf);
++	if (ret < 0)
++		gud_conn_err(connector, "Failed to add TV modes", ret);
++
++	return ret;
++}
++
++static struct drm_property *
++gud_connector_property_lookup(struct drm_connector *connector, u16 prop)
++{
++	struct drm_mode_config *config = &connector->dev->mode_config;
++
++	switch (prop) {
++	case GUD_PROPERTY_TV_LEFT_MARGIN:
++		return config->tv_left_margin_property;
++	case GUD_PROPERTY_TV_RIGHT_MARGIN:
++		return config->tv_right_margin_property;
++	case GUD_PROPERTY_TV_TOP_MARGIN:
++		return config->tv_top_margin_property;
++	case GUD_PROPERTY_TV_BOTTOM_MARGIN:
++		return config->tv_bottom_margin_property;
++	case GUD_PROPERTY_TV_MODE:
++		return config->tv_mode_property;
++	case GUD_PROPERTY_TV_BRIGHTNESS:
++		return config->tv_brightness_property;
++	case GUD_PROPERTY_TV_CONTRAST:
++		return config->tv_contrast_property;
++	case GUD_PROPERTY_TV_FLICKER_REDUCTION:
++		return config->tv_flicker_reduction_property;
++	case GUD_PROPERTY_TV_OVERSCAN:
++		return config->tv_overscan_property;
++	case GUD_PROPERTY_TV_SATURATION:
++		return config->tv_saturation_property;
++	case GUD_PROPERTY_TV_HUE:
++		return config->tv_hue_property;
++	default:
++		return ERR_PTR(-EINVAL);
++	}
++}
++
++static unsigned int *gud_connector_tv_state_val(u16 prop, struct drm_tv_connector_state *state)
++{
++	switch (prop) {
++	case GUD_PROPERTY_TV_LEFT_MARGIN:
++		return &state->margins.left;
++	case GUD_PROPERTY_TV_RIGHT_MARGIN:
++		return &state->margins.right;
++	case GUD_PROPERTY_TV_TOP_MARGIN:
++		return &state->margins.top;
++	case GUD_PROPERTY_TV_BOTTOM_MARGIN:
++		return &state->margins.bottom;
++	case GUD_PROPERTY_TV_MODE:
++		return &state->mode;
++	case GUD_PROPERTY_TV_BRIGHTNESS:
++		return &state->brightness;
++	case GUD_PROPERTY_TV_CONTRAST:
++		return &state->contrast;
++	case GUD_PROPERTY_TV_FLICKER_REDUCTION:
++		return &state->flicker_reduction;
++	case GUD_PROPERTY_TV_OVERSCAN:
++		return &state->overscan;
++	case GUD_PROPERTY_TV_SATURATION:
++		return &state->saturation;
++	case GUD_PROPERTY_TV_HUE:
++		return &state->hue;
++	default:
++		return ERR_PTR(-EINVAL);
++	}
++}
++
++static int gud_connector_add_properties(struct gud_device *gdrm, struct gud_connector *gconn)
++{
++	struct drm_connector *connector = &gconn->connector;
++	struct drm_device *drm = &gdrm->drm;
++	struct gud_property_req *properties;
++	unsigned int i, num_properties;
++	int ret;
++
++	properties = kcalloc(GUD_CONNECTOR_PROPERTIES_MAX_NUM, sizeof(*properties), GFP_KERNEL);
++	if (!properties)
++		return -ENOMEM;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_CONNECTOR_PROPERTIES, connector->index,
++			  properties, GUD_CONNECTOR_PROPERTIES_MAX_NUM * sizeof(*properties));
++	if (ret <= 0)
++		goto out;
++	if (ret % sizeof(*properties)) {
++		ret = -EIO;
++		goto out;
++	}
++
++	num_properties = ret / sizeof(*properties);
++	ret = 0;
++
++	gconn->properties = kcalloc(num_properties, sizeof(*gconn->properties), GFP_KERNEL);
++	if (!gconn->properties) {
++		ret = -ENOMEM;
++		goto out;
++	}
++
++	for (i = 0; i < num_properties; i++) {
++		u16 prop = le16_to_cpu(properties[i].prop);
++		u64 val = le64_to_cpu(properties[i].val);
++		struct drm_property *property;
++		unsigned int *state_val;
++
++		drm_dbg(drm, "property: %u = %llu(0x%llx)\n", prop, val, val);
++
++		switch (prop) {
++		case GUD_PROPERTY_TV_LEFT_MARGIN:
++			fallthrough;
++		case GUD_PROPERTY_TV_RIGHT_MARGIN:
++			fallthrough;
++		case GUD_PROPERTY_TV_TOP_MARGIN:
++			fallthrough;
++		case GUD_PROPERTY_TV_BOTTOM_MARGIN:
++			ret = drm_mode_create_tv_margin_properties(drm);
++			if (ret)
++				goto out;
++			break;
++		case GUD_PROPERTY_TV_MODE:
++			ret = gud_connector_add_tv_mode(gdrm, connector);
++			if (ret)
++				goto out;
++			break;
++		case GUD_PROPERTY_TV_BRIGHTNESS:
++			fallthrough;
++		case GUD_PROPERTY_TV_CONTRAST:
++			fallthrough;
++		case GUD_PROPERTY_TV_FLICKER_REDUCTION:
++			fallthrough;
++		case GUD_PROPERTY_TV_OVERSCAN:
++			fallthrough;
++		case GUD_PROPERTY_TV_SATURATION:
++			fallthrough;
++		case GUD_PROPERTY_TV_HUE:
++			/* This is a no-op if already added. */
++			ret = drm_mode_create_tv_properties(drm, 0, NULL);
++			if (ret)
++				goto out;
++			break;
++		case GUD_PROPERTY_BACKLIGHT_BRIGHTNESS:
++			if (val > 100) {
++				ret = -EINVAL;
++				goto out;
++			}
++			gconn->initial_brightness = val;
++			break;
++		default:
++			/* New ones might show up in future devices, skip those we don't know. */
++			drm_dbg(drm, "Ignoring unknown property: %u\n", prop);
++			continue;
++		}
++
++		gconn->properties[gconn->num_properties++] = prop;
++
++		if (prop == GUD_PROPERTY_BACKLIGHT_BRIGHTNESS)
++			continue; /* not a DRM property */
++
++		property = gud_connector_property_lookup(connector, prop);
++		if (WARN_ON(IS_ERR(property)))
++			continue;
++
++		state_val = gud_connector_tv_state_val(prop, &gconn->initial_tv_state);
++		if (WARN_ON(IS_ERR(state_val)))
++			continue;
++
++		*state_val = val;
++		drm_object_attach_property(&connector->base, property, 0);
++	}
++out:
++	kfree(properties);
++
++	return ret;
++}
++
++int gud_connector_fill_properties(struct drm_connector_state *connector_state,
++				  struct gud_property_req *properties)
++{
++	struct gud_connector *gconn = to_gud_connector(connector_state->connector);
++	unsigned int i;
++
++	for (i = 0; i < gconn->num_properties; i++) {
++		u16 prop = gconn->properties[i];
++		u64 val;
++
++		if (prop == GUD_PROPERTY_BACKLIGHT_BRIGHTNESS) {
++			val = connector_state->tv.brightness;
++		} else {
++			unsigned int *state_val;
++
++			state_val = gud_connector_tv_state_val(prop, &connector_state->tv);
++			if (WARN_ON_ONCE(IS_ERR(state_val)))
++				return PTR_ERR(state_val);
++
++			val = *state_val;
++		}
++
++		properties[i].prop = cpu_to_le16(prop);
++		properties[i].val = cpu_to_le64(val);
++	}
++
++	return gconn->num_properties;
++}
++
++static int gud_connector_create(struct gud_device *gdrm, unsigned int index,
++				struct gud_connector_descriptor_req *desc)
++{
++	struct drm_device *drm = &gdrm->drm;
++	struct gud_connector *gconn;
++	struct drm_connector *connector;
++	struct drm_encoder *encoder;
++	int ret, connector_type;
++	u32 flags;
++
++	gconn = kzalloc(sizeof(*gconn), GFP_KERNEL);
++	if (!gconn)
++		return -ENOMEM;
++
++	INIT_WORK(&gconn->backlight_work, gud_connector_backlight_update_status_work);
++	gconn->initial_brightness = -ENODEV;
++	flags = le32_to_cpu(desc->flags);
++	connector = &gconn->connector;
++
++	drm_dbg(drm, "Connector: index=%u type=%u flags=0x%x\n", index, desc->connector_type, flags);
++
++	switch (desc->connector_type) {
++	case GUD_CONNECTOR_TYPE_PANEL:
++		connector_type = DRM_MODE_CONNECTOR_USB;
++		break;
++	case GUD_CONNECTOR_TYPE_VGA:
++		connector_type = DRM_MODE_CONNECTOR_VGA;
++		break;
++	case GUD_CONNECTOR_TYPE_DVI:
++		connector_type = DRM_MODE_CONNECTOR_DVID;
++		break;
++	case GUD_CONNECTOR_TYPE_COMPOSITE:
++		connector_type = DRM_MODE_CONNECTOR_Composite;
++		break;
++	case GUD_CONNECTOR_TYPE_SVIDEO:
++		connector_type = DRM_MODE_CONNECTOR_SVIDEO;
++		break;
++	case GUD_CONNECTOR_TYPE_COMPONENT:
++		connector_type = DRM_MODE_CONNECTOR_Component;
++		break;
++	case GUD_CONNECTOR_TYPE_DISPLAYPORT:
++		connector_type = DRM_MODE_CONNECTOR_DisplayPort;
++		break;
++	case GUD_CONNECTOR_TYPE_HDMI:
++		connector_type = DRM_MODE_CONNECTOR_HDMIA;
++		break;
++	default: /* future types */
++		connector_type = DRM_MODE_CONNECTOR_USB;
++		break;
++	};
++
++	drm_connector_helper_add(connector, &gud_connector_helper_funcs);
++	ret = drm_connector_init(drm, connector, &gud_connector_funcs, connector_type);
++	if (ret) {
++		kfree(connector);
++		return ret;
++	}
++
++	if (WARN_ON(connector->index != index))
++		return -EINVAL;
++
++	if (flags & GUD_CONNECTOR_FLAGS_POLL_STATUS)
++		connector->polled = (DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT);
++	if (flags & GUD_CONNECTOR_FLAGS_INTERLACE)
++		connector->interlace_allowed = true;
++	if (flags & GUD_CONNECTOR_FLAGS_DOUBLESCAN)
++		connector->doublescan_allowed = true;
++
++	ret = gud_connector_add_properties(gdrm, gconn);
++	if (ret) {
++		gud_conn_err(connector, "Failed to add properties", ret);
++		return ret;
++	}
++
++	/* The first connector is attached to the existing simple pipe encoder */
++	if (!connector->index) {
++		encoder = &gdrm->pipe.encoder;
++	} else {
++		encoder = &gconn->encoder;
++
++		ret = drm_simple_encoder_init(drm, encoder, DRM_MODE_ENCODER_NONE);
++		if (ret)
++			return ret;
++
++		encoder->possible_crtcs = 1;
++	}
++
++	return drm_connector_attach_encoder(connector, encoder);
++}
++
++int gud_get_connectors(struct gud_device *gdrm)
++{
++	struct gud_connector_descriptor_req *descs;
++	unsigned int i, num_connectors;
++	int ret;
++
++	descs = kmalloc_array(GUD_CONNECTORS_MAX_NUM, sizeof(*descs), GFP_KERNEL);
++	if (!descs)
++		return -ENOMEM;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_CONNECTORS, 0,
++			  descs, GUD_CONNECTORS_MAX_NUM * sizeof(descs));
++	if (ret < 0)
++		goto free;
++	if (!ret || ret % sizeof(*descs)) {
++		ret = -EIO;
++		goto free;
++	}
++
++	num_connectors = ret / sizeof(*descs);
++
++	for (i = 0; i < num_connectors; i++) {
++		ret = gud_connector_create(gdrm, i, &descs[i]);
++		if (ret)
++			goto free;
++	}
++free:
++	kfree(descs);
++
++	return ret;
++}
+--- /dev/null
++++ b/drivers/gpu/drm/gud/gud_drv.c
+@@ -0,0 +1,674 @@
++// SPDX-License-Identifier: MIT
++/*
++ * Copyright 2020 Noralf Trønnes
++ */
++
++#include <linux/dma-buf.h>
++#include <linux/dma-mapping.h>
++#include <linux/lz4.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++#include <linux/string_helpers.h>
++#include <linux/usb.h>
++#include <linux/vmalloc.h>
++#include <linux/workqueue.h>
++
++#include <drm/drm_atomic_helper.h>
++#include <drm/drm_damage_helper.h>
++#include <drm/drm_debugfs.h>
++#include <drm/drm_drv.h>
++#include <drm/drm_fb_helper.h>
++#include <drm/drm_fourcc.h>
++#include <drm/drm_gem_framebuffer_helper.h>
++#include <drm/drm_gem_shmem_helper.h>
++#include <drm/drm_managed.h>
++#include <drm/drm_print.h>
++#include <drm/drm_probe_helper.h>
++#include <drm/drm_simple_kms_helper.h>
++#include <drm/gud.h>
++
++#include "gud_internal.h"
++
++/* Only used internally */
++static const struct drm_format_info gud_drm_format_r1 = {
++	.format = GUD_DRM_FORMAT_R1,
++	.num_planes = 1,
++	.char_per_block = { 1, 0, 0 },
++	.block_w = { 8, 0, 0 },
++	.block_h = { 1, 0, 0 },
++	.hsub = 1,
++	.vsub = 1,
++};
++
++static const struct drm_format_info gud_drm_format_xrgb1111 = {
++	.format = GUD_DRM_FORMAT_XRGB1111,
++	.num_planes = 1,
++	.char_per_block = { 1, 0, 0 },
++	.block_w = { 2, 0, 0 },
++	.block_h = { 1, 0, 0 },
++	.hsub = 1,
++	.vsub = 1,
++};
++
++static int gud_usb_control_msg(struct usb_interface *intf, bool in,
++			       u8 request, u16 value, void *buf, size_t len)
++{
++	u8 requesttype = USB_TYPE_VENDOR | USB_RECIP_INTERFACE;
++	u8 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
++	struct usb_device *usb = interface_to_usbdev(intf);
++	unsigned int pipe;
++
++	if (len && !buf)
++		return -EINVAL;
++
++	if (in) {
++		pipe = usb_rcvctrlpipe(usb, 0);
++		requesttype |= USB_DIR_IN;
++	} else {
++		pipe = usb_sndctrlpipe(usb, 0);
++		requesttype |= USB_DIR_OUT;
++	}
++
++	return usb_control_msg(usb, pipe, request, requesttype, value,
++			       ifnum, buf, len, USB_CTRL_GET_TIMEOUT);
++}
++
++static int gud_get_display_descriptor(struct usb_interface *intf,
++				      struct gud_display_descriptor_req *desc)
++{
++	void *buf;
++	int ret;
++
++	buf = kmalloc(sizeof(*desc), GFP_KERNEL);
++	if (!buf)
++		return -ENOMEM;
++
++	ret = gud_usb_control_msg(intf, true, GUD_REQ_GET_DESCRIPTOR, 0, buf, sizeof(*desc));
++	memcpy(desc, buf, sizeof(*desc));
++	kfree(buf);
++	if (ret < 0)
++		return ret;
++	if (ret != sizeof(*desc))
++		return -EIO;
++
++	if (desc->magic != le32_to_cpu(GUD_DISPLAY_MAGIC))
++		return -ENODATA;
++
++	DRM_DEV_DEBUG_DRIVER(&intf->dev,
++			     "version=%u flags=0x%x compression=0x%x max_buffer_size=%u\n",
++			     desc->version, le32_to_cpu(desc->flags), desc->compression,
++			     le32_to_cpu(desc->max_buffer_size));
++
++	if (!desc->version || !desc->max_width || !desc->max_height ||
++	    le32_to_cpu(desc->min_width) > le32_to_cpu(desc->max_width) ||
++	    le32_to_cpu(desc->min_height) > le32_to_cpu(desc->max_height))
++		return -EINVAL;
++
++	return 0;
++}
++
++static int gud_status_to_errno(u8 status)
++{
++	switch (status) {
++	case GUD_STATUS_OK:
++		return 0;
++	case GUD_STATUS_BUSY:
++		return -EBUSY;
++	case GUD_STATUS_REQUEST_NOT_SUPPORTED:
++		return -EOPNOTSUPP;
++	case GUD_STATUS_PROTOCOL_ERROR:
++		return -EPROTO;
++	case GUD_STATUS_INVALID_PARAMETER:
++		return -EINVAL;
++	case GUD_STATUS_ERROR:
++		return -EREMOTEIO;
++	default:
++		return -EREMOTEIO;
++	}
++}
++
++static int gud_usb_get_status(struct usb_interface *intf)
++{
++	int ret, status = -EIO;
++	u8 *buf;
++
++	buf = kmalloc(sizeof(*buf), GFP_KERNEL);
++	if (!buf)
++		return -ENOMEM;
++
++	ret = gud_usb_control_msg(intf, true, GUD_REQ_GET_STATUS, 0, buf, sizeof(*buf));
++	if (ret == sizeof(*buf))
++		status = gud_status_to_errno(*buf);
++	kfree(buf);
++
++	if (ret < 0)
++		return ret;
++
++	return status;
++}
++
++static int gud_usb_transfer(struct gud_device *gdrm, bool in, u8 request, u16 index,
++			    void *buf, size_t len)
++{
++	struct usb_interface *intf = to_usb_interface(gdrm->drm.dev);
++	int idx, ret;
++
++	drm_dbg(&gdrm->drm, "%s: request=0x%x index=%u len=%zu\n",
++		in ? "get" : "set", request, index, len);
++
++	if (!drm_dev_enter(&gdrm->drm, &idx))
++		return -ENODEV;
++
++	mutex_lock(&gdrm->ctrl_lock);
++
++	ret = gud_usb_control_msg(intf, in, request, index, buf, len);
++	if (ret == -EPIPE || ((gdrm->flags & GUD_DISPLAY_FLAG_STATUS_ON_SET) && !in && ret >= 0)) {
++		int status;
++
++		status = gud_usb_get_status(intf);
++		if (status < 0) {
++			ret = status;
++		} else if (ret < 0) {
++			dev_err_once(gdrm->drm.dev,
++				     "Unexpected status OK for failed transfer\n");
++			ret = -EPIPE;
++		}
++	}
++
++	if (ret < 0) {
++		drm_dbg(&gdrm->drm, "ret=%d\n", ret);
++		gdrm->stats_num_errors++;
++	}
++
++	mutex_unlock(&gdrm->ctrl_lock);
++	drm_dev_exit(idx);
++
++	return ret;
++}
++
++/*
++ * @buf cannot be allocated on the stack.
++ * Returns number of bytes received or negative error code on failure.
++ */
++int gud_usb_get(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t max_len)
++{
++	return gud_usb_transfer(gdrm, true, request, index, buf, max_len);
++}
++
++/*
++ * @buf can be allocated on the stack or NULL.
++ * Returns zero on success or negative error code on failure.
++ */
++int gud_usb_set(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len)
++{
++	void *trbuf = NULL;
++	int ret;
++
++	if (buf && len) {
++		trbuf = kmemdup(buf, len, GFP_KERNEL);
++		if (!trbuf)
++			return -ENOMEM;
++	}
++
++	ret = gud_usb_transfer(gdrm, false, request, index, trbuf, len);
++	kfree(trbuf);
++	if (ret < 0)
++		return ret;
++
++	return ret != len ? -EIO : 0;
++}
++
++/*
++ * @val can be allocated on the stack.
++ * Returns zero on success or negative error code on failure.
++ */
++int gud_usb_get_u8(struct gud_device *gdrm, u8 request, u16 index, u8 *val)
++{
++	u8 *buf;
++	int ret;
++
++	buf = kmalloc(sizeof(*val), GFP_KERNEL);
++	if (!buf)
++		return -ENOMEM;
++
++	ret = gud_usb_get(gdrm, request, index, buf, sizeof(*val));
++	*val = *buf;
++	kfree(buf);
++	if (ret < 0)
++		return ret;
++
++	return ret != sizeof(*val) ? -EIO : 0;
++}
++
++/* Returns zero on success or negative error code on failure. */
++int gud_usb_set_u8(struct gud_device *gdrm, u8 request, u8 val)
++{
++	return gud_usb_set(gdrm, request, 0, &val, sizeof(val));
++}
++
++static int gud_get_properties(struct gud_device *gdrm)
++{
++	struct gud_property_req *properties;
++	unsigned int i, num_properties;
++	int ret;
++
++	properties = kcalloc(GUD_PROPERTIES_MAX_NUM, sizeof(*properties), GFP_KERNEL);
++	if (!properties)
++		return -ENOMEM;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_PROPERTIES, 0,
++			  properties, GUD_PROPERTIES_MAX_NUM * sizeof(*properties));
++	if (ret <= 0)
++		goto out;
++	if (ret % sizeof(*properties)) {
++		ret = -EIO;
++		goto out;
++	}
++
++	num_properties = ret / sizeof(*properties);
++	ret = 0;
++
++	gdrm->properties = drmm_kcalloc(&gdrm->drm, num_properties, sizeof(*gdrm->properties),
++					GFP_KERNEL);
++	if (!gdrm->properties) {
++		ret = -ENOMEM;
++		goto out;
++	}
++
++	for (i = 0; i < num_properties; i++) {
++		u16 prop = le16_to_cpu(properties[i].prop);
++		u64 val = le64_to_cpu(properties[i].val);
++
++		switch (prop) {
++		case GUD_PROPERTY_ROTATION:
++			/*
++			 * DRM UAPI matches the protocol so use the value directly,
++			 * but mask out any additions on future devices.
++			 */
++			val &= GUD_ROTATION_MASK;
++			ret = drm_plane_create_rotation_property(&gdrm->pipe.plane,
++								 DRM_MODE_ROTATE_0, val);
++			break;
++		default:
++			/* New ones might show up in future devices, skip those we don't know. */
++			drm_dbg(&gdrm->drm, "Ignoring unknown property: %u\n", prop);
++			continue;
++		}
++
++		if (ret)
++			goto out;
++
++		gdrm->properties[gdrm->num_properties++] = prop;
++	}
++out:
++	kfree(properties);
++
++	return ret;
++}
++
++static struct drm_gem_object *gud_gem_create_object(struct drm_device *dev, size_t size)
++{
++	struct drm_gem_shmem_object *shmem;
++
++	shmem = kzalloc(sizeof(*shmem), GFP_KERNEL);
++	if (!shmem)
++		return NULL;
++
++	shmem->map_cached = true;
++
++	return &shmem->base;
++}
++
++/*
++ * FIXME: Dma-buf sharing requires DMA support by the importing device.
++ *        This function is a workaround to make USB devices work as well.
++ *        See todo.rst for how to fix the issue in the dma-buf framework.
++ */
++static struct drm_gem_object *gud_gem_prime_import(struct drm_device *drm, struct dma_buf *dma_buf)
++{
++	struct gud_device *gdrm = to_gud_device(drm);
++
++	if (!gdrm->dmadev)
++		return ERR_PTR(-ENODEV);
++
++	return drm_gem_prime_import_dev(drm, dma_buf, gdrm->dmadev);
++}
++
++static int gud_stats_debugfs(struct seq_file *m, void *data)
++{
++	struct drm_info_node *node = m->private;
++	struct gud_device *gdrm = to_gud_device(node->minor->dev);
++	char buf[10];
++
++	string_get_size(gdrm->bulk_len, 1, STRING_UNITS_2, buf, sizeof(buf));
++	seq_printf(m, "Max buffer size: %s\n", buf);
++	seq_printf(m, "Number of errors:  %u\n", gdrm->stats_num_errors);
++
++	seq_puts(m, "Compression:      ");
++	if (gdrm->compression & GUD_COMPRESSION_LZ4)
++		seq_puts(m, " lz4");
++	if (!gdrm->compression)
++		seq_puts(m, " none");
++	seq_puts(m, "\n");
++
++	if (gdrm->compression) {
++		u64 remainder;
++		u64 ratio = div64_u64_rem(gdrm->stats_length, gdrm->stats_actual_length,
++					  &remainder);
++		u64 ratio_frac = div64_u64(remainder * 10, gdrm->stats_actual_length);
++
++		seq_printf(m, "Compression ratio: %llu.%llu\n", ratio, ratio_frac);
++	}
++
++	return 0;
++}
++
++static const struct drm_info_list gud_debugfs_list[] = {
++	{ "stats", gud_stats_debugfs, 0, NULL },
++};
++
++static void gud_debugfs_init(struct drm_minor *minor)
++{
++	drm_debugfs_create_files(gud_debugfs_list, ARRAY_SIZE(gud_debugfs_list),
++				 minor->debugfs_root, minor);
++}
++
++static const struct drm_simple_display_pipe_funcs gud_pipe_funcs = {
++	.check      = gud_pipe_check,
++	.update	    = gud_pipe_update,
++	.prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
++};
++
++static const struct drm_mode_config_funcs gud_mode_config_funcs = {
++	.fb_create = drm_gem_fb_create_with_dirty,
++	.atomic_check = drm_atomic_helper_check,
++	.atomic_commit = drm_atomic_helper_commit,
++};
++
++static const u64 gud_pipe_modifiers[] = {
++	DRM_FORMAT_MOD_LINEAR,
++	DRM_FORMAT_MOD_INVALID
++};
++
++DEFINE_DRM_GEM_FOPS(gud_fops);
++
++static struct drm_driver gud_drm_driver = {
++	.driver_features	= DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
++	.fops			= &gud_fops,
++	DRM_GEM_SHMEM_DRIVER_OPS,
++	.gem_create_object	= gud_gem_create_object,
++	.gem_prime_import	= gud_gem_prime_import,
++	.debugfs_init		= gud_debugfs_init,
++
++	.name			= "gud",
++	.desc			= "Generic USB Display",
++	.date			= "20200422",
++	.major			= 1,
++	.minor			= 0,
++};
++
++static void gud_free_buffers_and_mutex(struct drm_device *drm, void *unused)
++{
++	struct gud_device *gdrm = to_gud_device(drm);
++
++	vfree(gdrm->compress_buf);
++	kfree(gdrm->bulk_buf);
++	mutex_destroy(&gdrm->ctrl_lock);
++	mutex_destroy(&gdrm->damage_lock);
++}
++
++static int gud_probe(struct usb_interface *intf, const struct usb_device_id *id)
++{
++	const struct drm_format_info *xrgb8888_emulation_format = NULL;
++	bool rgb565_supported = false, xrgb8888_supported = false;
++	unsigned int num_formats_dev, num_formats = 0;
++	struct usb_endpoint_descriptor *bulk_out;
++	struct gud_display_descriptor_req desc;
++	struct device *dev = &intf->dev;
++	size_t max_buffer_size = 0;
++	struct gud_device *gdrm;
++	struct drm_device *drm;
++	u8 *formats_dev;
++	u32 *formats;
++	int ret, i;
++
++	ret = usb_find_bulk_out_endpoint(intf->cur_altsetting, &bulk_out);
++	if (ret)
++		return ret;
++
++	ret = gud_get_display_descriptor(intf, &desc);
++	if (ret) {
++		DRM_DEV_DEBUG_DRIVER(dev, "Not a display interface: ret=%d\n", ret);
++		return -ENODEV;
++	}
++
++	if (desc.version > 1) {
++		dev_err(dev, "Protocol version %u is not supported\n", desc.version);
++		return -ENODEV;
++	}
++
++	gdrm = devm_drm_dev_alloc(dev, &gud_drm_driver, struct gud_device, drm);
++	if (IS_ERR(gdrm))
++		return PTR_ERR(gdrm);
++
++	drm = &gdrm->drm;
++	drm->mode_config.funcs = &gud_mode_config_funcs;
++	ret = drmm_mode_config_init(drm);
++	if (ret)
++		return ret;
++
++	gdrm->flags = le32_to_cpu(desc.flags);
++	gdrm->compression = desc.compression & GUD_COMPRESSION_LZ4;
++
++	if (gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE && gdrm->compression)
++		return -EINVAL;
++
++	mutex_init(&gdrm->ctrl_lock);
++	mutex_init(&gdrm->damage_lock);
++	INIT_WORK(&gdrm->work, gud_flush_work);
++	gud_clear_damage(gdrm);
++
++	ret = drmm_add_action_or_reset(drm, gud_free_buffers_and_mutex, NULL);
++	if (ret)
++		return ret;
++
++	drm->mode_config.min_width = le32_to_cpu(desc.min_width);
++	drm->mode_config.max_width = le32_to_cpu(desc.max_width);
++	drm->mode_config.min_height = le32_to_cpu(desc.min_height);
++	drm->mode_config.max_height = le32_to_cpu(desc.max_height);
++
++	formats_dev = devm_kmalloc(dev, GUD_FORMATS_MAX_NUM, GFP_KERNEL);
++	/* Add room for emulated XRGB8888 */
++	formats = devm_kmalloc_array(dev, GUD_FORMATS_MAX_NUM + 1, sizeof(*formats), GFP_KERNEL);
++	if (!formats_dev || !formats)
++		return -ENOMEM;
++
++	ret = gud_usb_get(gdrm, GUD_REQ_GET_FORMATS, 0, formats_dev, GUD_FORMATS_MAX_NUM);
++	if (ret < 0)
++		return ret;
++
++	num_formats_dev = ret;
++	for (i = 0; i < num_formats_dev; i++) {
++		const struct drm_format_info *info;
++		size_t fmt_buf_size;
++		u32 format;
++
++		format = gud_to_fourcc(formats_dev[i]);
++		if (!format) {
++			drm_dbg(drm, "Unsupported format: 0x%02x\n", formats_dev[i]);
++			continue;
++		}
++
++		if (format == GUD_DRM_FORMAT_R1)
++			info = &gud_drm_format_r1;
++		else if (format == GUD_DRM_FORMAT_XRGB1111)
++			info = &gud_drm_format_xrgb1111;
++		else
++			info = drm_format_info(format);
++
++		switch (format) {
++		case GUD_DRM_FORMAT_R1:
++			fallthrough;
++		case GUD_DRM_FORMAT_XRGB1111:
++			if (!xrgb8888_emulation_format)
++				xrgb8888_emulation_format = info;
++			break;
++		case DRM_FORMAT_RGB565:
++			rgb565_supported = true;
++			if (!xrgb8888_emulation_format)
++				xrgb8888_emulation_format = info;
++			break;
++		case DRM_FORMAT_XRGB8888:
++			xrgb8888_supported = true;
++			break;
++		};
++
++		fmt_buf_size = drm_format_info_min_pitch(info, 0, drm->mode_config.max_width) *
++			       drm->mode_config.max_height;
++		max_buffer_size = max(max_buffer_size, fmt_buf_size);
++
++		if (format == GUD_DRM_FORMAT_R1 || format == GUD_DRM_FORMAT_XRGB1111)
++			continue; /* Internal not for userspace */
++
++		formats[num_formats++] = format;
++	}
++
++	if (!num_formats && !xrgb8888_emulation_format) {
++		dev_err(dev, "No supported pixel formats found\n");
++		return -EINVAL;
++	}
++
++	/* Prefer speed over color depth */
++	if (rgb565_supported)
++		drm->mode_config.preferred_depth = 16;
++
++	if (!xrgb8888_supported && xrgb8888_emulation_format) {
++		gdrm->xrgb8888_emulation_format = xrgb8888_emulation_format;
++		formats[num_formats++] = DRM_FORMAT_XRGB8888;
++	}
++
++	if (desc.max_buffer_size)
++		max_buffer_size = le32_to_cpu(desc.max_buffer_size);
++retry:
++	/*
++	 * Use plain kmalloc here since devm_kmalloc() places struct devres at the beginning
++	 * of the buffer it allocates. This wastes a lot of memory when allocating big buffers.
++	 * Asking for 2M would actually allocate 4M. This would also prevent getting the biggest
++	 * possible buffer potentially leading to split transfers.
++	 */
++	gdrm->bulk_buf = kmalloc(max_buffer_size, GFP_KERNEL | __GFP_NOWARN);
++	if (!gdrm->bulk_buf) {
++		max_buffer_size = roundup_pow_of_two(max_buffer_size) / 2;
++		if (max_buffer_size < SZ_512K)
++			return -ENOMEM;
++		goto retry;
++	}
++
++	gdrm->bulk_pipe = usb_sndbulkpipe(interface_to_usbdev(intf), usb_endpoint_num(bulk_out));
++	gdrm->bulk_len = max_buffer_size;
++
++	if (gdrm->compression & GUD_COMPRESSION_LZ4) {
++		gdrm->lz4_comp_mem = devm_kmalloc(dev, LZ4_MEM_COMPRESS, GFP_KERNEL);
++		if (!gdrm->lz4_comp_mem)
++			return -ENOMEM;
++
++		gdrm->compress_buf = vmalloc(gdrm->bulk_len);
++		if (!gdrm->compress_buf)
++			return -ENOMEM;
++	}
++
++	ret = drm_simple_display_pipe_init(drm, &gdrm->pipe, &gud_pipe_funcs,
++					   formats, num_formats,
++					   gud_pipe_modifiers, NULL);
++	if (ret)
++		return ret;
++
++	devm_kfree(dev, formats);
++	devm_kfree(dev, formats_dev);
++
++	ret = gud_get_properties(gdrm);
++	if (ret) {
++		dev_err(dev, "Failed to get properties (error=%d)\n", ret);
++		return ret;
++	}
++
++	drm_plane_enable_fb_damage_clips(&gdrm->pipe.plane);
++
++	ret = gud_get_connectors(gdrm);
++	if (ret) {
++		dev_err(dev, "Failed to get connectors (error=%d)\n", ret);
++		return ret;
++	}
++
++	drm_mode_config_reset(drm);
++
++	usb_set_intfdata(intf, gdrm);
++
++	gdrm->dmadev = usb_intf_get_dma_device(intf);
++	if (!gdrm->dmadev)
++		dev_warn(dev, "buffer sharing not supported");
++
++	ret = drm_dev_register(drm, 0);
++	if (ret) {
++		put_device(gdrm->dmadev);
++		return ret;
++	}
++
++	drm_kms_helper_poll_init(drm);
++
++	drm_fbdev_generic_setup(drm, 0);
++
++	return 0;
++}
++
++static void gud_disconnect(struct usb_interface *interface)
++{
++	struct gud_device *gdrm = usb_get_intfdata(interface);
++	struct drm_device *drm = &gdrm->drm;
++
++	drm_dbg(drm, "%s:\n", __func__);
++
++	drm_kms_helper_poll_fini(drm);
++	drm_dev_unplug(drm);
++	drm_atomic_helper_shutdown(drm);
++	put_device(gdrm->dmadev);
++	gdrm->dmadev = NULL;
++}
++
++static int gud_suspend(struct usb_interface *intf, pm_message_t message)
++{
++	struct gud_device *gdrm = usb_get_intfdata(intf);
++
++	return drm_mode_config_helper_suspend(&gdrm->drm);
++}
++
++static int gud_resume(struct usb_interface *intf)
++{
++	struct gud_device *gdrm = usb_get_intfdata(intf);
++
++	drm_mode_config_helper_resume(&gdrm->drm);
++
++	return 0;
++}
++
++static const struct usb_device_id gud_id_table[] = {
++	{ USB_DEVICE_INTERFACE_CLASS(0x1d50, 0x614d, USB_CLASS_VENDOR_SPEC) },
++	{ }
++};
++
++MODULE_DEVICE_TABLE(usb, gud_id_table);
++
++static struct usb_driver gud_usb_driver = {
++	.name		= "gud",
++	.probe		= gud_probe,
++	.disconnect	= gud_disconnect,
++	.id_table	= gud_id_table,
++	.suspend	= gud_suspend,
++	.resume		= gud_resume,
++	.reset_resume	= gud_resume,
++};
++
++module_usb_driver(gud_usb_driver);
++
++MODULE_AUTHOR("Noralf Trønnes");
++MODULE_LICENSE("Dual MIT/GPL");
+--- /dev/null
++++ b/drivers/gpu/drm/gud/gud_internal.h
+@@ -0,0 +1,154 @@
++/* SPDX-License-Identifier: MIT */
++
++#ifndef __LINUX_GUD_INTERNAL_H
++#define __LINUX_GUD_INTERNAL_H
++
++#include <linux/list.h>
++#include <linux/mutex.h>
++#include <linux/usb.h>
++#include <linux/workqueue.h>
++#include <uapi/drm/drm_fourcc.h>
++
++#include <drm/drm_modes.h>
++#include <drm/drm_simple_kms_helper.h>
++
++struct gud_device {
++	struct drm_device drm;
++	struct drm_simple_display_pipe pipe;
++	struct device *dmadev;
++	struct work_struct work;
++	u32 flags;
++	const struct drm_format_info *xrgb8888_emulation_format;
++
++	u16 *properties;
++	unsigned int num_properties;
++
++	unsigned int bulk_pipe;
++	void *bulk_buf;
++	size_t bulk_len;
++
++	u8 compression;
++	void *lz4_comp_mem;
++	void *compress_buf;
++
++	u64 stats_length;
++	u64 stats_actual_length;
++	unsigned int stats_num_errors;
++
++	struct mutex ctrl_lock; /* Serialize get/set and status transfers */
++
++	struct mutex damage_lock; /* Protects the following members: */
++	struct drm_framebuffer *fb;
++	struct drm_rect damage;
++	bool prev_flush_failed;
++};
++
++static inline struct gud_device *to_gud_device(struct drm_device *drm)
++{
++	return container_of(drm, struct gud_device, drm);
++}
++
++static inline struct usb_device *gud_to_usb_device(struct gud_device *gdrm)
++{
++	return interface_to_usbdev(to_usb_interface(gdrm->drm.dev));
++}
++
++int gud_usb_get(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len);
++int gud_usb_set(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len);
++int gud_usb_get_u8(struct gud_device *gdrm, u8 request, u16 index, u8 *val);
++int gud_usb_set_u8(struct gud_device *gdrm, u8 request, u8 val);
++
++void gud_clear_damage(struct gud_device *gdrm);
++void gud_flush_work(struct work_struct *work);
++int gud_pipe_check(struct drm_simple_display_pipe *pipe,
++		   struct drm_plane_state *new_plane_state,
++		   struct drm_crtc_state *new_crtc_state);
++void gud_pipe_update(struct drm_simple_display_pipe *pipe,
++		     struct drm_plane_state *old_state);
++int gud_connector_fill_properties(struct drm_connector_state *connector_state,
++				  struct gud_property_req *properties);
++int gud_get_connectors(struct gud_device *gdrm);
++
++/* Driver internal fourcc transfer formats */
++#define GUD_DRM_FORMAT_R1		0x00000122
++#define GUD_DRM_FORMAT_XRGB1111		0x03121722
++
++static inline u8 gud_from_fourcc(u32 fourcc)
++{
++	switch (fourcc) {
++	case GUD_DRM_FORMAT_R1:
++		return GUD_PIXEL_FORMAT_R1;
++	case GUD_DRM_FORMAT_XRGB1111:
++		return GUD_PIXEL_FORMAT_XRGB1111;
++	case DRM_FORMAT_RGB565:
++		return GUD_PIXEL_FORMAT_RGB565;
++	case DRM_FORMAT_XRGB8888:
++		return GUD_PIXEL_FORMAT_XRGB8888;
++	case DRM_FORMAT_ARGB8888:
++		return GUD_PIXEL_FORMAT_ARGB8888;
++	};
++
++	return 0;
++}
++
++static inline u32 gud_to_fourcc(u8 format)
++{
++	switch (format) {
++	case GUD_PIXEL_FORMAT_R1:
++		return GUD_DRM_FORMAT_R1;
++	case GUD_PIXEL_FORMAT_XRGB1111:
++		return GUD_DRM_FORMAT_XRGB1111;
++	case GUD_PIXEL_FORMAT_RGB565:
++		return DRM_FORMAT_RGB565;
++	case GUD_PIXEL_FORMAT_XRGB8888:
++		return DRM_FORMAT_XRGB8888;
++	case GUD_PIXEL_FORMAT_ARGB8888:
++		return DRM_FORMAT_ARGB8888;
++	};
++
++	return 0;
++}
++
++static inline void gud_from_display_mode(struct gud_display_mode_req *dst,
++					 const struct drm_display_mode *src)
++{
++	u32 flags = src->flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;
++
++	if (src->type & DRM_MODE_TYPE_PREFERRED)
++		flags |= GUD_DISPLAY_MODE_FLAG_PREFERRED;
++
++	dst->clock = cpu_to_le32(src->clock);
++	dst->hdisplay = cpu_to_le16(src->hdisplay);
++	dst->hsync_start = cpu_to_le16(src->hsync_start);
++	dst->hsync_end = cpu_to_le16(src->hsync_end);
++	dst->htotal = cpu_to_le16(src->htotal);
++	dst->vdisplay = cpu_to_le16(src->vdisplay);
++	dst->vsync_start = cpu_to_le16(src->vsync_start);
++	dst->vsync_end = cpu_to_le16(src->vsync_end);
++	dst->vtotal = cpu_to_le16(src->vtotal);
++	dst->flags = cpu_to_le32(flags);
++}
++
++static inline void gud_to_display_mode(struct drm_display_mode *dst,
++				       const struct gud_display_mode_req *src)
++{
++	u32 flags = le32_to_cpu(src->flags);
++
++	memset(dst, 0, sizeof(*dst));
++	dst->clock = le32_to_cpu(src->clock);
++	dst->hdisplay = le16_to_cpu(src->hdisplay);
++	dst->hsync_start = le16_to_cpu(src->hsync_start);
++	dst->hsync_end = le16_to_cpu(src->hsync_end);
++	dst->htotal = le16_to_cpu(src->htotal);
++	dst->vdisplay = le16_to_cpu(src->vdisplay);
++	dst->vsync_start = le16_to_cpu(src->vsync_start);
++	dst->vsync_end = le16_to_cpu(src->vsync_end);
++	dst->vtotal = le16_to_cpu(src->vtotal);
++	dst->flags = flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;
++	dst->type = DRM_MODE_TYPE_DRIVER;
++	if (flags & GUD_DISPLAY_MODE_FLAG_PREFERRED)
++		dst->type |= DRM_MODE_TYPE_PREFERRED;
++	drm_mode_set_name(dst);
++}
++
++#endif
+--- /dev/null
++++ b/drivers/gpu/drm/gud/gud_pipe.c
+@@ -0,0 +1,551 @@
++// SPDX-License-Identifier: MIT
++/*
++ * Copyright 2020 Noralf Trønnes
++ */
++
++#include <linux/dma-buf.h>
++#include <linux/lz4.h>
++#include <linux/usb.h>
++#include <linux/workqueue.h>
++
++#include <drm/drm_atomic.h>
++#include <drm/drm_connector.h>
++#include <drm/drm_damage_helper.h>
++#include <drm/drm_drv.h>
++#include <drm/drm_format_helper.h>
++#include <drm/drm_fourcc.h>
++#include <drm/drm_framebuffer.h>
++#include <drm/drm_gem_shmem_helper.h>
++#include <drm/drm_print.h>
++#include <drm/drm_rect.h>
++#include <drm/drm_simple_kms_helper.h>
++#include <drm/gud.h>
++
++#include "gud_internal.h"
++
++/*
++ * FIXME: The driver is probably broken on Big Endian machines.
++ * See discussion:
++ * https://lore.kernel.org/dri-devel/CAKb7UvihLX0hgBOP3VBG7O+atwZcUVCPVuBdfmDMpg0NjXe-cQ@mail.gmail.com/
++ */
++
++static bool gud_is_big_endian(void)
++{
++#if defined(__BIG_ENDIAN)
++	return true;
++#else
++	return false;
++#endif
++}
++
++static size_t gud_xrgb8888_to_r124(u8 *dst, const struct drm_format_info *format,
++				   void *src, struct drm_framebuffer *fb,
++				   struct drm_rect *rect)
++{
++	unsigned int block_width = drm_format_info_block_width(format, 0);
++	unsigned int bits_per_pixel = 8 / block_width;
++	unsigned int x, y, width, height;
++	u8 pix, *pix8, *block = dst; /* Assign to silence compiler warning */
++	size_t len;
++	void *buf;
++
++	WARN_ON_ONCE(format->char_per_block[0] != 1);
++
++	/* Start on a byte boundary */
++	rect->x1 = ALIGN_DOWN(rect->x1, block_width);
++	width = drm_rect_width(rect);
++	height = drm_rect_height(rect);
++	len = drm_format_info_min_pitch(format, 0, width) * height;
++
++	buf = kmalloc(width * height, GFP_KERNEL);
++	if (!buf)
++		return 0;
++
++	drm_fb_xrgb8888_to_gray8(buf, src, fb, rect);
++	pix8 = buf;
++
++	for (y = 0; y < height; y++) {
++		for (x = 0; x < width; x++) {
++			unsigned int pixpos = x % block_width; /* within byte from the left */
++			unsigned int pixshift = (block_width - pixpos - 1) * bits_per_pixel;
++
++			if (!pixpos) {
++				block = dst++;
++				*block = 0;
++			}
++
++			pix = (*pix8++) >> (8 - bits_per_pixel);
++			*block |= pix << pixshift;
++		}
++	}
++
++	kfree(buf);
++
++	return len;
++}
++
++static size_t gud_xrgb8888_to_color(u8 *dst, const struct drm_format_info *format,
++				    void *src, struct drm_framebuffer *fb,
++				    struct drm_rect *rect)
++{
++	unsigned int block_width = drm_format_info_block_width(format, 0);
++	unsigned int bits_per_pixel = 8 / block_width;
++	u8 r, g, b, pix, *block = dst; /* Assign to silence compiler warning */
++	unsigned int x, y, width;
++	u32 *pix32;
++	size_t len;
++
++	/* Start on a byte boundary */
++	rect->x1 = ALIGN_DOWN(rect->x1, block_width);
++	width = drm_rect_width(rect);
++	len = drm_format_info_min_pitch(format, 0, width) * drm_rect_height(rect);
++
++	for (y = rect->y1; y < rect->y2; y++) {
++		pix32 = src + (y * fb->pitches[0]);
++		pix32 += rect->x1;
++
++		for (x = 0; x < width; x++) {
++			unsigned int pixpos = x % block_width; /* within byte from the left */
++			unsigned int pixshift = (block_width - pixpos - 1) * bits_per_pixel;
++
++			if (!pixpos) {
++				block = dst++;
++				*block = 0;
++			}
++
++			r = *pix32 >> 16;
++			g = *pix32 >> 8;
++			b = *pix32++;
++
++			switch (format->format) {
++			case GUD_DRM_FORMAT_XRGB1111:
++				pix = ((r >> 7) << 2) | ((g >> 7) << 1) | (b >> 7);
++				break;
++			default:
++				WARN_ON_ONCE(1);
++				return len;
++			};
++
++			*block |= pix << pixshift;
++		}
++	}
++
++	return len;
++}
++
++static int gud_prep_flush(struct gud_device *gdrm, struct drm_framebuffer *fb,
++			  const struct drm_format_info *format, struct drm_rect *rect,
++			  struct gud_set_buffer_req *req)
++{
++	struct dma_buf_attachment *import_attach = fb->obj[0]->import_attach;
++	u8 compression = gdrm->compression;
++	void *vmap, *vaddr, *buf;
++	size_t pitch, len;
++	int ret = 0;
++
++	pitch = drm_format_info_min_pitch(format, 0, drm_rect_width(rect));
++	len = pitch * drm_rect_height(rect);
++	if (len > gdrm->bulk_len)
++		return -E2BIG;
++
++	vmap = drm_gem_shmem_vmap(fb->obj[0]);
++	if (!vmap)
++		return -ENOMEM;
++
++	vaddr = vmap + fb->offsets[0];
++
++	if (import_attach) {
++		ret = dma_buf_begin_cpu_access(import_attach->dmabuf, DMA_FROM_DEVICE);
++		if (ret)
++			goto vunmap;
++	}
++retry:
++	if (compression)
++		buf = gdrm->compress_buf;
++	else
++		buf = gdrm->bulk_buf;
++
++	/*
++	 * Imported buffers are assumed to be write-combined and thus uncached
++	 * with slow reads (at least on ARM).
++	 */
++	if (format != fb->format) {
++		if (format->format == GUD_DRM_FORMAT_R1) {
++			len = gud_xrgb8888_to_r124(buf, format, vaddr, fb, rect);
++			if (!len) {
++				ret = -ENOMEM;
++				goto end_cpu_access;
++			}
++		} else if (format->format == DRM_FORMAT_RGB565) {
++			drm_fb_xrgb8888_to_rgb565(buf, vaddr, fb, rect, gud_is_big_endian());
++		} else {
++			len = gud_xrgb8888_to_color(buf, format, vaddr, fb, rect);
++		}
++	} else if (gud_is_big_endian() && format->cpp[0] > 1) {
++		drm_fb_swab(buf, vaddr, fb, rect, !import_attach);
++	} else if (compression && !import_attach && pitch == fb->pitches[0]) {
++		/* can compress directly from the framebuffer */
++		buf = vaddr + rect->y1 * pitch;
++	} else {
++		drm_fb_memcpy(buf, vaddr, fb, rect);
++	}
++
++	memset(req, 0, sizeof(*req));
++	req->x = cpu_to_le32(rect->x1);
++	req->y = cpu_to_le32(rect->y1);
++	req->width = cpu_to_le32(drm_rect_width(rect));
++	req->height = cpu_to_le32(drm_rect_height(rect));
++	req->length = cpu_to_le32(len);
++
++	if (compression & GUD_COMPRESSION_LZ4) {
++		int complen;
++
++		complen = LZ4_compress_default(buf, gdrm->bulk_buf, len, len, gdrm->lz4_comp_mem);
++		if (complen <= 0) {
++			compression = 0;
++			goto retry;
++		}
++
++		req->compression = GUD_COMPRESSION_LZ4;
++		req->compressed_length = cpu_to_le32(complen);
++	}
++
++end_cpu_access:
++	if (import_attach)
++		dma_buf_end_cpu_access(import_attach->dmabuf, DMA_FROM_DEVICE);
++vunmap:
++	drm_gem_shmem_vunmap(fb->obj[0], vmap);
++
++	return ret;
++}
++
++static int gud_flush_rect(struct gud_device *gdrm, struct drm_framebuffer *fb,
++			  const struct drm_format_info *format, struct drm_rect *rect)
++{
++	struct usb_device *usb = gud_to_usb_device(gdrm);
++	struct gud_set_buffer_req req;
++	int ret, actual_length;
++	size_t len, trlen;
++
++	drm_dbg(&gdrm->drm, "Flushing [FB:%d] " DRM_RECT_FMT "\n", fb->base.id, DRM_RECT_ARG(rect));
++
++	ret = gud_prep_flush(gdrm, fb, format, rect, &req);
++	if (ret)
++		return ret;
++
++	len = le32_to_cpu(req.length);
++
++	if (req.compression)
++		trlen = le32_to_cpu(req.compressed_length);
++	else
++		trlen = len;
++
++	gdrm->stats_length += len;
++	/* Did it wrap around? */
++	if (gdrm->stats_length <= len && gdrm->stats_actual_length) {
++		gdrm->stats_length = len;
++		gdrm->stats_actual_length = 0;
++	}
++	gdrm->stats_actual_length += trlen;
++
++	if (!(gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE) || gdrm->prev_flush_failed) {
++		ret = gud_usb_set(gdrm, GUD_REQ_SET_BUFFER, 0, &req, sizeof(req));
++		if (ret)
++			return ret;
++	}
++
++	ret = usb_bulk_msg(usb, gdrm->bulk_pipe, gdrm->bulk_buf, trlen,
++			   &actual_length, msecs_to_jiffies(3000));
++	if (!ret && trlen != actual_length)
++		ret = -EIO;
++	if (ret)
++		gdrm->stats_num_errors++;
++
++	return ret;
++}
++
++void gud_clear_damage(struct gud_device *gdrm)
++{
++	gdrm->damage.x1 = INT_MAX;
++	gdrm->damage.y1 = INT_MAX;
++	gdrm->damage.x2 = 0;
++	gdrm->damage.y2 = 0;
++}
++
++static void gud_add_damage(struct gud_device *gdrm, struct drm_rect *damage)
++{
++	gdrm->damage.x1 = min(gdrm->damage.x1, damage->x1);
++	gdrm->damage.y1 = min(gdrm->damage.y1, damage->y1);
++	gdrm->damage.x2 = max(gdrm->damage.x2, damage->x2);
++	gdrm->damage.y2 = max(gdrm->damage.y2, damage->y2);
++}
++
++static void gud_retry_failed_flush(struct gud_device *gdrm, struct drm_framebuffer *fb,
++				   struct drm_rect *damage)
++{
++	/*
++	 * pipe_update waits for the worker when the display mode is going to change.
++	 * This ensures that the width and height is still the same making it safe to
++	 * add back the damage.
++	 */
++
++	mutex_lock(&gdrm->damage_lock);
++	if (!gdrm->fb) {
++		drm_framebuffer_get(fb);
++		gdrm->fb = fb;
++	}
++	gud_add_damage(gdrm, damage);
++	mutex_unlock(&gdrm->damage_lock);
++
++	/* Retry only once to avoid a possible storm in case of continues errors. */
++	if (!gdrm->prev_flush_failed)
++		queue_work(system_long_wq, &gdrm->work);
++	gdrm->prev_flush_failed = true;
++}
++
++void gud_flush_work(struct work_struct *work)
++{
++	struct gud_device *gdrm = container_of(work, struct gud_device, work);
++	const struct drm_format_info *format;
++	struct drm_framebuffer *fb;
++	struct drm_rect damage;
++	unsigned int i, lines;
++	int idx, ret = 0;
++	size_t pitch;
++
++	if (!drm_dev_enter(&gdrm->drm, &idx))
++		return;
++
++	mutex_lock(&gdrm->damage_lock);
++	fb = gdrm->fb;
++	gdrm->fb = NULL;
++	damage = gdrm->damage;
++	gud_clear_damage(gdrm);
++	mutex_unlock(&gdrm->damage_lock);
++
++	if (!fb)
++		goto out;
++
++	format = fb->format;
++	if (format->format == DRM_FORMAT_XRGB8888 && gdrm->xrgb8888_emulation_format)
++		format = gdrm->xrgb8888_emulation_format;
++
++	/* Split update if it's too big */
++	pitch = drm_format_info_min_pitch(format, 0, drm_rect_width(&damage));
++	lines = drm_rect_height(&damage);
++
++	if (gdrm->bulk_len < lines * pitch)
++		lines = gdrm->bulk_len / pitch;
++
++	for (i = 0; i < DIV_ROUND_UP(drm_rect_height(&damage), lines); i++) {
++		struct drm_rect rect = damage;
++
++		rect.y1 += i * lines;
++		rect.y2 = min_t(u32, rect.y1 + lines, damage.y2);
++
++		ret = gud_flush_rect(gdrm, fb, format, &rect);
++		if (ret) {
++			if (ret != -ENODEV && ret != -ECONNRESET &&
++			    ret != -ESHUTDOWN && ret != -EPROTO) {
++				bool prev_flush_failed = gdrm->prev_flush_failed;
++
++				gud_retry_failed_flush(gdrm, fb, &damage);
++				if (!prev_flush_failed)
++					dev_err_ratelimited(fb->dev->dev,
++							    "Failed to flush framebuffer: error=%d\n", ret);
++			}
++			break;
++		}
++
++		gdrm->prev_flush_failed = false;
++	}
++
++	drm_framebuffer_put(fb);
++out:
++	drm_dev_exit(idx);
++}
++
++static void gud_fb_queue_damage(struct gud_device *gdrm, struct drm_framebuffer *fb,
++				struct drm_rect *damage)
++{
++	struct drm_framebuffer *old_fb = NULL;
++
++	mutex_lock(&gdrm->damage_lock);
++
++	if (fb != gdrm->fb) {
++		old_fb = gdrm->fb;
++		drm_framebuffer_get(fb);
++		gdrm->fb = fb;
++	}
++
++	gud_add_damage(gdrm, damage);
++
++	mutex_unlock(&gdrm->damage_lock);
++
++	queue_work(system_long_wq, &gdrm->work);
++
++	if (old_fb)
++		drm_framebuffer_put(old_fb);
++}
++
++int gud_pipe_check(struct drm_simple_display_pipe *pipe,
++		   struct drm_plane_state *new_plane_state,
++		   struct drm_crtc_state *new_crtc_state)
++{
++	struct gud_device *gdrm = to_gud_device(pipe->crtc.dev);
++	struct drm_plane_state *old_plane_state = pipe->plane.state;
++	const struct drm_display_mode *mode = &new_crtc_state->mode;
++	struct drm_atomic_state *state = new_plane_state->state;
++	struct drm_framebuffer *old_fb = old_plane_state->fb;
++	struct drm_connector_state *connector_state = NULL;
++	struct drm_framebuffer *fb = new_plane_state->fb;
++	const struct drm_format_info *format = fb->format;
++	struct drm_connector *connector;
++	unsigned int i, num_properties;
++	struct gud_state_req *req;
++	int idx, ret;
++	size_t len;
++
++	if (WARN_ON_ONCE(!fb))
++		return -EINVAL;
++
++	if (old_plane_state->rotation != new_plane_state->rotation)
++		new_crtc_state->mode_changed = true;
++
++	if (old_fb && old_fb->format != format)
++		new_crtc_state->mode_changed = true;
++
++	if (!new_crtc_state->mode_changed && !new_crtc_state->connectors_changed)
++		return 0;
++
++	/* Only one connector is supported */
++	if (hweight32(new_crtc_state->connector_mask) != 1)
++		return -EINVAL;
++
++	if (format->format == DRM_FORMAT_XRGB8888 && gdrm->xrgb8888_emulation_format)
++		format = gdrm->xrgb8888_emulation_format;
++
++	for_each_new_connector_in_state(state, connector, connector_state, i) {
++		if (connector_state->crtc)
++			break;
++	}
++
++	/*
++	 * DRM_IOCTL_MODE_OBJ_SETPROPERTY on the rotation property will not have
++	 * the connector included in the state.
++	 */
++	if (!connector_state) {
++		struct drm_connector_list_iter conn_iter;
++
++		drm_connector_list_iter_begin(pipe->crtc.dev, &conn_iter);
++		drm_for_each_connector_iter(connector, &conn_iter) {
++			if (connector->state->crtc) {
++				connector_state = connector->state;
++				break;
++			}
++		}
++		drm_connector_list_iter_end(&conn_iter);
++	}
++
++	if (WARN_ON_ONCE(!connector_state))
++		return -ENOENT;
++
++	len = struct_size(req, properties,
++			  GUD_PROPERTIES_MAX_NUM + GUD_CONNECTOR_PROPERTIES_MAX_NUM);
++	req = kzalloc(len, GFP_KERNEL);
++	if (!req)
++		return -ENOMEM;
++
++	gud_from_display_mode(&req->mode, mode);
++
++	req->format = gud_from_fourcc(format->format);
++	if (WARN_ON_ONCE(!req->format)) {
++		ret = -EINVAL;
++		goto out;
++	}
++
++	req->connector = drm_connector_index(connector_state->connector);
++
++	ret = gud_connector_fill_properties(connector_state, req->properties);
++	if (ret < 0)
++		goto out;
++
++	num_properties = ret;
++	for (i = 0; i < gdrm->num_properties; i++) {
++		u16 prop = gdrm->properties[i];
++		u64 val;
++
++		switch (prop) {
++		case GUD_PROPERTY_ROTATION:
++			/* DRM UAPI matches the protocol so use value directly */
++			val = new_plane_state->rotation;
++			break;
++		default:
++			WARN_ON_ONCE(1);
++			ret = -EINVAL;
++			goto out;
++		}
++
++		req->properties[num_properties + i].prop = cpu_to_le16(prop);
++		req->properties[num_properties + i].val = cpu_to_le64(val);
++		num_properties++;
++	}
++
++	if (drm_dev_enter(fb->dev, &idx)) {
++		len = struct_size(req, properties, num_properties);
++		ret = gud_usb_set(gdrm, GUD_REQ_SET_STATE_CHECK, 0, req, len);
++		drm_dev_exit(idx);
++	}  else {
++		ret = -ENODEV;
++	}
++out:
++	kfree(req);
++
++	return ret;
++}
++
++void gud_pipe_update(struct drm_simple_display_pipe *pipe,
++		     struct drm_plane_state *old_state)
++{
++	struct drm_device *drm = pipe->crtc.dev;
++	struct gud_device *gdrm = to_gud_device(drm);
++	struct drm_plane_state *state = pipe->plane.state;
++	struct drm_framebuffer *fb = state->fb;
++	struct drm_crtc *crtc = &pipe->crtc;
++	struct drm_rect damage;
++	int idx;
++
++	if (crtc->state->mode_changed || !crtc->state->enable) {
++		cancel_work_sync(&gdrm->work);
++		mutex_lock(&gdrm->damage_lock);
++		if (gdrm->fb) {
++			drm_framebuffer_put(gdrm->fb);
++			gdrm->fb = NULL;
++		}
++		gud_clear_damage(gdrm);
++		mutex_unlock(&gdrm->damage_lock);
++	}
++
++	if (!drm_dev_enter(drm, &idx))
++		return;
++
++	if (!old_state->fb)
++		gud_usb_set_u8(gdrm, GUD_REQ_SET_CONTROLLER_ENABLE, 1);
++
++	if (fb && (crtc->state->mode_changed || crtc->state->connectors_changed))
++		gud_usb_set(gdrm, GUD_REQ_SET_STATE_COMMIT, 0, NULL, 0);
++
++	if (crtc->state->active_changed)
++		gud_usb_set_u8(gdrm, GUD_REQ_SET_DISPLAY_ENABLE, crtc->state->active);
++
++	if (drm_atomic_helper_damage_merged(old_state, state, &damage)) {
++		if (gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE)
++			drm_rect_init(&damage, 0, 0, fb->width, fb->height);
++		gud_fb_queue_damage(gdrm, fb, &damage);
++	}
++
++	if (!crtc->state->enable)
++		gud_usb_set_u8(gdrm, GUD_REQ_SET_CONTROLLER_ENABLE, 0);
++
++	drm_dev_exit(idx);
++}
+--- /dev/null
++++ b/include/drm/gud.h
+@@ -0,0 +1,333 @@
++/* SPDX-License-Identifier: MIT */
++/*
++ * Copyright 2020 Noralf Trønnes
++ */
++
++#ifndef __LINUX_GUD_H
++#define __LINUX_GUD_H
++
++#include <linux/types.h>
++
++/*
++ * struct gud_display_descriptor_req - Display descriptor
++ * @magic: Magic value GUD_DISPLAY_MAGIC
++ * @version: Protocol version
++ * @flags: Flags
++ *         - STATUS_ON_SET: Always do a status request after a SET request.
++ *                          This is used by the Linux gadget driver since it has
++ *                          no way to control the status stage of a control OUT
++ *                          request that has a payload.
++ *         - FULL_UPDATE:   Always send the entire framebuffer when flushing changes.
++ *                          The GUD_REQ_SET_BUFFER request will not be sent
++ *                          before each bulk transfer, it will only be sent if the
++ *                          previous bulk transfer had failed. This gives the device
++ *                          a chance to reset its state machine if needed.
++ *                          This flag can not be used in combination with compression.
++ * @compression: Supported compression types
++ *               - GUD_COMPRESSION_LZ4: LZ4 lossless compression.
++ * @max_buffer_size: Maximum buffer size the device can handle (optional).
++ *                   This is useful for devices that don't have a big enough
++ *                   buffer to decompress the entire framebuffer in one go.
++ * @min_width: Minimum pixel width the controller can handle
++ * @max_width: Maximum width
++ * @min_height: Minimum height
++ * @max_height: Maximum height
++ *
++ * Devices that have only one display mode will have min_width == max_width
++ * and min_height == max_height.
++ */
++struct gud_display_descriptor_req {
++	__le32 magic;
++#define GUD_DISPLAY_MAGIC			0x1d50614d
++	__u8 version;
++	__le32 flags;
++#define GUD_DISPLAY_FLAG_STATUS_ON_SET		BIT(0)
++#define GUD_DISPLAY_FLAG_FULL_UPDATE		BIT(1)
++	__u8 compression;
++#define GUD_COMPRESSION_LZ4			BIT(0)
++	__le32 max_buffer_size;
++	__le32 min_width;
++	__le32 max_width;
++	__le32 min_height;
++	__le32 max_height;
++} __packed;
++
++/*
++ * struct gud_property_req - Property
++ * @prop: Property
++ * @val: Value
++ */
++struct gud_property_req {
++	__le16 prop;
++	__le64 val;
++} __packed;
++
++/*
++ * struct gud_display_mode_req - Display mode
++ * @clock: Pixel clock in kHz
++ * @hdisplay: Horizontal display size
++ * @hsync_start: Horizontal sync start
++ * @hsync_end: Horizontal sync end
++ * @htotal: Horizontal total size
++ * @vdisplay: Vertical display size
++ * @vsync_start: Vertical sync start
++ * @vsync_end: Vertical sync end
++ * @vtotal: Vertical total size
++ * @flags: Bits 0-13 are the same as in the RandR protocol and also what DRM uses.
++ *         The deprecated bits are reused for internal protocol flags leaving us
++ *         free to follow DRM for the other bits in the future.
++ *         - FLAG_PREFERRED: Set on the preferred display mode.
++ */
++struct gud_display_mode_req {
++	__le32 clock;
++	__le16 hdisplay;
++	__le16 hsync_start;
++	__le16 hsync_end;
++	__le16 htotal;
++	__le16 vdisplay;
++	__le16 vsync_start;
++	__le16 vsync_end;
++	__le16 vtotal;
++	__le32 flags;
++#define GUD_DISPLAY_MODE_FLAG_PHSYNC		BIT(0)
++#define GUD_DISPLAY_MODE_FLAG_NHSYNC		BIT(1)
++#define GUD_DISPLAY_MODE_FLAG_PVSYNC		BIT(2)
++#define GUD_DISPLAY_MODE_FLAG_NVSYNC		BIT(3)
++#define GUD_DISPLAY_MODE_FLAG_INTERLACE		BIT(4)
++#define GUD_DISPLAY_MODE_FLAG_DBLSCAN		BIT(5)
++#define GUD_DISPLAY_MODE_FLAG_CSYNC		BIT(6)
++#define GUD_DISPLAY_MODE_FLAG_PCSYNC		BIT(7)
++#define GUD_DISPLAY_MODE_FLAG_NCSYNC		BIT(8)
++#define GUD_DISPLAY_MODE_FLAG_HSKEW		BIT(9)
++/* BCast and PixelMultiplex are deprecated */
++#define GUD_DISPLAY_MODE_FLAG_DBLCLK		BIT(12)
++#define GUD_DISPLAY_MODE_FLAG_CLKDIV2		BIT(13)
++#define GUD_DISPLAY_MODE_FLAG_USER_MASK		\
++		(GUD_DISPLAY_MODE_FLAG_PHSYNC | GUD_DISPLAY_MODE_FLAG_NHSYNC | \
++		GUD_DISPLAY_MODE_FLAG_PVSYNC | GUD_DISPLAY_MODE_FLAG_NVSYNC | \
++		GUD_DISPLAY_MODE_FLAG_INTERLACE | GUD_DISPLAY_MODE_FLAG_DBLSCAN | \
++		GUD_DISPLAY_MODE_FLAG_CSYNC | GUD_DISPLAY_MODE_FLAG_PCSYNC | \
++		GUD_DISPLAY_MODE_FLAG_NCSYNC | GUD_DISPLAY_MODE_FLAG_HSKEW | \
++		GUD_DISPLAY_MODE_FLAG_DBLCLK | GUD_DISPLAY_MODE_FLAG_CLKDIV2)
++/* Internal protocol flags */
++#define GUD_DISPLAY_MODE_FLAG_PREFERRED		BIT(10)
++} __packed;
++
++/*
++ * struct gud_connector_descriptor_req - Connector descriptor
++ * @connector_type: Connector type (GUD_CONNECTOR_TYPE_*).
++ *                  If the host doesn't support the type it should fall back to PANEL.
++ * @flags: Flags
++ *         - POLL_STATUS: Connector status can change (polled every 10 seconds)
++ *         - INTERLACE: Interlaced modes are supported
++ *         - DOUBLESCAN: Doublescan modes are supported
++ */
++struct gud_connector_descriptor_req {
++	__u8 connector_type;
++#define GUD_CONNECTOR_TYPE_PANEL		0
++#define GUD_CONNECTOR_TYPE_VGA			1
++#define GUD_CONNECTOR_TYPE_COMPOSITE		2
++#define GUD_CONNECTOR_TYPE_SVIDEO		3
++#define GUD_CONNECTOR_TYPE_COMPONENT		4
++#define GUD_CONNECTOR_TYPE_DVI			5
++#define GUD_CONNECTOR_TYPE_DISPLAYPORT		6
++#define GUD_CONNECTOR_TYPE_HDMI			7
++	__le32 flags;
++#define GUD_CONNECTOR_FLAGS_POLL_STATUS		BIT(0)
++#define GUD_CONNECTOR_FLAGS_INTERLACE		BIT(1)
++#define GUD_CONNECTOR_FLAGS_DOUBLESCAN		BIT(2)
++} __packed;
++
++/*
++ * struct gud_set_buffer_req - Set buffer transfer info
++ * @x: X position of rectangle
++ * @y: Y position
++ * @width: Pixel width of rectangle
++ * @height: Pixel height
++ * @length: Buffer length in bytes
++ * @compression: Transfer compression
++ * @compressed_length: Compressed buffer length
++ *
++ * This request is issued right before the bulk transfer.
++ * @x, @y, @width and @height specifies the rectangle where the buffer should be
++ * placed inside the framebuffer.
++ */
++struct gud_set_buffer_req {
++	__le32 x;
++	__le32 y;
++	__le32 width;
++	__le32 height;
++	__le32 length;
++	__u8 compression;
++	__le32 compressed_length;
++} __packed;
++
++/*
++ * struct gud_state_req - Display state
++ * @mode: Display mode
++ * @format: Pixel format GUD_PIXEL_FORMAT_*
++ * @connector: Connector index
++ * @properties: Array of properties
++ *
++ * The entire state is transferred each time there's a change.
++ */
++struct gud_state_req {
++	struct gud_display_mode_req mode;
++	__u8 format;
++	__u8 connector;
++	struct gud_property_req properties[];
++} __packed;
++
++/* List of supported connector properties: */
++
++/* Margins in pixels to deal with overscan, range 0-100 */
++#define GUD_PROPERTY_TV_LEFT_MARGIN			1
++#define GUD_PROPERTY_TV_RIGHT_MARGIN			2
++#define GUD_PROPERTY_TV_TOP_MARGIN			3
++#define GUD_PROPERTY_TV_BOTTOM_MARGIN			4
++#define GUD_PROPERTY_TV_MODE				5
++/* Brightness in percent, range 0-100 */
++#define GUD_PROPERTY_TV_BRIGHTNESS			6
++/* Contrast in percent, range 0-100 */
++#define GUD_PROPERTY_TV_CONTRAST			7
++/* Flicker reduction in percent, range 0-100 */
++#define GUD_PROPERTY_TV_FLICKER_REDUCTION		8
++/* Overscan in percent, range 0-100 */
++#define GUD_PROPERTY_TV_OVERSCAN			9
++/* Saturation in percent, range 0-100 */
++#define GUD_PROPERTY_TV_SATURATION			10
++/* Hue in percent, range 0-100 */
++#define GUD_PROPERTY_TV_HUE				11
++
++/*
++ * Backlight brightness is in the range 0-100 inclusive. The value represents the human perceptual
++ * brightness and not a linear PWM value. 0 is minimum brightness which should not turn the
++ * backlight completely off. The DPMS connector property should be used to control power which will
++ * trigger a GUD_REQ_SET_DISPLAY_ENABLE request.
++ *
++ * This does not map to a DRM property, it is used with the backlight device.
++ */
++#define GUD_PROPERTY_BACKLIGHT_BRIGHTNESS		12
++
++/* List of supported properties that are not connector propeties: */
++
++/*
++ * Plane rotation. Should return the supported bitmask on
++ * GUD_REQ_GET_PROPERTIES. GUD_ROTATION_0 is mandatory.
++ *
++ * Note: This is not display rotation so 90/270 will need scaling to make it fit (unless squared).
++ */
++#define GUD_PROPERTY_ROTATION				50
++  #define GUD_ROTATION_0			BIT(0)
++  #define GUD_ROTATION_90			BIT(1)
++  #define GUD_ROTATION_180			BIT(2)
++  #define GUD_ROTATION_270			BIT(3)
++  #define GUD_ROTATION_REFLECT_X		BIT(4)
++  #define GUD_ROTATION_REFLECT_Y		BIT(5)
++  #define GUD_ROTATION_MASK			(GUD_ROTATION_0 | GUD_ROTATION_90 | \
++						GUD_ROTATION_180 | GUD_ROTATION_270 | \
++						GUD_ROTATION_REFLECT_X | GUD_ROTATION_REFLECT_Y)
++
++/* USB Control requests: */
++
++/* Get status from the last GET/SET control request. Value is u8. */
++#define GUD_REQ_GET_STATUS				0x00
++  /* Status values: */
++  #define GUD_STATUS_OK				0x00
++  #define GUD_STATUS_BUSY			0x01
++  #define GUD_STATUS_REQUEST_NOT_SUPPORTED	0x02
++  #define GUD_STATUS_PROTOCOL_ERROR		0x03
++  #define GUD_STATUS_INVALID_PARAMETER		0x04
++  #define GUD_STATUS_ERROR			0x05
++
++/* Get display descriptor as a &gud_display_descriptor_req */
++#define GUD_REQ_GET_DESCRIPTOR				0x01
++
++/* Get supported pixel formats as a byte array of GUD_PIXEL_FORMAT_* */
++#define GUD_REQ_GET_FORMATS				0x40
++  #define GUD_FORMATS_MAX_NUM			32
++  /* R1 is a 1-bit monochrome transfer format presented to userspace as XRGB8888 */
++  #define GUD_PIXEL_FORMAT_R1			0x01
++  #define GUD_PIXEL_FORMAT_XRGB1111		0x20
++  #define GUD_PIXEL_FORMAT_RGB565		0x40
++  #define GUD_PIXEL_FORMAT_XRGB8888		0x80
++  #define GUD_PIXEL_FORMAT_ARGB8888		0x81
++
++/*
++ * Get supported properties that are not connector propeties as a &gud_property_req array.
++ * gud_property_req.val often contains the initial value for the property.
++ */
++#define GUD_REQ_GET_PROPERTIES				0x41
++  #define GUD_PROPERTIES_MAX_NUM		32
++
++/* Connector requests have the connector index passed in the wValue field */
++
++/* Get connector descriptors as an array of &gud_connector_descriptor_req */
++#define GUD_REQ_GET_CONNECTORS				0x50
++  #define GUD_CONNECTORS_MAX_NUM		32
++
++/*
++ * Get properties supported by the connector as a &gud_property_req array.
++ * gud_property_req.val often contains the initial value for the property.
++ */
++#define GUD_REQ_GET_CONNECTOR_PROPERTIES		0x51
++  #define GUD_CONNECTOR_PROPERTIES_MAX_NUM	32
++
++/*
++ * Issued when there's a TV_MODE property present.
++ * Gets an array of the supported TV_MODE names each entry of length
++ * GUD_CONNECTOR_TV_MODE_NAME_LEN. Names must be NUL-terminated.
++ */
++#define GUD_REQ_GET_CONNECTOR_TV_MODE_VALUES		0x52
++  #define GUD_CONNECTOR_TV_MODE_NAME_LEN	16
++  #define GUD_CONNECTOR_TV_MODE_MAX_NUM		16
++
++/* When userspace checks connector status, this is issued first, not used for poll requests. */
++#define GUD_REQ_SET_CONNECTOR_FORCE_DETECT		0x53
++
++/*
++ * Get connector status. Value is u8.
++ *
++ * Userspace will get a HOTPLUG uevent if one of the following is true:
++ * - Connection status has changed since last
++ * - CHANGED is set
++ */
++#define GUD_REQ_GET_CONNECTOR_STATUS			0x54
++  #define GUD_CONNECTOR_STATUS_DISCONNECTED	0x00
++  #define GUD_CONNECTOR_STATUS_CONNECTED	0x01
++  #define GUD_CONNECTOR_STATUS_UNKNOWN		0x02
++  #define GUD_CONNECTOR_STATUS_CONNECTED_MASK	0x03
++  #define GUD_CONNECTOR_STATUS_CHANGED		BIT(7)
++
++/*
++ * Display modes can be fetched as either EDID data or an array of &gud_display_mode_req.
++ *
++ * If GUD_REQ_GET_CONNECTOR_MODES returns zero, EDID is used to create display modes.
++ * If both display modes and EDID are returned, EDID is just passed on to userspace
++ * in the EDID connector property.
++ */
++
++/* Get &gud_display_mode_req array of supported display modes */
++#define GUD_REQ_GET_CONNECTOR_MODES			0x55
++  #define GUD_CONNECTOR_MAX_NUM_MODES		128
++
++/* Get Extended Display Identification Data */
++#define GUD_REQ_GET_CONNECTOR_EDID			0x56
++  #define GUD_CONNECTOR_MAX_EDID_LEN		2048
++
++/* Set buffer properties before bulk transfer as &gud_set_buffer_req */
++#define GUD_REQ_SET_BUFFER				0x60
++
++/* Check display configuration as &gud_state_req */
++#define GUD_REQ_SET_STATE_CHECK				0x61
++
++/* Apply the previous STATE_CHECK configuration */
++#define GUD_REQ_SET_STATE_COMMIT			0x62
++
++/* Enable/disable the display controller, value is u8: 0/1 */
++#define GUD_REQ_SET_CONTROLLER_ENABLE			0x63
++
++/* Enable/disable display/output (DPMS), value is u8: 0/1 */
++#define GUD_REQ_SET_DISPLAY_ENABLE			0x64
++
++#endif