[Intel-gfx] [RFC v3 09/12] drm: Add API for in-kernel clients

Noralf Trønnes noralf at tronnes.org
Thu Mar 8 17:12:11 UTC 2018


Den 06.03.2018 09.56, skrev Daniel Vetter:
> On Thu, Feb 22, 2018 at 09:06:50PM +0100, Noralf Trønnes wrote:
>> This adds an API for writing in-kernel clients.
>>
>> TODO:
>> - Flesh out and complete documentation.
>> - Cloned displays is not tested.
>> - Complete tiled display support and test it.
>> - Test plug/unplug different monitors.
>> - A runtime knob to prevent clients from attaching for debugging purposes.
>> - Maybe a way to unbind individual client instances.
>> - Maybe take the sysrq support in drm_fb_helper and move it here somehow.
>> - Add suspend/resume callbacks.
>>    Does anyone know why fbdev requires suspend/resume?
>>
>> Signed-off-by: Noralf Trønnes <noralf at tronnes.org>
> The core client api I like. Some of the opens I'm seeing:
>
> - If we go with using the internal kms api directly instead of IOCTL
>    wrappers then a huge pile of the functions you have here aren't needed
>    (e.g. all the event stuff we can just directly use vblank events instead
>    of all the wrapping). I'm leaning ever more into that direction, since
>    much less code to add.

Looking at drm_fb_helper once again I now see an opportunity to simplify
the modesetting code by nuking drm_fb_helper_connector and stop
maintaining an array of connectors. It looks to be possible to just
create an array temporarily in drm_setup_crtcs() for the duration of the
function. The connectors we care about are ref counted and attached to
modesets. This would remove the need for drm_fb_helper_add_one_connector().

So I might be able to do struct drm_fb_helper_crtc -> drm_client_crtc
and let the client API take over drm_setup_crtcs(). I'll give it a try.

There is one challenge I see upfront and that's the i915 fb_helper
callback in drm_setup_crtcs().

> - The register/unregister model needs more thought. Allowing both clients
>    to register whenever they want to, and drm_device instances to come and
>    go is what fbcon has done, and the resulting locking is a horror show.
>
>    I think if we require that all in-kernel drm_clients are registers when
>    loading drm.ko (and enabled/disabled only per module options and
>    Kconfig), then we can throw out all the locking. That avoids a lot of
>    the headaches.
>
>    2nd, if the list of clients is static over the lifetime of drm.ko, we
>    also don't need to iterate existing drivers. Which avoids me having to
>    review the iterator patch (that's the other aspect where fbcon totally
>    falls over and essentially just ignores a bunch of races).

Are you talking about linking the clients into drm.ko?

drivers/gpu/drm/Makefile:

drm-$(CONFIG_DRM_CLIENT_BOOTSPLASH) += client/drm_bootsplash.o

drivers/gpu/drm/drm_drv.c:

  static int __init drm_core_init(void)
  {
+    drm_bootsplash_register();
+    drm_fbdev_register();
  }

drivers/gpu/drm/drm_internal.h:

#ifdef DRM_CLIENT_BOOTSPLASH
void drm_bootsplash_register(void);
#else
static inline void drm_bootsplash_register(void)
{
}
#endif

drivers/gpu/drm/client/drm_bootsplash.c:

static const struct drm_client_funcs drm_bootsplash_funcs = {
     .name        = "drm_bootsplash",
     .new        = drm_bootsplash_new,
     .remove        = drm_bootsplash_remove,
     .hotplug    = drm_bootsplash_hotplug,
};

void drm_bootsplash_register(void)
{
     drm_client_register(&drm_bootsplash_funcs);
}

drivers/gpu/drm/drm_client.c:

static LIST_HEAD(drm_client_funcs_list);

void drm_client_register(const struct drm_client_funcs *funcs)
{
     struct drm_client_funcs_entry *funcs_entry;

     funcs_entry = kzalloc(sizeof(*funcs_entry), GFP_KERNEL);
     if (!funcs_entry) {
         DRM_ERROR("Failed to register: %s\n", funcs->name);
         return;
     }

     funcs_entry->funcs = funcs;

     list_add(&funcs_entry->list, &drm_client_funcs_list);

     DRM_DEBUG_KMS("%s\n", funcs->name);
}


And each client having a runtime enable/disable knob:

drivers/gpu/drm/client/drm_bootsplash.c:

static bool drm_bootsplash_enabled = true;
module_param_named(bootsplash_enabled, drm_bootsplash_enabled, bool, 0600);
MODULE_PARM_DESC(bootsplash_enabled, "Enable bootsplash client 
[default=true]");


Simple USB Display
A few months back while looking at the udl shmem code, I got the idea
that I could turn a Raspberry Pi Zero into a $5 USB to HDMI/DSI/DPI/DBI/TV
adapter. The host side would be a simple tinydrm driver using the kernel
compression lib to speed up transfers. The gadget/device side would be a
userspace app decompressing the buffer into an exported dumb buffer.

While working with this client API I realized that I could use it and
write a kernel gadget driver instead avoiding the challenge of going
back and forth to userspace with the framebuffer. For such a client I
would have preferred it to be a loadable module not linked into drm.ko
to increase the chance that distributions would enable it.

Noralf.

>> ---
>>   drivers/gpu/drm/Kconfig             |    2 +
>>   drivers/gpu/drm/Makefile            |    3 +-
>>   drivers/gpu/drm/client/Kconfig      |    4 +
>>   drivers/gpu/drm/client/Makefile     |    1 +
>>   drivers/gpu/drm/client/drm_client.c | 1612 +++++++++++++++++++++++++++++++++++
> I'd move this into main drm/ directory, it's fairly core stuff.
>
>>   drivers/gpu/drm/drm_drv.c           |    6 +
>>   drivers/gpu/drm/drm_file.c          |    3 +
>>   drivers/gpu/drm/drm_probe_helper.c  |    3 +
>>   include/drm/drm_client.h            |  192 +++++
>>   include/drm/drm_device.h            |    1 +
>>   include/drm/drm_file.h              |    7 +
>>   11 files changed, 1833 insertions(+), 1 deletion(-)
>>   create mode 100644 drivers/gpu/drm/client/Kconfig
>>   create mode 100644 drivers/gpu/drm/client/Makefile
>>   create mode 100644 drivers/gpu/drm/client/drm_client.c
>>   create mode 100644 include/drm/drm_client.h
>>
>> diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
>> index deeefa7a1773..d4ae15f9ee9f 100644
>> --- a/drivers/gpu/drm/Kconfig
>> +++ b/drivers/gpu/drm/Kconfig
>> @@ -154,6 +154,8 @@ config DRM_SCHED
>>   	tristate
>>   	depends on DRM
>>   
>> +source "drivers/gpu/drm/client/Kconfig"
>> +
>>   source "drivers/gpu/drm/i2c/Kconfig"
>>   
>>   source "drivers/gpu/drm/arm/Kconfig"
>> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
>> index 50093ff4479b..8e06dc7eeca1 100644
>> --- a/drivers/gpu/drm/Makefile
>> +++ b/drivers/gpu/drm/Makefile
>> @@ -18,7 +18,7 @@ drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
>>   		drm_encoder.o drm_mode_object.o drm_property.o \
>>   		drm_plane.o drm_color_mgmt.o drm_print.o \
>>   		drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
>> -		drm_syncobj.o drm_lease.o
>> +		drm_syncobj.o drm_lease.o client/drm_client.o
>>   
>>   drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o
>>   drm-$(CONFIG_DRM_VM) += drm_vm.o
>> @@ -103,3 +103,4 @@ obj-$(CONFIG_DRM_MXSFB)	+= mxsfb/
>>   obj-$(CONFIG_DRM_TINYDRM) += tinydrm/
>>   obj-$(CONFIG_DRM_PL111) += pl111/
>>   obj-$(CONFIG_DRM_TVE200) += tve200/
>> +obj-y			+= client/
>> diff --git a/drivers/gpu/drm/client/Kconfig b/drivers/gpu/drm/client/Kconfig
>> new file mode 100644
>> index 000000000000..4bb8e4655ff7
>> --- /dev/null
>> +++ b/drivers/gpu/drm/client/Kconfig
>> @@ -0,0 +1,4 @@
>> +menu "DRM Clients"
>> +	depends on DRM
>> +
>> +endmenu
>> diff --git a/drivers/gpu/drm/client/Makefile b/drivers/gpu/drm/client/Makefile
>> new file mode 100644
>> index 000000000000..f66554cd5c45
>> --- /dev/null
>> +++ b/drivers/gpu/drm/client/Makefile
>> @@ -0,0 +1 @@
>> +# SPDX-License-Identifier: GPL-2.0
>> diff --git a/drivers/gpu/drm/client/drm_client.c b/drivers/gpu/drm/client/drm_client.c
>> new file mode 100644
>> index 000000000000..a633bf747316
>> --- /dev/null
>> +++ b/drivers/gpu/drm/client/drm_client.c
>> @@ -0,0 +1,1612 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +// Copyright 2018 Noralf Trønnes
>> +
>> +#include <linux/dma-buf.h>
>> +#include <linux/list.h>
>> +#include <linux/mutex.h>
>> +#include <linux/module.h>
>> +#include <linux/slab.h>
>> +
>> +#include <drm/drm_client.h>
>> +#include <drm/drm_connector.h>
>> +#include <drm/drm_drv.h>
>> +#include <drm/drm_file.h>
>> +#include <drm/drm_ioctl.h>
>> +#include <drm/drmP.h>
>> +
>> +#include "drm_crtc_internal.h"
>> +#include "drm_internal.h"
>> +
>> +struct drm_client_funcs_entry {
>> +	struct list_head list;
>> +	const struct drm_client_funcs *funcs;
>> +};
>> +
>> +static LIST_HEAD(drm_client_list);
> I think the client list itself should be on the drm_device, not in one
> global list that mixes up all the clients of all the drm_devices.
>
> I'll skip reviewing details since we have a bunch of high-level questions
> to figure out first.
> -Daniel
>
>> +static LIST_HEAD(drm_client_funcs_list);
>> +static DEFINE_MUTEX(drm_client_list_lock);
>> +
>> +static void drm_client_new(struct drm_device *dev,
>> +			   const struct drm_client_funcs *funcs)
>> +{
>> +	struct drm_client_dev *client;
>> +	int ret;
>> +
>> +	lockdep_assert_held(&drm_client_list_lock);
>> +
>> +	client = kzalloc(sizeof(*client), GFP_KERNEL);
>> +	if (!client)
>> +		return;
>> +
>> +	mutex_init(&client->lock);
>> +	client->dev = dev;
>> +	client->funcs = funcs;
>> +
>> +	ret = funcs->new(client);
>> +	DRM_DEV_DEBUG_KMS(dev->dev, "%s: ret=%d\n", funcs->name, ret);
>> +	if (ret) {
>> +		drm_client_free(client);
>> +		return;
>> +	}
>> +
>> +	list_add(&client->list, &drm_client_list);
>> +}
>> +
>> +/**
>> + * drm_client_free - Free DRM client resources
>> + * @client: DRM client
>> + *
>> + * This is called automatically on client removal unless the client returns
>> + * non-zero in the &drm_client_funcs->remove callback. The fbdev client does
>> + * this when it can't close &drm_file because userspace has an open fd.
>> + */
>> +void drm_client_free(struct drm_client_dev *client)
>> +{
>> +	DRM_DEV_DEBUG_KMS(client->dev->dev, "%s\n", client->funcs->name);
>> +	if (WARN_ON(client->file)) {
>> +		client->file_ref_count = 1;
>> +		drm_client_put_file(client);
>> +	}
>> +	mutex_destroy(&client->lock);
>> +	kfree(client->crtcs);
>> +	kfree(client);
>> +}
>> +EXPORT_SYMBOL(drm_client_free);
>> +
>> +static void drm_client_remove(struct drm_client_dev *client)
>> +{
>> +	lockdep_assert_held(&drm_client_list_lock);
>> +
>> +	list_del(&client->list);
>> +
>> +	if (!client->funcs->remove || !client->funcs->remove(client))
>> +		drm_client_free(client);
>> +}
>> +
>> +/**
>> + * drm_client_register - Register a DRM client
>> + * @funcs: Client callbacks
>> + *
>> + * Returns:
>> + * Zero on success, negative error code on failure.
>> + */
>> +int drm_client_register(const struct drm_client_funcs *funcs)
>> +{
>> +	struct drm_client_funcs_entry *funcs_entry;
>> +	struct drm_device_list_iter iter;
>> +	struct drm_device *dev;
>> +
>> +	funcs_entry = kzalloc(sizeof(*funcs_entry), GFP_KERNEL);
>> +	if (!funcs_entry)
>> +		return -ENOMEM;
>> +
>> +	funcs_entry->funcs = funcs;
>> +
>> +	mutex_lock(&drm_global_mutex);
>> +	mutex_lock(&drm_client_list_lock);
>> +
>> +	drm_device_list_iter_begin(&iter);
>> +	drm_for_each_device_iter(dev, &iter)
>> +		if (drm_core_check_feature(dev, DRIVER_MODESET))
>> +			drm_client_new(dev, funcs);
>> +	drm_device_list_iter_end(&iter);
>> +
>> +	list_add(&funcs_entry->list, &drm_client_funcs_list);
>> +
>> +	mutex_unlock(&drm_client_list_lock);
>> +	mutex_unlock(&drm_global_mutex);
>> +
>> +	DRM_DEBUG_KMS("%s\n", funcs->name);
>> +
>> +	return 0;
>> +}
>> +EXPORT_SYMBOL(drm_client_register);
>> +
>> +/**
>> + * drm_client_unregister - Unregister a DRM client
>> + * @funcs: Client callbacks
>> + */
>> +void drm_client_unregister(const struct drm_client_funcs *funcs)
>> +{
>> +	struct drm_client_funcs_entry *funcs_entry;
>> +	struct drm_client_dev *client, *tmp;
>> +
>> +	mutex_lock(&drm_client_list_lock);
>> +
>> +	list_for_each_entry_safe(client, tmp, &drm_client_list, list) {
>> +		if (client->funcs == funcs)
>> +			drm_client_remove(client);
>> +	}
>> +
>> +	list_for_each_entry(funcs_entry, &drm_client_funcs_list, list) {
>> +		if (funcs_entry->funcs == funcs) {
>> +			list_del(&funcs_entry->list);
>> +			kfree(funcs_entry);
>> +			break;
>> +		}
>> +	}
>> +
>> +	mutex_unlock(&drm_client_list_lock);
>> +
>> +	DRM_DEBUG_KMS("%s\n", funcs->name);
>> +}
>> +EXPORT_SYMBOL(drm_client_unregister);
>> +
>> +void drm_client_dev_register(struct drm_device *dev)
>> +{
>> +	struct drm_client_funcs_entry *funcs_entry;
>> +
>> +	/*
>> +	 * Minors are created at the beginning of drm_dev_register(), but can
>> +	 * be removed again if the function fails. Since we iterate DRM devices
>> +	 * by walking DRM minors, we need to stay under this lock.
>> +	 */
>> +	lockdep_assert_held(&drm_global_mutex);
>> +
>> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
>> +		return;
>> +
>> +	mutex_lock(&drm_client_list_lock);
>> +	list_for_each_entry(funcs_entry, &drm_client_funcs_list, list)
>> +		drm_client_new(dev, funcs_entry->funcs);
>> +	mutex_unlock(&drm_client_list_lock);
>> +}
>> +
>> +void drm_client_dev_unregister(struct drm_device *dev)
>> +{
>> +	struct drm_client_dev *client, *tmp;
>> +
>> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
>> +		return;
>> +
>> +	mutex_lock(&drm_client_list_lock);
>> +	list_for_each_entry_safe(client, tmp, &drm_client_list, list)
>> +		if (client->dev == dev)
>> +			drm_client_remove(client);
>> +	mutex_unlock(&drm_client_list_lock);
>> +}
>> +
>> +void drm_client_dev_hotplug(struct drm_device *dev)
>> +{
>> +	struct drm_client_dev *client;
>> +	int ret;
>> +
>> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
>> +		return;
>> +
>> +	mutex_lock(&drm_client_list_lock);
>> +	list_for_each_entry(client, &drm_client_list, list)
>> +		if (client->dev == dev && client->funcs->hotplug) {
>> +			ret = client->funcs->hotplug(client);
>> +			DRM_DEV_DEBUG_KMS(dev->dev, "%s: ret=%d\n",
>> +					  client->funcs->name, ret);
>> +		}
>> +	mutex_unlock(&drm_client_list_lock);
>> +}
>> +
>> +void drm_client_dev_lastclose(struct drm_device *dev)
>> +{
>> +	struct drm_client_dev *client;
>> +	int ret;
>> +
>> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
>> +		return;
>> +
>> +	mutex_lock(&drm_client_list_lock);
>> +	list_for_each_entry(client, &drm_client_list, list)
>> +		if (client->dev == dev && client->funcs->lastclose) {
>> +			ret = client->funcs->lastclose(client);
>> +			DRM_DEV_DEBUG_KMS(dev->dev, "%s: ret=%d\n",
>> +					  client->funcs->name, ret);
>> +		}
>> +	mutex_unlock(&drm_client_list_lock);
>> +}
>> +
>> +/* Get static info */
>> +static int drm_client_init(struct drm_client_dev *client, struct drm_file *file)
>> +{
>> +	struct drm_mode_card_res card_res = {};
>> +	struct drm_device *dev = client->dev;
>> +	u32 *crtcs;
>> +	int ret;
>> +
>> +	ret = drm_mode_getresources(dev, &card_res, file, false);
>> +	if (ret)
>> +		return ret;
>> +	if (!card_res.count_crtcs)
>> +		return -ENOENT;
>> +
>> +	crtcs = kmalloc_array(card_res.count_crtcs, sizeof(*crtcs), GFP_KERNEL);
>> +	if (!crtcs)
>> +		return -ENOMEM;
>> +
>> +	card_res.count_fbs = 0;
>> +	card_res.count_connectors = 0;
>> +	card_res.count_encoders = 0;
>> +	card_res.crtc_id_ptr = (unsigned long)crtcs;
>> +
>> +	ret = drm_mode_getresources(dev, &card_res, file, false);
>> +	if (ret) {
>> +		kfree(crtcs);
>> +		return ret;
>> +	}
>> +
>> +	client->crtcs = crtcs;
>> +	client->num_crtcs = card_res.count_crtcs;
>> +	client->min_width = card_res.min_width;
>> +	client->max_width = card_res.max_width;
>> +	client->min_height = card_res.min_height;
>> +	client->max_height = card_res.max_height;
>> +
>> +	return 0;
>> +}
>> +
>> +/**
>> + * drm_client_get_file - Get a DRM file
>> + * @client: DRM client
>> + *
>> + * This function makes sure the client has a &drm_file available. The client
>> + * doesn't normally need to call this, since all client functions that depends
>> + * on a DRM file will call it. A matching call to drm_client_put_file() is
>> + * necessary.
>> + *
>> + * The reason for not opening a DRM file when a @client is created is because
>> + * we have to take a ref on the driver module due to &drm_driver->postclose
>> + * being called in drm_file_free(). Having a DRM file open for the lifetime of
>> + * the client instance would block driver module unload.
>> + *
>> + * Returns:
>> + * Zero on success, negative error code on failure.
>> + */
>> +int drm_client_get_file(struct drm_client_dev *client)
>> +{
>> +	struct drm_device *dev = client->dev;
>> +	struct drm_file *file;
>> +	int ret = 0;
>> +
>> +	mutex_lock(&client->lock);
>> +
>> +	if (client->file_ref_count++) {
>> +		mutex_unlock(&client->lock);
>> +		return 0;
>> +	}
>> +
>> +	if (!try_module_get(dev->driver->fops->owner)) {
>> +		ret = -ENODEV;
>> +		goto err_unlock;
>> +	}
>> +
>> +	drm_dev_get(dev);
>> +
>> +	file = drm_file_alloc(dev->primary);
>> +	if (IS_ERR(file)) {
>> +		ret = PTR_ERR(file);
>> +		goto err_put;
>> +	}
>> +
>> +	if (!client->crtcs) {
>> +		ret = drm_client_init(client, file);
>> +		if (ret)
>> +			goto err_free;
>> +	}
>> +
>> +	mutex_lock(&dev->filelist_mutex);
>> +	list_add(&file->lhead, &dev->filelist_internal);
>> +	mutex_unlock(&dev->filelist_mutex);
>> +
>> +	client->file = file;
>> +
>> +	mutex_unlock(&client->lock);
>> +
>> +	return 0;
>> +
>> +err_free:
>> +	drm_file_free(file);
>> +err_put:
>> +	drm_dev_put(dev);
>> +	module_put(dev->driver->fops->owner);
>> +err_unlock:
>> +	client->file_ref_count = 0;
>> +	mutex_unlock(&client->lock);
>> +
>> +	return ret;
>> +}
>> +EXPORT_SYMBOL(drm_client_get_file);
>> +
>> +void drm_client_put_file(struct drm_client_dev *client)
>> +{
>> +	struct drm_device *dev = client->dev;
>> +
>> +	if (!client)
>> +		return;
>> +
>> +	mutex_lock(&client->lock);
>> +
>> +	if (WARN_ON(!client->file_ref_count))
>> +		goto out_unlock;
>> +
>> +	if (--client->file_ref_count)
>> +		goto out_unlock;
>> +
>> +	mutex_lock(&dev->filelist_mutex);
>> +	list_del(&client->file->lhead);
>> +	mutex_unlock(&dev->filelist_mutex);
>> +
>> +	drm_file_free(client->file);
>> +	client->file = NULL;
>> +	drm_dev_put(dev);
>> +	module_put(dev->driver->fops->owner);
>> +out_unlock:
>> +	mutex_unlock(&client->lock);
>> +}
>> +EXPORT_SYMBOL(drm_client_put_file);
>> +
>> +static struct drm_pending_event *
>> +drm_client_read_get_pending_event(struct drm_device *dev, struct drm_file *file)
>> +{
>> +	struct drm_pending_event *e = NULL;
>> +	int ret;
>> +
>> +	ret = mutex_lock_interruptible(&file->event_read_lock);
>> +	if (ret)
>> +		return ERR_PTR(ret);
>> +
>> +	spin_lock_irq(&dev->event_lock);
>> +	if (!list_empty(&file->event_list)) {
>> +		e = list_first_entry(&file->event_list,
>> +				     struct drm_pending_event, link);
>> +		file->event_space += e->event->length;
>> +		list_del(&e->link);
>> +	}
>> +	spin_unlock_irq(&dev->event_lock);
>> +
>> +	mutex_unlock(&file->event_read_lock);
>> +
>> +	return e;
>> +}
>> +
>> +struct drm_event *
>> +drm_client_read_event(struct drm_client_dev *client, bool block)
>> +{
>> +	struct drm_file *file = client->file;
>> +	struct drm_device *dev = client->dev;
>> +	struct drm_pending_event *e;
>> +	struct drm_event *event;
>> +	int ret;
>> +
>> +	/* Allocate so it fits all events, there's a sanity check later */
>> +	event = kzalloc(128, GFP_KERNEL);
>> +	if (!event)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	e = drm_client_read_get_pending_event(dev, file);
>> +	if (IS_ERR(e)) {
>> +		ret = PTR_ERR(e);
>> +		goto err_free;
>> +	}
>> +
>> +	if (!e && !block) {
>> +		ret = 0;
>> +		goto err_free;
>> +	}
>> +
>> +	ret = wait_event_interruptible_timeout(file->event_wait,
>> +					       !list_empty(&file->event_list),
>> +					       5 * HZ);
>> +	if (!ret)
>> +		ret = -ETIMEDOUT;
>> +	if (ret < 0)
>> +		goto err_free;
>> +
>> +	e = drm_client_read_get_pending_event(dev, file);
>> +	if (IS_ERR_OR_NULL(e)) {
>> +		ret = PTR_ERR_OR_ZERO(e);
>> +		goto err_free;
>> +	}
>> +
>> +	if (WARN_ON(e->event->length > 128)) {
>> +		/* Increase buffer if this happens */
>> +		ret = -ENOMEM;
>> +		goto err_free;
>> +	}
>> +
>> +	memcpy(event, e->event, e->event->length);
>> +	kfree(e);
>> +
>> +	return event;
>> +
>> +err_free:
>> +	kfree(event);
>> +
>> +	return ret ? ERR_PTR(ret) : NULL;
>> +}
>> +EXPORT_SYMBOL(drm_client_read_event);
>> +
>> +static void drm_client_connector_free(struct drm_client_connector *connector)
>> +{
>> +	if (!connector)
>> +		return;
>> +	kfree(connector->modes);
>> +	kfree(connector);
>> +}
>> +
>> +static struct drm_client_connector *
>> +drm_client_get_connector(struct drm_client_dev *client, unsigned int id)
>> +{
>> +	struct drm_mode_get_connector req = {
>> +		.connector_id = id,
>> +	};
>> +	struct drm_client_connector *connector;
>> +	struct drm_mode_modeinfo *modes = NULL;
>> +	struct drm_device *dev = client->dev;
>> +	struct drm_connector *conn;
>> +	bool non_desktop;
>> +	int ret;
>> +
>> +	connector = kzalloc(sizeof(*connector), GFP_KERNEL);
>> +	if (!connector)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	ret = drm_mode_getconnector(dev, &req, client->file, false);
>> +	if (ret)
>> +		goto err_free;
>> +
>> +	connector->conn_id = id;
>> +	connector->status = req.connection;
>> +
>> +	conn = drm_connector_lookup(dev, client->file, id);
>> +	if (!conn) {
>> +		ret = -ENOENT;
>> +		goto err_free;
>> +	}
>> +
>> +	non_desktop = conn->display_info.non_desktop;
>> +
>> +	connector->has_tile = conn->has_tile;
>> +	connector->tile_h_loc = conn->tile_h_loc;
>> +	connector->tile_v_loc = conn->tile_v_loc;
>> +	if (conn->tile_group)
>> +		connector->tile_group = conn->tile_group->id;
>> +
>> +	drm_connector_put(conn);
>> +
>> +	if (non_desktop) {
>> +		kfree(connector);
>> +		return NULL;
>> +	}
>> +
>> +	if (!req.count_modes)
>> +		return connector;
>> +
>> +	modes = kcalloc(req.count_modes, sizeof(*modes), GFP_KERNEL);
>> +	if (!modes) {
>> +		ret = -ENOMEM;
>> +		goto err_free;
>> +	}
>> +
>> +	connector->modes = modes;
>> +	connector->num_modes = req.count_modes;
>> +
>> +	req.count_props = 0;
>> +	req.count_encoders = 0;
>> +	req.modes_ptr = (unsigned long)modes;
>> +
>> +	ret = drm_mode_getconnector(dev, &req, client->file, false);
>> +	if (ret)
>> +		goto err_free;
>> +
>> +	return connector;
>> +
>> +err_free:
>> +	kfree(modes);
>> +	kfree(connector);
>> +
>> +	return ERR_PTR(ret);
>> +}
>> +
>> +static int drm_client_get_connectors(struct drm_client_dev *client,
>> +				     struct drm_client_connector ***connectors)
>> +{
>> +	struct drm_mode_card_res card_res = {};
>> +	struct drm_device *dev = client->dev;
>> +	int ret, num_connectors;
>> +	u32 *connector_ids;
>> +	unsigned int i;
>> +
>> +	ret = drm_mode_getresources(dev, &card_res, client->file, false);
>> +	if (ret)
>> +		return ret;
>> +	if (!card_res.count_connectors)
>> +		return 0;
>> +
>> +	num_connectors = card_res.count_connectors;
>> +	connector_ids = kcalloc(num_connectors,
>> +				sizeof(*connector_ids), GFP_KERNEL);
>> +	if (!connector_ids)
>> +		return -ENOMEM;
>> +
>> +	card_res.count_fbs = 0;
>> +	card_res.count_crtcs = 0;
>> +	card_res.count_encoders = 0;
>> +	card_res.connector_id_ptr = (unsigned long)connector_ids;
>> +
>> +	ret = drm_mode_getresources(dev, &card_res, client->file, false);
>> +	if (ret)
>> +		goto err_free;
>> +
>> +	*connectors = kcalloc(num_connectors, sizeof(**connectors), GFP_KERNEL);
>> +	if (!(*connectors)) {
>> +		ret = -ENOMEM;
>> +		goto err_free;
>> +	}
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		struct drm_client_connector *connector;
>> +
>> +		connector = drm_client_get_connector(client, connector_ids[i]);
>> +		if (IS_ERR(connector)) {
>> +			ret = PTR_ERR(connector);
>> +			goto err_free;
>> +		}
>> +		if (connector)
>> +			(*connectors)[i] = connector;
>> +		else
>> +			num_connectors--;
>> +	}
>> +
>> +	if (!num_connectors) {
>> +		ret = 0;
>> +		goto err_free;
>> +	}
>> +
>> +	return num_connectors;
>> +
>> +err_free:
>> +	if (connectors)
>> +		for (i = 0; i < num_connectors; i++)
>> +			drm_client_connector_free((*connectors)[i]);
>> +
>> +	kfree(connectors);
>> +	kfree(connector_ids);
>> +
>> +	return ret;
>> +}
>> +
>> +static bool
>> +drm_client_connector_is_enabled(struct drm_client_connector *connector,
>> +				bool strict)
>> +{
>> +	if (strict)
>> +		return connector->status == connector_status_connected;
>> +	else
>> +		return connector->status != connector_status_disconnected;
>> +}
>> +
>> +struct drm_mode_modeinfo *
>> +drm_client_display_first_mode(struct drm_client_display *display)
>> +{
>> +	if (!display->num_modes)
>> +		return NULL;
>> +	return display->modes;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_first_mode);
>> +
>> +struct drm_mode_modeinfo *
>> +drm_client_display_next_mode(struct drm_client_display *display,
>> +			     struct drm_mode_modeinfo *mode)
>> +{
>> +	struct drm_mode_modeinfo *modes = display->modes;
>> +
>> +	if (++mode < &modes[display->num_modes])
>> +		return mode;
>> +
>> +	return NULL;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_next_mode);
>> +
>> +static void
>> +drm_client_display_fill_tile_modes(struct drm_client_display *display,
>> +				   struct drm_mode_modeinfo *tile_modes)
>> +{
>> +	unsigned int i, j, num_modes = display->connectors[0]->num_modes;
>> +	struct drm_mode_modeinfo *tile_mode, *conn_mode;
>> +
>> +	if (!num_modes) {
>> +		kfree(tile_modes);
>> +		kfree(display->modes);
>> +		display->modes = NULL;
>> +		display->num_modes = 0;
>> +		return;
>> +	}
>> +
>> +	for (i = 0; i < num_modes; i++) {
>> +		tile_mode = &tile_modes[i];
>> +
>> +		conn_mode = &display->connectors[0]->modes[i];
>> +		tile_mode->clock = conn_mode->clock;
>> +		tile_mode->vscan = conn_mode->vscan;
>> +		tile_mode->vrefresh = conn_mode->vrefresh;
>> +		tile_mode->flags = conn_mode->flags;
>> +		tile_mode->type = conn_mode->type;
>> +
>> +		for (j = 0; j < display->num_connectors; j++) {
>> +			conn_mode = &display->connectors[j]->modes[i];
>> +
>> +			if (!display->connectors[j]->tile_h_loc) {
>> +				tile_mode->hdisplay += conn_mode->hdisplay;
>> +				tile_mode->hsync_start += conn_mode->hsync_start;
>> +				tile_mode->hsync_end += conn_mode->hsync_end;
>> +				tile_mode->htotal += conn_mode->htotal;
>> +			}
>> +
>> +			if (!display->connectors[j]->tile_v_loc) {
>> +				tile_mode->vdisplay += conn_mode->vdisplay;
>> +				tile_mode->vsync_start += conn_mode->vsync_start;
>> +				tile_mode->vsync_end += conn_mode->vsync_end;
>> +				tile_mode->vtotal += conn_mode->vtotal;
>> +			}
>> +		}
>> +	}
>> +
>> +	kfree(display->modes);
>> +	display->modes = tile_modes;
>> +	display->num_modes = num_modes;
>> +}
>> +
>> +/**
>> + * drm_client_display_update_modes - Fetch display modes
>> + * @display: Client display
>> + * @mode_changed: Optional pointer to boolen which return whether the modes
>> + *                have changed or not.
>> + *
>> + * This function can be used in the client hotplug callback to check if the
>> + * video modes have changed and get them up-to-date.
>> + *
>> + * Returns:
>> + * Number of modes on success, negative error code on failure.
>> + */
>> +int drm_client_display_update_modes(struct drm_client_display *display,
>> +				    bool *mode_changed)
>> +{
>> +	unsigned int num_connectors = display->num_connectors;
>> +	struct drm_client_dev *client = display->client;
>> +	struct drm_mode_modeinfo *display_tile_modes;
>> +	struct drm_client_connector **connectors;
>> +	unsigned int i, num_modes = 0;
>> +	bool dummy_changed = false;
>> +	int ret;
>> +
>> +	if (mode_changed)
>> +		*mode_changed = false;
>> +	else
>> +		mode_changed = &dummy_changed;
>> +
>> +	if (display->cloned)
>> +		return 2;
>> +
>> +	ret = drm_client_get_file(client);
>> +	if (ret)
>> +		return ret;
>> +
>> +	connectors = kcalloc(num_connectors, sizeof(*connectors), GFP_KERNEL);
>> +	if (!connectors) {
>> +		ret = -ENOMEM;
>> +		goto out_put_file;
>> +	}
>> +
>> +	/* Get a new set for comparison */
>> +	for (i = 0; i < num_connectors; i++) {
>> +		connectors[i] = drm_client_get_connector(client, display->connectors[i]->conn_id);
>> +		if (IS_ERR_OR_NULL(connectors[i])) {
>> +			ret = PTR_ERR_OR_ZERO(connectors[i]);
>> +			if (!ret)
>> +				ret = -ENOENT;
>> +			goto out_cleanup;
>> +		}
>> +	}
>> +
>> +	/* All connectors should have the same number of modes */
>> +	num_modes = connectors[0]->num_modes;
>> +	for (i = 0; i < num_connectors; i++) {
>> +		if (num_modes != connectors[i]->num_modes) {
>> +			ret = -EINVAL;
>> +			goto out_cleanup;
>> +		}
>> +	}
>> +
>> +	if (num_connectors > 1) {
>> +		display_tile_modes = kcalloc(num_modes, sizeof(*display_tile_modes), GFP_KERNEL);
>> +		if (!display_tile_modes) {
>> +			ret = -ENOMEM;
>> +			goto out_cleanup;
>> +		}
>> +	}
>> +
>> +	mutex_lock(&display->modes_lock);
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		display->connectors[i]->status = connectors[i]->status;
>> +		if (display->connectors[i]->num_modes != connectors[i]->num_modes) {
>> +			display->connectors[i]->num_modes = connectors[i]->num_modes;
>> +			kfree(display->connectors[i]->modes);
>> +			display->connectors[i]->modes = connectors[i]->modes;
>> +			connectors[i]->modes = NULL;
>> +			*mode_changed = true;
>> +		}
>> +	}
>> +
>> +	if (num_connectors > 1)
>> +		drm_client_display_fill_tile_modes(display, display_tile_modes);
>> +	else
>> +		display->modes = display->connectors[0]->modes;
>> +
>> +	mutex_unlock(&display->modes_lock);
>> +
>> +out_cleanup:
>> +	for (i = 0; i < num_connectors; i++)
>> +		drm_client_connector_free(connectors[i]);
>> +	kfree(connectors);
>> +out_put_file:
>> +	drm_client_put_file(client);
>> +
>> +	return ret ? ret : num_modes;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_update_modes);
>> +
>> +void drm_client_display_free(struct drm_client_display *display)
>> +{
>> +	unsigned int i;
>> +
>> +	if (!display)
>> +		return;
>> +
>> +	/* tile modes? */
>> +	if (display->modes != display->connectors[0]->modes)
>> +		kfree(display->modes);
>> +
>> +	for (i = 0; i < display->num_connectors; i++)
>> +		drm_client_connector_free(display->connectors[i]);
>> +
>> +	kfree(display->connectors);
>> +	mutex_destroy(&display->modes_lock);
>> +	kfree(display);
>> +}
>> +EXPORT_SYMBOL(drm_client_display_free);
>> +
>> +static struct drm_client_display *
>> +drm_client_display_alloc(struct drm_client_dev *client,
>> +			 unsigned int num_connectors)
>> +{
>> +	struct drm_client_display *display;
>> +	struct drm_client_connector **connectors;
>> +
>> +	display = kzalloc(sizeof(*display), GFP_KERNEL);
>> +	connectors = kcalloc(num_connectors, sizeof(*connectors), GFP_KERNEL);
>> +	if (!display || !connectors) {
>> +		kfree(display);
>> +		kfree(connectors);
>> +		return NULL;
>> +	}
>> +
>> +	mutex_init(&display->modes_lock);
>> +	display->client = client;
>> +	display->connectors = connectors;
>> +	display->num_connectors = num_connectors;
>> +
>> +	return display;
>> +}
>> +
>> +/* Logic is from drm_fb_helper */
>> +static struct drm_client_display *
>> +drm_client_connector_pick_cloned(struct drm_client_dev *client,
>> +				 struct drm_client_connector **connectors,
>> +				 unsigned int num_connectors)
>> +{
>> +	struct drm_mode_modeinfo modes[2], udmt_mode, *mode, *tmp;
>> +	struct drm_display_mode *dmt_display_mode = NULL;
>> +	unsigned int i, j, conns[2], num_conns = 0;
>> +	struct drm_client_connector *connector;
>> +	struct drm_device *dev = client->dev;
>> +	struct drm_client_display *display;
>> +
>> +	/* only contemplate cloning in the single crtc case */
>> +	if (dev->mode_config.num_crtc > 1)
>> +		return NULL;
>> +retry:
>> +	for (i = 0; i < num_connectors; i++) {
>> +		connector = connectors[i];
>> +		if (!connector || connector->has_tile || !connector->num_modes)
>> +			continue;
>> +
>> +		for (j = 0; j < connector->num_modes; j++) {
>> +			mode = &connector->modes[j];
>> +			if (dmt_display_mode) {
>> +				if (drm_umode_equal(&udmt_mode, mode)) {
>> +					conns[num_conns] = i;
>> +					modes[num_conns++] = *mode;
>> +					break;
>> +				}
>> +			} else {
>> +				if (mode->type & DRM_MODE_TYPE_USERDEF) {
>> +					conns[num_conns] = i;
>> +					modes[num_conns++] = *mode;
>> +					break;
>> +				}
>> +			}
>> +		}
>> +		if (num_conns == 2)
>> +			break;
>> +	}
>> +
>> +	if (num_conns == 2)
>> +		goto found;
>> +
>> +	if (dmt_display_mode)
>> +		return NULL;
>> +
>> +	dmt_display_mode = drm_mode_find_dmt(dev, 1024, 768, 60, false);
>> +	drm_mode_convert_to_umode(&udmt_mode, dmt_display_mode);
>> +	drm_mode_destroy(dev, dmt_display_mode);
>> +
>> +	goto retry;
>> +
>> +found:
>> +	tmp = kcalloc(2, sizeof(*tmp), GFP_KERNEL);
>> +	if (!tmp)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	display = drm_client_display_alloc(client, 2);
>> +	if (!display) {
>> +		kfree(tmp);
>> +		return ERR_PTR(-ENOMEM);
>> +	}
>> +
>> +	for (i = 0; i < 2; i++) {
>> +		connector = connectors[conns[i]];
>> +		display->connectors[i] = connector;
>> +		connectors[conns[i]] = NULL;
>> +		kfree(connector->modes);
>> +		tmp[i] = modes[i];
>> +		connector->modes = &tmp[i];
>> +		connector->num_modes = 1;
>> +	}
>> +
>> +	display->cloned = true;
>> +	display->modes = &tmp[0];
>> +	display->num_modes = 1;
>> +
>> +	return display;
>> +}
>> +
>> +static struct drm_client_display *
>> +drm_client_connector_pick_tile(struct drm_client_dev *client,
>> +			       struct drm_client_connector **connectors,
>> +			       unsigned int num_connectors)
>> +{
>> +	unsigned int i, num_conns, num_modes, tile_group = 0;
>> +	struct drm_mode_modeinfo *tile_modes = NULL;
>> +	struct drm_client_connector *connector;
>> +	struct drm_client_display *display;
>> +	u16 conns[32];
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		connector = connectors[i];
>> +		if (!connector || !connector->tile_group)
>> +			continue;
>> +
>> +		if (!tile_group) {
>> +			tile_group = connector->tile_group;
>> +			num_modes = connector->num_modes;
>> +		}
>> +
>> +		if (connector->tile_group != tile_group)
>> +			continue;
>> +
>> +		if (num_modes != connector->num_modes) {
>> +			DRM_ERROR("Tile connectors must have the same number of modes\n");
>> +			return ERR_PTR(-EINVAL);
>> +		}
>> +
>> +		conns[num_conns++] = i;
>> +		if (WARN_ON(num_conns == 33))
>> +			return ERR_PTR(-EINVAL);
>> +	}
>> +
>> +	if (!num_conns)
>> +		return NULL;
>> +
>> +	if (num_modes) {
>> +		tile_modes = kcalloc(num_modes, sizeof(*tile_modes), GFP_KERNEL);
>> +		if (!tile_modes)
>> +			return ERR_PTR(-ENOMEM);
>> +	}
>> +
>> +	display = drm_client_display_alloc(client, num_conns);
>> +	if (!display) {
>> +		kfree(tile_modes);
>> +		return ERR_PTR(-ENOMEM);
>> +	}
>> +
>> +	if (num_modes)
>> +		drm_client_display_fill_tile_modes(display, tile_modes);
>> +
>> +	return display;
>> +}
>> +
>> +static struct drm_client_display *
>> +drm_client_connector_pick_not_tile(struct drm_client_dev *client,
>> +				   struct drm_client_connector **connectors,
>> +				   unsigned int num_connectors)
>> +{
>> +	struct drm_client_display *display;
>> +	unsigned int i;
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		if (!connectors[i] || connectors[i]->has_tile)
>> +			continue;
>> +		break;
>> +	}
>> +
>> +	if (i == num_connectors)
>> +		return NULL;
>> +
>> +	display = drm_client_display_alloc(client, 1);
>> +	if (!display)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	display->connectors[0] = connectors[i];
>> +	connectors[i] = NULL;
>> +	display->modes = display->connectors[0]->modes;
>> +	display->num_modes = display->connectors[0]->num_modes;
>> +
>> +	return display;
>> +}
>> +
>> +/* Get connectors and bundle them up into displays */
>> +static int drm_client_get_displays(struct drm_client_dev *client,
>> +				   struct drm_client_display ***displays)
>> +{
>> +	int ret, num_connectors, num_displays = 0;
>> +	struct drm_client_connector **connectors;
>> +	struct drm_client_display *display;
>> +	unsigned int i;
>> +
>> +	ret = drm_client_get_file(client);
>> +	if (ret)
>> +		return ret;
>> +
>> +	num_connectors = drm_client_get_connectors(client, &connectors);
>> +	if (num_connectors <= 0) {
>> +		ret = num_connectors;
>> +		goto err_put_file;
>> +	}
>> +
>> +	*displays = kcalloc(num_connectors, sizeof(*displays), GFP_KERNEL);
>> +	if (!(*displays)) {
>> +		ret = -ENOMEM;
>> +		goto err_free;
>> +	}
>> +
>> +	display = drm_client_connector_pick_cloned(client, connectors,
>> +						   num_connectors);
>> +	if (IS_ERR(display)) {
>> +		ret = PTR_ERR(display);
>> +		goto err_free;
>> +	}
>> +	if (display)
>> +		(*displays)[num_displays++] = display;
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		display = drm_client_connector_pick_tile(client, connectors,
>> +							 num_connectors);
>> +		if (IS_ERR(display)) {
>> +			ret = PTR_ERR(display);
>> +			goto err_free;
>> +		}
>> +		if (!display)
>> +			break;
>> +		(*displays)[num_displays++] = display;
>> +	}
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		display = drm_client_connector_pick_not_tile(client, connectors,
>> +							     num_connectors);
>> +		if (IS_ERR(display)) {
>> +			ret = PTR_ERR(display);
>> +			goto err_free;
>> +		}
>> +		if (!display)
>> +			break;
>> +		(*displays)[num_displays++] = display;
>> +	}
>> +
>> +	for (i = 0; i < num_connectors; i++) {
>> +		if (connectors[i]) {
>> +			DRM_INFO("Connector %u fell through the cracks.\n",
>> +				 connectors[i]->conn_id);
>> +			drm_client_connector_free(connectors[i]);
>> +		}
>> +	}
>> +
>> +	drm_client_put_file(client);
>> +	kfree(connectors);
>> +
>> +	return num_displays;
>> +
>> +err_free:
>> +	for (i = 0; i < num_displays; i++)
>> +		drm_client_display_free((*displays)[i]);
>> +	kfree(*displays);
>> +	*displays = NULL;
>> +	for (i = 0; i < num_connectors; i++)
>> +		drm_client_connector_free(connectors[i]);
>> +	kfree(connectors);
>> +err_put_file:
>> +	drm_client_put_file(client);
>> +
>> +	return ret;
>> +}
>> +
>> +static bool
>> +drm_client_display_is_enabled(struct drm_client_display *display, bool strict)
>> +{
>> +	unsigned int i;
>> +
>> +	if (!display->num_modes)
>> +		return false;
>> +
>> +	for (i = 0; i < display->num_connectors; i++)
>> +		if (!drm_client_connector_is_enabled(display->connectors[i], strict))
>> +			return false;
>> +
>> +	return true;
>> +}
>> +
>> +/**
>> + * drm_client_display_get_first_enabled - Get first enabled display
>> + * @client: DRM client
>> + * @strict: If true the connector(s) have to be connected, if false they can
>> + *          also have unknown status.
>> + *
>> + * This function gets all connectors and bundles them into displays
>> + * (tiled/cloned). It then picks the first one with connectors that is enabled
>> + * according to @strict.
>> + *
>> + * Returns:
>> + * Pointer to a client display if such a display was found, NULL if not found
>> + * or an error pointer on failure.
>> + */
>> +struct drm_client_display *
>> +drm_client_display_get_first_enabled(struct drm_client_dev *client, bool strict)
>> +{
>> +	struct drm_client_display **displays, *display = NULL;
>> +	int num_displays;
>> +	unsigned int i;
>> +
>> +	num_displays = drm_client_get_displays(client, &displays);
>> +	if (num_displays < 0)
>> +		return ERR_PTR(num_displays);
>> +	if (!num_displays)
>> +		return NULL;
>> +
>> +	for (i = 0; i < num_displays; i++) {
>> +		if (!display &&
>> +		    drm_client_display_is_enabled(displays[i], strict)) {
>> +			display = displays[i];
>> +			continue;
>> +		}
>> +		drm_client_display_free(displays[i]);
>> +	}
>> +
>> +	kfree(displays);
>> +
>> +	return display;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_get_first_enabled);
>> +
>> +unsigned int
>> +drm_client_display_preferred_depth(struct drm_client_display *display)
>> +{
>> +	struct drm_connector *conn;
>> +	unsigned int ret;
>> +
>> +	conn = drm_connector_lookup(display->client->dev, NULL,
>> +				    display->connectors[0]->conn_id);
>> +	if (!conn)
>> +		return 0;
>> +
>> +	if (conn->cmdline_mode.bpp_specified)
>> +		ret = conn->cmdline_mode.bpp;
>> +	else
>> +		ret = display->client->dev->mode_config.preferred_depth;
>> +
>> +	drm_connector_put(conn);
>> +
>> +	return ret;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_preferred_depth);
>> +
>> +int drm_client_display_dpms(struct drm_client_display *display, int mode)
>> +{
>> +	struct drm_mode_obj_set_property prop;
>> +
>> +	prop.value = mode;
>> +	prop.prop_id = display->client->dev->mode_config.dpms_property->base.id;
>> +	prop.obj_id = display->connectors[0]->conn_id;
>> +	prop.obj_type = DRM_MODE_OBJECT_CONNECTOR;
>> +
>> +	return drm_mode_obj_set_property(display->client->dev, &prop,
>> +					 display->client->file);
>> +}
>> +EXPORT_SYMBOL(drm_client_display_dpms);
>> +
>> +int drm_client_display_wait_vblank(struct drm_client_display *display)
>> +{
>> +	struct drm_crtc *crtc;
>> +	union drm_wait_vblank vblank_req = {
>> +		.request = {
>> +			.type = _DRM_VBLANK_RELATIVE,
>> +			.sequence = 1,
>> +		},
>> +	};
>> +
>> +	crtc = drm_crtc_find(display->client->dev, display->client->file,
>> +			     display->connectors[0]->crtc_id);
>> +	if (!crtc)
>> +		return -ENOENT;
>> +
>> +	vblank_req.request.type |= drm_crtc_index(crtc) << _DRM_VBLANK_HIGH_CRTC_SHIFT;
>> +
>> +	return drm_wait_vblank(display->client->dev, &vblank_req,
>> +			       display->client->file);
>> +}
>> +EXPORT_SYMBOL(drm_client_display_wait_vblank);
>> +
>> +static int drm_client_get_crtc_index(struct drm_client_dev *client, u32 id)
>> +{
>> +	int i;
>> +
>> +	for (i = 0; i < client->num_crtcs; i++)
>> +		if (client->crtcs[i] == id)
>> +			return i;
>> +
>> +	return -ENOENT;
>> +}
>> +
>> +static int drm_client_display_find_crtcs(struct drm_client_display *display)
>> +{
>> +	struct drm_client_dev *client = display->client;
>> +	struct drm_device *dev = client->dev;
>> +	struct drm_file *file = client->file;
>> +	u32 encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
>> +	unsigned int i, j, available_crtcs = ~0;
>> +	struct drm_mode_get_connector conn_req;
>> +	struct drm_mode_get_encoder enc_req;
>> +	int ret;
>> +
>> +	/* Already done? */
>> +	if (display->connectors[0]->crtc_id)
>> +		return 0;
>> +
>> +	for (i = 0; i < display->num_connectors; i++) {
>> +		u32 active_crtcs = 0, crtcs_for_connector = 0;
>> +		int crtc_idx;
>> +
>> +		memset(&conn_req, 0, sizeof(conn_req));
>> +		conn_req.connector_id = display->connectors[i]->conn_id;
>> +		conn_req.encoders_ptr = (unsigned long)(encoder_ids);
>> +		conn_req.count_encoders = DRM_CONNECTOR_MAX_ENCODER;
>> +		ret = drm_mode_getconnector(dev, &conn_req, file, false);
>> +		if (ret)
>> +			return ret;
>> +
>> +		if (conn_req.encoder_id) {
>> +			memset(&enc_req, 0, sizeof(enc_req));
>> +			enc_req.encoder_id = conn_req.encoder_id;
>> +			ret = drm_mode_getencoder(dev, &enc_req, file);
>> +			if (ret)
>> +				return ret;
>> +			crtcs_for_connector |= enc_req.possible_crtcs;
>> +			if (crtcs_for_connector & available_crtcs)
>> +				goto found;
>> +		}
>> +
>> +		for (j = 0; j < conn_req.count_encoders; j++) {
>> +			memset(&enc_req, 0, sizeof(enc_req));
>> +			enc_req.encoder_id = encoder_ids[j];
>> +			ret = drm_mode_getencoder(dev, &enc_req, file);
>> +			if (ret)
>> +				return ret;
>> +
>> +			crtcs_for_connector |= enc_req.possible_crtcs;
>> +
>> +			if (enc_req.crtc_id) {
>> +				crtc_idx = drm_client_get_crtc_index(client, enc_req.crtc_id);
>> +				if (crtc_idx >= 0)
>> +					active_crtcs |= 1 << crtc_idx;
>> +			}
>> +		}
>> +
>> +found:
>> +		crtcs_for_connector &= available_crtcs;
>> +		active_crtcs &= available_crtcs;
>> +
>> +		if (!crtcs_for_connector)
>> +			return -ENOENT;
>> +
>> +		if (active_crtcs)
>> +			crtc_idx = ffs(active_crtcs) - 1;
>> +		else
>> +			crtc_idx = ffs(crtcs_for_connector) - 1;
>> +
>> +		if (crtc_idx >= client->num_crtcs)
>> +			return -EINVAL;
>> +
>> +		display->connectors[i]->crtc_id = client->crtcs[crtc_idx];
>> +		available_crtcs &= ~BIT(crtc_idx);
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +/**
>> + * drm_client_display_commit_mode - Commit a mode to the crtc(s)
>> + * @display: Client display
>> + * @fb_id: Framebuffer id
>> + * @mode: Video mode
>> + *
>> + * Returns:
>> + * Zero on success, negative error code on failure.
>> + */
>> +int drm_client_display_commit_mode(struct drm_client_display *display,
>> +				   u32 fb_id, struct drm_mode_modeinfo *mode)
>> +{
>> +	struct drm_client_dev *client = display->client;
>> +	struct drm_device *dev = client->dev;
>> +	unsigned int num_crtcs = client->num_crtcs;
>> +	struct drm_file *file = client->file;
>> +	unsigned int *xoffsets = NULL, *yoffsets = NULL;
>> +	struct drm_mode_crtc *crtc_reqs, *req;
>> +	u32 cloned_conn_ids[2];
>> +	unsigned int i;
>> +	int idx, ret;
>> +
>> +	ret = drm_client_display_find_crtcs(display);
>> +	if (ret)
>> +		return ret;
>> +
>> +	crtc_reqs = kcalloc(num_crtcs, sizeof(*crtc_reqs), GFP_KERNEL);
>> +	if (!crtc_reqs)
>> +		return -ENOMEM;
>> +
>> +	for (i = 0; i < num_crtcs; i++)
>> +		crtc_reqs[i].crtc_id = client->crtcs[i];
>> +
>> +	if (drm_client_display_is_tiled(display)) {
>> +		/* TODO calculate tile crtc offsets */
>> +	}
>> +
>> +	for (i = 0; i < display->num_connectors; i++) {
>> +		idx = drm_client_get_crtc_index(client, display->connectors[i]->crtc_id);
>> +		if (idx < 0)
>> +			return -ENOENT;
>> +
>> +		req = &crtc_reqs[idx];
>> +
>> +		req->fb_id = fb_id;
>> +		if (xoffsets) {
>> +			req->x = xoffsets[i];
>> +			req->y = yoffsets[i];
>> +		}
>> +		req->mode_valid = 1;
>> +		req->mode = *mode;
>> +
>> +		if (display->cloned) {
>> +			cloned_conn_ids[0] = display->connectors[0]->conn_id;
>> +			cloned_conn_ids[1] = display->connectors[1]->conn_id;
>> +			req->set_connectors_ptr = (unsigned long)(cloned_conn_ids);
>> +			req->count_connectors = 2;
>> +			break;
>> +		}
>> +
>> +		req->set_connectors_ptr = (unsigned long)(&display->connectors[i]->conn_id);
>> +		req->count_connectors = 1;
>> +	}
>> +
>> +	for (i = 0; i < num_crtcs; i++) {
>> +		ret = drm_mode_setcrtc(dev, &crtc_reqs[i], file, false);
>> +		if (ret)
>> +			break;
>> +	}
>> +
>> +	kfree(xoffsets);
>> +	kfree(yoffsets);
>> +	kfree(crtc_reqs);
>> +
>> +	return ret;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_commit_mode);
>> +
>> +unsigned int drm_client_display_current_fb(struct drm_client_display *display)
>> +{
>> +	struct drm_client_dev *client = display->client;
>> +	int ret;
>> +	struct drm_mode_crtc crtc_req = {
>> +		.crtc_id = display->connectors[0]->crtc_id,
>> +	};
>> +
>> +	ret = drm_mode_getcrtc(client->dev, &crtc_req, client->file);
>> +	if (ret)
>> +		return 0;
>> +
>> +	return crtc_req.fb_id;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_current_fb);
>> +
>> +int drm_client_display_flush(struct drm_client_display *display, u32 fb_id,
>> +			     struct drm_clip_rect *clips, unsigned int num_clips)
>> +{
>> +	struct drm_client_dev *client = display->client;
>> +	struct drm_mode_fb_dirty_cmd dirty_req = {
>> +		.fb_id = fb_id,
>> +		.clips_ptr = (unsigned long)clips,
>> +		.num_clips = num_clips,
>> +	};
>> +	int ret;
>> +
>> +	if (display->no_flushing)
>> +		return 0;
>> +
>> +	ret = drm_mode_dirtyfb(client->dev, &dirty_req, client->file, false);
>> +	if (ret == -ENOSYS) {
>> +		ret = 0;
>> +		display->no_flushing = true;
>> +	}
>> +
>> +	return ret;
>> +}
>> +EXPORT_SYMBOL(drm_client_display_flush);
>> +
>> +int drm_client_display_page_flip(struct drm_client_display *display, u32 fb_id,
>> +				 bool event)
>> +{
>> +	struct drm_client_dev *client = display->client;
>> +	struct drm_mode_crtc_page_flip_target page_flip_req = {
>> +		.crtc_id = display->connectors[0]->crtc_id,
>> +		.fb_id = fb_id,
>> +	};
>> +
>> +	if (event)
>> +		page_flip_req.flags = DRM_MODE_PAGE_FLIP_EVENT;
>> +
>> +	return drm_mode_page_flip(client->dev, &page_flip_req, client->file);
>> +	/*
>> +	 * TODO:
>> +	 * Where do we flush on page flip? Should the driver handle that?
>> +	 */
>> +}
>> +EXPORT_SYMBOL(drm_client_display_page_flip);
>> +
>> +/**
>> + * drm_client_framebuffer_create - Create a client framebuffer
>> + * @client: DRM client
>> + * @mode: Display mode to create a buffer for
>> + * @format: Buffer format
>> + *
>> + * This function creates a &drm_client_buffer which consists of a
>> + * &drm_framebuffer backed by a dumb buffer. The dumb buffer is &dma_buf
>> + * exported to aquire a virtual address which is stored in
>> + * &drm_client_buffer->vaddr.
>> + * Call drm_client_framebuffer_delete() to free the buffer.
>> + *
>> + * Returns:
>> + * Pointer to a client buffer or an error pointer on failure.
>> + */
>> +struct drm_client_buffer *
>> +drm_client_framebuffer_create(struct drm_client_dev *client,
>> +			      struct drm_mode_modeinfo *mode, u32 format)
>> +{
>> +	struct drm_client_buffer *buffer;
>> +	int ret;
>> +
>> +	buffer = drm_client_buffer_create(client, mode->hdisplay,
>> +					  mode->vdisplay, format);
>> +	if (IS_ERR(buffer))
>> +		return buffer;
>> +
>> +	ret = drm_client_buffer_addfb(buffer, mode);
>> +	if (ret) {
>> +		drm_client_buffer_delete(buffer);
>> +		return ERR_PTR(ret);
>> +	}
>> +
>> +	return buffer;
>> +}
>> +EXPORT_SYMBOL(drm_client_framebuffer_create);
>> +
>> +void drm_client_framebuffer_delete(struct drm_client_buffer *buffer)
>> +{
>> +	drm_client_buffer_rmfb(buffer);
>> +	drm_client_buffer_delete(buffer);
>> +}
>> +EXPORT_SYMBOL(drm_client_framebuffer_delete);
>> +
>> +struct drm_client_buffer *
>> +drm_client_buffer_create(struct drm_client_dev *client, u32 width, u32 height,
>> +			 u32 format)
>> +{
>> +	struct drm_mode_create_dumb dumb_args = { 0 };
>> +	struct drm_prime_handle prime_args = { 0 };
>> +	struct drm_client_buffer *buffer;
>> +	struct dma_buf *dma_buf;
>> +	void *vaddr;
>> +	int ret;
>> +
>> +	buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
>> +	if (!buffer)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	ret = drm_client_get_file(client);
>> +	if (ret)
>> +		goto err_free;
>> +
>> +	buffer->client = client;
>> +	buffer->width = width;
>> +	buffer->height = height;
>> +	buffer->format = format;
>> +
>> +	dumb_args.width = buffer->width;
>> +	dumb_args.height = buffer->height;
>> +	dumb_args.bpp = drm_format_plane_cpp(format, 0) * 8;
>> +	ret = drm_mode_create_dumb(client->dev, &dumb_args, client->file);
>> +	if (ret)
>> +		goto err_put_file;
>> +
>> +	buffer->handle = dumb_args.handle;
>> +	buffer->pitch = dumb_args.pitch;
>> +	buffer->size = dumb_args.size;
>> +
>> +	prime_args.handle = dumb_args.handle;
>> +	ret = drm_prime_handle_to_fd(client->dev, &prime_args, client->file);
>> +	if (ret)
>> +		goto err_delete;
>> +
>> +	dma_buf = dma_buf_get(prime_args.fd);
>> +	if (IS_ERR(dma_buf)) {
>> +		ret = PTR_ERR(dma_buf);
>> +		goto err_delete;
>> +	}
>> +
>> +	buffer->dma_buf = dma_buf;
>> +
>> +	vaddr = dma_buf_vmap(dma_buf);
>> +	if (!vaddr) {
>> +		ret = -ENOMEM;
>> +		goto err_delete;
>> +	}
>> +
>> +	buffer->vaddr = vaddr;
>> +
>> +	return buffer;
>> +
>> +err_delete:
>> +	drm_client_buffer_delete(buffer);
>> +err_put_file:
>> +	drm_client_put_file(client);
>> +err_free:
>> +	kfree(buffer);
>> +
>> +	return ERR_PTR(ret);
>> +}
>> +EXPORT_SYMBOL(drm_client_buffer_create);
>> +
>> +void drm_client_buffer_delete(struct drm_client_buffer *buffer)
>> +{
>> +	if (!buffer)
>> +		return;
>> +
>> +	if (buffer->vaddr)
>> +		dma_buf_vunmap(buffer->dma_buf, buffer->vaddr);
>> +
>> +	if (buffer->dma_buf)
>> +		dma_buf_put(buffer->dma_buf);
>> +
>> +	drm_mode_destroy_dumb(buffer->client->dev, buffer->handle,
>> +			      buffer->client->file);
>> +	drm_client_put_file(buffer->client);
>> +	kfree(buffer);
>> +}
>> +EXPORT_SYMBOL(drm_client_buffer_delete);
>> +
>> +int drm_client_buffer_addfb(struct drm_client_buffer *buffer,
>> +			    struct drm_mode_modeinfo *mode)
>> +{
>> +	struct drm_client_dev *client = buffer->client;
>> +	struct drm_mode_fb_cmd2 fb_req = { };
>> +	unsigned int num_fbs, *fb_ids;
>> +	int i, ret;
>> +
>> +	if (buffer->num_fbs)
>> +		return -EINVAL;
>> +
>> +	if (mode->hdisplay > buffer->width || mode->vdisplay > buffer->height)
>> +		return -EINVAL;
>> +
>> +	num_fbs = buffer->height / mode->vdisplay;
>> +	fb_ids = kcalloc(num_fbs, sizeof(*fb_ids), GFP_KERNEL);
>> +	if (!fb_ids)
>> +		return -ENOMEM;
>> +
>> +	fb_req.width = mode->hdisplay;
>> +	fb_req.height = mode->vdisplay;
>> +	fb_req.pixel_format = buffer->format;
>> +	fb_req.handles[0] = buffer->handle;
>> +	fb_req.pitches[0] = buffer->pitch;
>> +
>> +	for (i = 0; i < num_fbs; i++) {
>> +		fb_req.offsets[0] = i * mode->vdisplay * buffer->pitch;
>> +		ret = drm_mode_addfb2(client->dev, &fb_req, client->file,
>> +				      client->funcs->name);
>> +		if (ret)
>> +			goto err_remove;
>> +		fb_ids[i] = fb_req.fb_id;
>> +	}
>> +
>> +	buffer->fb_ids = fb_ids;
>> +	buffer->num_fbs = num_fbs;
>> +
>> +	return 0;
>> +
>> +err_remove:
>> +	for (i--; i >= 0; i--)
>> +		drm_mode_rmfb(client->dev, fb_ids[i], client->file);
>> +	kfree(fb_ids);
>> +
>> +	return ret;
>> +}
>> +EXPORT_SYMBOL(drm_client_buffer_addfb);
>> +
>> +int drm_client_buffer_rmfb(struct drm_client_buffer *buffer)
>> +{
>> +	unsigned int i;
>> +	int ret;
>> +
>> +	if (!buffer || !buffer->num_fbs)
>> +		return 0;
>> +
>> +	for (i = 0; i < buffer->num_fbs; i++) {
>> +		ret = drm_mode_rmfb(buffer->client->dev, buffer->fb_ids[i],
>> +				    buffer->client->file);
>> +		if (ret)
>> +			DRM_DEV_ERROR(buffer->client->dev->dev,
>> +				      "Error removing FB:%u (%d)\n",
>> +				      buffer->fb_ids[i], ret);
>> +	}
>> +
>> +	kfree(buffer->fb_ids);
>> +	buffer->fb_ids = NULL;
>> +	buffer->num_fbs = 0;
>> +
>> +	return 0;
>> +}
>> +EXPORT_SYMBOL(drm_client_buffer_rmfb);
>> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
>> index f869de185986..db161337d87c 100644
>> --- a/drivers/gpu/drm/drm_drv.c
>> +++ b/drivers/gpu/drm/drm_drv.c
>> @@ -33,6 +33,7 @@
>>   #include <linux/mount.h>
>>   #include <linux/slab.h>
>>   
>> +#include <drm/drm_client.h>
>>   #include <drm/drm_drv.h>
>>   #include <drm/drmP.h>
>>   
>> @@ -463,6 +464,7 @@ int drm_dev_init(struct drm_device *dev,
>>   	dev->driver = driver;
>>   
>>   	INIT_LIST_HEAD(&dev->filelist);
>> +	INIT_LIST_HEAD(&dev->filelist_internal);
>>   	INIT_LIST_HEAD(&dev->ctxlist);
>>   	INIT_LIST_HEAD(&dev->vmalist);
>>   	INIT_LIST_HEAD(&dev->maplist);
>> @@ -787,6 +789,8 @@ int drm_dev_register(struct drm_device *dev, unsigned long flags)
>>   		 dev->dev ? dev_name(dev->dev) : "virtual device",
>>   		 dev->primary->index);
>>   
>> +	drm_client_dev_register(dev);
>> +
>>   	goto out_unlock;
>>   
>>   err_minors:
>> @@ -839,6 +843,8 @@ void drm_dev_unregister(struct drm_device *dev)
>>   	drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
>>   	drm_minor_unregister(dev, DRM_MINOR_RENDER);
>>   	drm_minor_unregister(dev, DRM_MINOR_CONTROL);
>> +
>> +	drm_client_dev_unregister(dev);
>>   }
>>   EXPORT_SYMBOL(drm_dev_unregister);
>>   
>> diff --git a/drivers/gpu/drm/drm_file.c b/drivers/gpu/drm/drm_file.c
>> index 55505378df47..bcc688e58776 100644
>> --- a/drivers/gpu/drm/drm_file.c
>> +++ b/drivers/gpu/drm/drm_file.c
>> @@ -35,6 +35,7 @@
>>   #include <linux/slab.h>
>>   #include <linux/module.h>
>>   
>> +#include <drm/drm_client.h>
>>   #include <drm/drm_file.h>
>>   #include <drm/drmP.h>
>>   
>> @@ -443,6 +444,8 @@ void drm_lastclose(struct drm_device * dev)
>>   
>>   	if (drm_core_check_feature(dev, DRIVER_LEGACY))
>>   		drm_legacy_dev_reinit(dev);
>> +
>> +	drm_client_dev_lastclose(dev);
>>   }
>>   
>>   /**
>> diff --git a/drivers/gpu/drm/drm_probe_helper.c b/drivers/gpu/drm/drm_probe_helper.c
>> index 2d1643bdae78..5d2a6c6717f5 100644
>> --- a/drivers/gpu/drm/drm_probe_helper.c
>> +++ b/drivers/gpu/drm/drm_probe_helper.c
>> @@ -33,6 +33,7 @@
>>   #include <linux/moduleparam.h>
>>   
>>   #include <drm/drmP.h>
>> +#include <drm/drm_client.h>
>>   #include <drm/drm_crtc.h>
>>   #include <drm/drm_fourcc.h>
>>   #include <drm/drm_crtc_helper.h>
>> @@ -563,6 +564,8 @@ void drm_kms_helper_hotplug_event(struct drm_device *dev)
>>   	drm_sysfs_hotplug_event(dev);
>>   	if (dev->mode_config.funcs->output_poll_changed)
>>   		dev->mode_config.funcs->output_poll_changed(dev);
>> +
>> +	drm_client_dev_hotplug(dev);
>>   }
>>   EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
>>   
>> diff --git a/include/drm/drm_client.h b/include/drm/drm_client.h
>> new file mode 100644
>> index 000000000000..88f6f87919c5
>> --- /dev/null
>> +++ b/include/drm/drm_client.h
>> @@ -0,0 +1,192 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>> +
>> +#include <linux/mutex.h>
>> +
>> +struct dma_buf;
>> +struct drm_clip_rect;
>> +struct drm_device;
>> +struct drm_file;
>> +struct drm_mode_modeinfo;
>> +
>> +struct drm_client_dev;
>> +
>> +/**
>> + * struct drm_client_funcs - DRM client  callbacks
>> + */
>> +struct drm_client_funcs {
>> +	/**
>> +	 * @name:
>> +	 *
>> +	 * Name of the client.
>> +	 */
>> +	const char *name;
>> +
>> +	/**
>> +	 * @new:
>> +	 *
>> +	 * Called when a client or a &drm_device is registered.
>> +	 * If the callback returns anything but zero, then this client instance
>> +	 * is dropped.
>> +	 *
>> +	 * This callback is mandatory.
>> +	 */
>> +	int (*new)(struct drm_client_dev *client);
>> +
>> +	/**
>> +	 * @remove:
>> +	 *
>> +	 * Called when a &drm_device is unregistered or the client is
>> +	 * unregistered. If zero is returned drm_client_free() is called
>> +	 * automatically. If the client can't drop it's resources it should
>> +	 * return non-zero and call drm_client_free() later.
>> +	 *
>> +	 * This callback is optional.
>> +	 */
>> +	int (*remove)(struct drm_client_dev *client);
>> +
>> +	/**
>> +	 * @lastclose:
>> +	 *
>> +	 * Called on drm_lastclose(). The first client instance in the list
>> +	 * that returns zero gets the privilege to restore and no more clients
>> +	 * are called.
>> +	 *
>> +	 * This callback is optional.
>> +	 */
>> +	int (*lastclose)(struct drm_client_dev *client);
>> +
>> +	/**
>> +	 * @hotplug:
>> +	 *
>> +	 * Called on drm_kms_helper_hotplug_event().
>> +	 *
>> +	 * This callback is optional.
>> +	 */
>> +	int (*hotplug)(struct drm_client_dev *client);
>> +
>> +// TODO
>> +//	void (*suspend)(struct drm_client_dev *client);
>> +//	void (*resume)(struct drm_client_dev *client);
>> +};
>> +
>> +/**
>> + * struct drm_client_dev - DRM client instance
>> + */
>> +struct drm_client_dev {
>> +	struct list_head list;
>> +	struct drm_device *dev;
>> +	const struct drm_client_funcs *funcs;
>> +	struct mutex lock;
>> +	struct drm_file *file;
>> +	unsigned int file_ref_count;
>> +	u32 *crtcs;
>> +	unsigned int num_crtcs;
>> +	u32 min_width;
>> +	u32 max_width;
>> +	u32 min_height;
>> +	u32 max_height;
>> +	void *private;
>> +};
>> +
>> +void drm_client_free(struct drm_client_dev *client);
>> +int drm_client_register(const struct drm_client_funcs *funcs);
>> +void drm_client_unregister(const struct drm_client_funcs *funcs);
>> +
>> +void drm_client_dev_register(struct drm_device *dev);
>> +void drm_client_dev_unregister(struct drm_device *dev);
>> +void drm_client_dev_hotplug(struct drm_device *dev);
>> +void drm_client_dev_lastclose(struct drm_device *dev);
>> +
>> +int drm_client_get_file(struct drm_client_dev *client);
>> +void drm_client_put_file(struct drm_client_dev *client);
>> +struct drm_event *
>> +drm_client_read_event(struct drm_client_dev *client, bool block);
>> +
>> +struct drm_client_connector {
>> +	unsigned int conn_id;
>> +	unsigned int status;
>> +	unsigned int crtc_id;
>> +	struct drm_mode_modeinfo *modes;
>> +	unsigned int num_modes;
>> +	bool has_tile;
>> +	int tile_group;
>> +	u8 tile_h_loc, tile_v_loc;
>> +};
>> +
>> +struct drm_client_display {
>> +	struct drm_client_dev *client;
>> +
>> +	struct drm_client_connector **connectors;
>> +	unsigned int num_connectors;
>> +
>> +	struct mutex modes_lock;
>> +	struct drm_mode_modeinfo *modes;
>> +	unsigned int num_modes;
>> +
>> +	bool cloned;
>> +	bool no_flushing;
>> +};
>> +
>> +void drm_client_display_free(struct drm_client_display *display);
>> +struct drm_client_display *
>> +drm_client_display_get_first_enabled(struct drm_client_dev *client, bool strict);
>> +
>> +int drm_client_display_update_modes(struct drm_client_display *display,
>> +				    bool *mode_changed);
>> +
>> +static inline bool
>> +drm_client_display_is_tiled(struct drm_client_display *display)
>> +{
>> +	return !display->cloned && display->num_connectors > 1;
>> +}
>> +
>> +int drm_client_display_dpms(struct drm_client_display *display, int mode);
>> +int drm_client_display_wait_vblank(struct drm_client_display *display);
>> +
>> +struct drm_mode_modeinfo *
>> +drm_client_display_first_mode(struct drm_client_display *display);
>> +struct drm_mode_modeinfo *
>> +drm_client_display_next_mode(struct drm_client_display *display,
>> +			     struct drm_mode_modeinfo *mode);
>> +
>> +#define drm_client_display_for_each_mode(display, mode) \
>> +	for (mode = drm_client_display_first_mode(display); mode; \
>> +	     mode = drm_client_display_next_mode(display, mode))
>> +
>> +unsigned int
>> +drm_client_display_preferred_depth(struct drm_client_display *display);
>> +
>> +int drm_client_display_commit_mode(struct drm_client_display *display,
>> +				   u32 fb_id, struct drm_mode_modeinfo *mode);
>> +unsigned int drm_client_display_current_fb(struct drm_client_display *display);
>> +int drm_client_display_flush(struct drm_client_display *display, u32 fb_id,
>> +			     struct drm_clip_rect *clips, unsigned int num_clips);
>> +int drm_client_display_page_flip(struct drm_client_display *display, u32 fb_id,
>> +				 bool event);
>> +
>> +struct drm_client_buffer {
>> +	struct drm_client_dev *client;
>> +	u32 width;
>> +	u32 height;
>> +	u32 format;
>> +	u32 handle;
>> +	u32 pitch;
>> +	u64 size;
>> +	struct dma_buf *dma_buf;
>> +	void *vaddr;
>> +
>> +	unsigned int *fb_ids;
>> +	unsigned int num_fbs;
>> +};
>> +
>> +struct drm_client_buffer *
>> +drm_client_framebuffer_create(struct drm_client_dev *client,
>> +			      struct drm_mode_modeinfo *mode, u32 format);
>> +void drm_client_framebuffer_delete(struct drm_client_buffer *buffer);
>> +struct drm_client_buffer *
>> +drm_client_buffer_create(struct drm_client_dev *client, u32 width, u32 height,
>> +			 u32 format);
>> +void drm_client_buffer_delete(struct drm_client_buffer *buffer);
>> +int drm_client_buffer_addfb(struct drm_client_buffer *buffer,
>> +			    struct drm_mode_modeinfo *mode);
>> +int drm_client_buffer_rmfb(struct drm_client_buffer *buffer);
>> diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h
>> index 7c4fa32f3fc6..32dfed3d5a86 100644
>> --- a/include/drm/drm_device.h
>> +++ b/include/drm/drm_device.h
>> @@ -67,6 +67,7 @@ struct drm_device {
>>   
>>   	struct mutex filelist_mutex;
>>   	struct list_head filelist;
>> +	struct list_head filelist_internal;
>>   
>>   	/** \name Memory management */
>>   	/*@{ */
>> diff --git a/include/drm/drm_file.h b/include/drm/drm_file.h
>> index 5176c3797680..39af8a4be7b3 100644
>> --- a/include/drm/drm_file.h
>> +++ b/include/drm/drm_file.h
>> @@ -248,6 +248,13 @@ struct drm_file {
>>   	 */
>>   	void *driver_priv;
>>   
>> +	/**
>> +	 * @user_priv:
>> +	 *
>> +	 * Optional pointer for user private data. Useful for in-kernel clients.
>> +	 */
>> +	void *user_priv;
>> +
>>   	/**
>>   	 * @fbs:
>>   	 *
>> -- 
>> 2.15.1
>>



More information about the Intel-gfx mailing list