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@tronnes.org --- 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 +++++++++++++++++++++++++++++++++++ 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); +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: *