From: David Herrmann dh.herrmann@gmail.com

Rather than doing drm_file allocation/destruction right in the fops, lets provide separate helpers. This decouples drm_file management from the still-mandatory drm-fops. It prepares for use of drm_file without the fops, both by possible separate fops implementations and APIs (not that I am aware of any such plans), and more importantly from in-kernel use where no real file is available.

Signed-off-by: David Herrmann dh.herrmann@gmail.com Signed-off-by: Noralf Trønnes noralf@tronnes.org Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch --- drivers/gpu/drm/drm_file.c | 305 +++++++++++++++++++++++------------------ drivers/gpu/drm/drm_internal.h | 2 + 2 files changed, 175 insertions(+), 132 deletions(-)

diff --git a/drivers/gpu/drm/drm_file.c b/drivers/gpu/drm/drm_file.c index e394799979a6..d4588d33f91c 100644 --- a/drivers/gpu/drm/drm_file.c +++ b/drivers/gpu/drm/drm_file.c @@ -101,6 +101,175 @@ DEFINE_MUTEX(drm_global_mutex);

static int drm_open_helper(struct file *filp, struct drm_minor *minor);

+/** + * drm_file_alloc - allocate file context + * @minor: minor to allocate on + * + * This allocates a new DRM file context. It is not linked into any context and + * can be used by the caller freely. Note that the context keeps a pointer to + * @minor, so it must be freed before @minor is. + * + * RETURNS: + * Pointer to newly allocated context, ERR_PTR on failure. + */ +struct drm_file *drm_file_alloc(struct drm_minor *minor) +{ + struct drm_device *dev = minor->dev; + struct drm_file *file; + int ret; + + file = kzalloc(sizeof(*file), GFP_KERNEL); + if (!file) + return ERR_PTR(-ENOMEM); + + file->pid = get_pid(task_pid(current)); + file->minor = minor; + + /* for compatibility root is always authenticated */ + file->authenticated = capable(CAP_SYS_ADMIN); + file->lock_count = 0; + + INIT_LIST_HEAD(&file->lhead); + INIT_LIST_HEAD(&file->fbs); + mutex_init(&file->fbs_lock); + INIT_LIST_HEAD(&file->blobs); + INIT_LIST_HEAD(&file->pending_event_list); + INIT_LIST_HEAD(&file->event_list); + init_waitqueue_head(&file->event_wait); + file->event_space = 4096; /* set aside 4k for event buffer */ + + mutex_init(&file->event_read_lock); + + if (drm_core_check_feature(dev, DRIVER_GEM)) + drm_gem_open(dev, file); + + if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) + drm_syncobj_open(file); + + if (drm_core_check_feature(dev, DRIVER_PRIME)) + drm_prime_init_file_private(&file->prime); + + if (dev->driver->open) { + ret = dev->driver->open(dev, file); + if (ret < 0) + goto out_prime_destroy; + } + + if (drm_is_primary_client(file)) { + ret = drm_master_open(file); + if (ret) + goto out_close; + } + + return file; + +out_close: + if (dev->driver->postclose) + dev->driver->postclose(dev, file); +out_prime_destroy: + if (drm_core_check_feature(dev, DRIVER_PRIME)) + drm_prime_destroy_file_private(&file->prime); + if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) + drm_syncobj_release(file); + if (drm_core_check_feature(dev, DRIVER_GEM)) + drm_gem_release(dev, file); + put_pid(file->pid); + kfree(file); + + return ERR_PTR(ret); +} + +static void drm_events_release(struct drm_file *file_priv) +{ + struct drm_device *dev = file_priv->minor->dev; + struct drm_pending_event *e, *et; + unsigned long flags; + + spin_lock_irqsave(&dev->event_lock, flags); + + /* Unlink pending events */ + list_for_each_entry_safe(e, et, &file_priv->pending_event_list, + pending_link) { + list_del(&e->pending_link); + e->file_priv = NULL; + } + + /* Remove unconsumed events */ + list_for_each_entry_safe(e, et, &file_priv->event_list, link) { + list_del(&e->link); + kfree(e); + } + + spin_unlock_irqrestore(&dev->event_lock, flags); +} + +/** + * drm_file_free - free file context + * @file: context to free, or NULL + * + * This destroys and deallocates a DRM file context previously allocated via + * drm_file_alloc(). The caller must make sure to unlink it from any contexts + * before calling this. + * + * If NULL is passed, this is a no-op. + * + * RETURNS: + * 0 on success, or error code on failure. + */ +void drm_file_free(struct drm_file *file) +{ + struct drm_device *dev; + + if (!file) + return; + + dev = file->minor->dev; + + DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n", + task_pid_nr(current), + (long)old_encode_dev(file->minor->kdev->devt), + dev->open_count); + + if (drm_core_check_feature(dev, DRIVER_LEGACY) && + dev->driver->preclose) + dev->driver->preclose(dev, file); + + if (drm_core_check_feature(dev, DRIVER_LEGACY)) + drm_legacy_lock_release(dev, file->filp); + + if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)) + drm_legacy_reclaim_buffers(dev, file); + + drm_events_release(file); + + if (drm_core_check_feature(dev, DRIVER_MODESET)) { + drm_fb_release(file); + drm_property_destroy_user_blobs(dev, file); + } + + if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) + drm_syncobj_release(file); + + if (drm_core_check_feature(dev, DRIVER_GEM)) + drm_gem_release(dev, file); + + drm_legacy_ctxbitmap_flush(dev, file); + + if (drm_is_primary_client(file)) + drm_master_release(file); + + if (dev->driver->postclose) + dev->driver->postclose(dev, file); + + if (drm_core_check_feature(dev, DRIVER_PRIME)) + drm_prime_destroy_file_private(&file->prime); + + WARN_ON(!list_empty(&file->event_list)); + + put_pid(file->pid); + kfree(file); +} + static int drm_setup(struct drm_device * dev) { int ret; @@ -196,7 +365,6 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor) { struct drm_device *dev = minor->dev; struct drm_file *priv; - int ret;

if (filp->f_flags & O_EXCL) return -EBUSY; /* No exclusive opens */ @@ -207,50 +375,12 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor)

DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor->index);

- priv = kzalloc(sizeof(*priv), GFP_KERNEL); - if (!priv) - return -ENOMEM; + priv = drm_file_alloc(minor); + if (IS_ERR(priv)) + return PTR_ERR(priv);

filp->private_data = priv; priv->filp = filp; - priv->pid = get_pid(task_pid(current)); - priv->minor = minor; - - /* for compatibility root is always authenticated */ - priv->authenticated = capable(CAP_SYS_ADMIN); - priv->lock_count = 0; - - INIT_LIST_HEAD(&priv->lhead); - INIT_LIST_HEAD(&priv->fbs); - mutex_init(&priv->fbs_lock); - INIT_LIST_HEAD(&priv->blobs); - INIT_LIST_HEAD(&priv->pending_event_list); - INIT_LIST_HEAD(&priv->event_list); - init_waitqueue_head(&priv->event_wait); - priv->event_space = 4096; /* set aside 4k for event buffer */ - - mutex_init(&priv->event_read_lock); - - if (drm_core_check_feature(dev, DRIVER_GEM)) - drm_gem_open(dev, priv); - - if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) - drm_syncobj_open(priv); - - if (drm_core_check_feature(dev, DRIVER_PRIME)) - drm_prime_init_file_private(&priv->prime); - - if (dev->driver->open) { - ret = dev->driver->open(dev, priv); - if (ret < 0) - goto out_prime_destroy; - } - - if (drm_is_primary_client(priv)) { - ret = drm_master_open(priv); - if (ret) - goto out_close; - }

mutex_lock(&dev->filelist_mutex); list_add(&priv->lhead, &dev->filelist); @@ -277,45 +407,6 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor) #endif

return 0; - -out_close: - if (dev->driver->postclose) - dev->driver->postclose(dev, priv); -out_prime_destroy: - if (drm_core_check_feature(dev, DRIVER_PRIME)) - drm_prime_destroy_file_private(&priv->prime); - if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) - drm_syncobj_release(priv); - if (drm_core_check_feature(dev, DRIVER_GEM)) - drm_gem_release(dev, priv); - put_pid(priv->pid); - kfree(priv); - filp->private_data = NULL; - return ret; -} - -static void drm_events_release(struct drm_file *file_priv) -{ - struct drm_device *dev = file_priv->minor->dev; - struct drm_pending_event *e, *et; - unsigned long flags; - - spin_lock_irqsave(&dev->event_lock, flags); - - /* Unlink pending events */ - list_for_each_entry_safe(e, et, &file_priv->pending_event_list, - pending_link) { - list_del(&e->pending_link); - e->file_priv = NULL; - } - - /* Remove unconsumed events */ - list_for_each_entry_safe(e, et, &file_priv->event_list, link) { - list_del(&e->link); - kfree(e); - } - - spin_unlock_irqrestore(&dev->event_lock, flags); }

static void drm_legacy_dev_reinit(struct drm_device *dev) @@ -382,57 +473,7 @@ int drm_release(struct inode *inode, struct file *filp) list_del(&file_priv->lhead); mutex_unlock(&dev->filelist_mutex);

- if (drm_core_check_feature(dev, DRIVER_LEGACY) && - dev->driver->preclose) - dev->driver->preclose(dev, file_priv); - - /* ======================================================== - * Begin inline drm_release - */ - - DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n", - task_pid_nr(current), - (long)old_encode_dev(file_priv->minor->kdev->devt), - dev->open_count); - - if (drm_core_check_feature(dev, DRIVER_LEGACY)) - drm_legacy_lock_release(dev, filp); - - if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)) - drm_legacy_reclaim_buffers(dev, file_priv); - - drm_events_release(file_priv); - - if (drm_core_check_feature(dev, DRIVER_MODESET)) { - drm_fb_release(file_priv); - drm_property_destroy_user_blobs(dev, file_priv); - } - - if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) - drm_syncobj_release(file_priv); - - if (drm_core_check_feature(dev, DRIVER_GEM)) - drm_gem_release(dev, file_priv); - - drm_legacy_ctxbitmap_flush(dev, file_priv); - - if (drm_is_primary_client(file_priv)) - drm_master_release(file_priv); - - if (dev->driver->postclose) - dev->driver->postclose(dev, file_priv); - - if (drm_core_check_feature(dev, DRIVER_PRIME)) - drm_prime_destroy_file_private(&file_priv->prime); - - WARN_ON(!list_empty(&file_priv->event_list)); - - put_pid(file_priv->pid); - kfree(file_priv); - - /* ======================================================== - * End inline drm_release - */ + drm_file_free(file_priv);

if (!--dev->open_count) { drm_lastclose(dev); diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h index b72242e93ea4..40179c5fc6b8 100644 --- a/drivers/gpu/drm/drm_internal.h +++ b/drivers/gpu/drm/drm_internal.h @@ -26,6 +26,8 @@

/* drm_file.c */ extern struct mutex drm_global_mutex; +struct drm_file *drm_file_alloc(struct drm_minor *minor); +void drm_file_free(struct drm_file *file); void drm_lastclose(struct drm_device *dev);

/* drm_pci.c */

This is part 2 of making ioctls useable for in-kernel clients. Make an ioctl wrapper function that calls a function that can be used by in-kernel clients.

It adjusts the signature of the following functions: - drm_mode_getcrtc() - drm_mode_create_dumb_ioctl() - drm_mode_destroy_dumb_ioctl() - drm_mode_getencoder() - drm_mode_addfb2() - drm_mode_rmfb() - drm_mode_obj_set_property_ioctl() - drm_mode_page_flip_ioctl() - drm_prime_handle_to_fd_ioctl() - drm_wait_vblank_ioctl()

drm_mode_addfb2() also gets the ability to override the debug name.

There is no functional change from the userspace side.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_crtc.c | 15 +++++++---- drivers/gpu/drm/drm_crtc_internal.h | 37 +++++++++++++++++++++------ drivers/gpu/drm/drm_dumb_buffers.c | 33 ++++++++++++++++-------- drivers/gpu/drm/drm_encoder.c | 10 ++++++-- drivers/gpu/drm/drm_framebuffer.c | 50 ++++++++++++++++++++++++------------- drivers/gpu/drm/drm_internal.h | 5 ++++ drivers/gpu/drm/drm_ioc32.c | 2 +- drivers/gpu/drm/drm_ioctl.c | 8 +++--- drivers/gpu/drm/drm_mode_object.c | 12 ++++++--- drivers/gpu/drm/drm_plane.c | 12 ++++++--- drivers/gpu/drm/drm_prime.c | 13 +++++++--- drivers/gpu/drm/drm_vblank.c | 11 +++++--- 12 files changed, 147 insertions(+), 61 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index c9ab1cc6b412..61a6a90fae7e 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c @@ -387,8 +387,8 @@ EXPORT_SYMBOL(drm_crtc_cleanup); /** * drm_mode_getcrtc - get CRTC configuration * @dev: drm device for the ioctl - * @data: data pointer for the ioctl - * @file_priv: drm file for the ioctl call + * @crtc_resp: pointer to crtc request structure + * @file_priv: drm file * * Construct a CRTC configuration structure to return to the user. * @@ -397,10 +397,9 @@ EXPORT_SYMBOL(drm_crtc_cleanup); * Returns: * Zero on success, negative errno on failure. */ -int drm_mode_getcrtc(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_getcrtc(struct drm_device *dev, struct drm_mode_crtc *crtc_resp, + struct drm_file *file_priv) { - struct drm_mode_crtc *crtc_resp = data; struct drm_crtc *crtc;

if (!drm_core_check_feature(dev, DRIVER_MODESET)) @@ -451,6 +450,12 @@ int drm_mode_getcrtc(struct drm_device *dev, return 0; }

+int drm_mode_getcrtc_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) +{ + return drm_mode_getcrtc(dev, data, file_priv); +} + static int __drm_mode_set_config_internal(struct drm_mode_set *set, struct drm_modeset_acquire_ctx *ctx) { diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h index 29c59ce7e56e..45713af5a015 100644 --- a/drivers/gpu/drm/drm_crtc_internal.h +++ b/drivers/gpu/drm/drm_crtc_internal.h @@ -45,12 +45,14 @@ void drm_crtc_unregister_all(struct drm_device *dev);

struct dma_fence *drm_crtc_create_fence(struct drm_crtc *crtc);

+int drm_mode_getcrtc(struct drm_device *dev, struct drm_mode_crtc *crtc_resp, + struct drm_file *file_priv); int drm_mode_setcrtc(struct drm_device *dev, struct drm_mode_crtc *crtc_req, struct drm_file *file_priv, bool user);

/* IOCTLs */ -int drm_mode_getcrtc(struct drm_device *dev, - void *data, struct drm_file *file_priv); +int drm_mode_getcrtc_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); int drm_mode_setcrtc_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);

@@ -68,6 +70,12 @@ int drm_mode_getresources_ioctl(struct drm_device *dev, void *data,

/* drm_dumb_buffers.c */ +int drm_mode_create_dumb(struct drm_device *dev, + struct drm_mode_create_dumb *args, + struct drm_file *file_priv); +int drm_mode_destroy_dumb(struct drm_device *dev, u32 handle, + struct drm_file *file_priv); + /* IOCTLs */ int drm_mode_create_dumb_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); @@ -122,6 +130,9 @@ int drm_mode_object_get_properties(struct drm_mode_object *obj, bool atomic, uint32_t *arg_count_props); struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj, uint32_t prop_id); +int drm_mode_obj_set_property(struct drm_device *dev, + struct drm_mode_obj_set_property *arg, + struct drm_file *file_priv);

/* IOCTL */

@@ -133,10 +144,13 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, /* drm_encoder.c */ int drm_encoder_register_all(struct drm_device *dev); void drm_encoder_unregister_all(struct drm_device *dev); +int drm_mode_getencoder(struct drm_device *dev, + struct drm_mode_get_encoder *enc_resp, + struct drm_file *file_priv);

/* IOCTL */ -int drm_mode_getencoder(struct drm_device *dev, - void *data, struct drm_file *file_priv); +int drm_mode_getencoder_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv);

/* drm_connector.c */ void drm_connector_ida_init(void); @@ -170,16 +184,20 @@ int drm_framebuffer_check_src_coords(uint32_t src_x, uint32_t src_y, const struct drm_framebuffer *fb); void drm_fb_release(struct drm_file *file_priv);

+int drm_mode_addfb2(struct drm_device *dev, struct drm_mode_fb_cmd2 *r, + struct drm_file *file_priv, const char *comm); +int drm_mode_rmfb(struct drm_device *dev, u32 fb_id, + struct drm_file *file_priv); int drm_mode_dirtyfb(struct drm_device *dev, struct drm_mode_fb_dirty_cmd *req, struct drm_file *file_priv, bool user);

/* IOCTL */ int drm_mode_addfb(struct drm_device *dev, void *data, struct drm_file *file_priv); -int drm_mode_addfb2(struct drm_device *dev, - void *data, struct drm_file *file_priv); -int drm_mode_rmfb(struct drm_device *dev, - void *data, struct drm_file *file_priv); +int drm_mode_addfb2_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); +int drm_mode_rmfb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); int drm_mode_getfb(struct drm_device *dev, void *data, struct drm_file *file_priv); int drm_mode_dirtyfb_ioctl(struct drm_device *dev, @@ -209,6 +227,9 @@ int drm_plane_register_all(struct drm_device *dev); void drm_plane_unregister_all(struct drm_device *dev); int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format); +int drm_mode_page_flip(struct drm_device *dev, + struct drm_mode_crtc_page_flip_target *page_flip, + struct drm_file *file_priv);

/* drm_bridge.c */ void drm_bridge_detach(struct drm_bridge *bridge); diff --git a/drivers/gpu/drm/drm_dumb_buffers.c b/drivers/gpu/drm/drm_dumb_buffers.c index 39ac15ce4702..eed9687b8698 100644 --- a/drivers/gpu/drm/drm_dumb_buffers.c +++ b/drivers/gpu/drm/drm_dumb_buffers.c @@ -53,10 +53,10 @@ * a hardware-specific ioctl to allocate suitable buffer objects. */

-int drm_mode_create_dumb_ioctl(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_create_dumb(struct drm_device *dev, + struct drm_mode_create_dumb *args, + struct drm_file *file_priv) { - struct drm_mode_create_dumb *args = data; u32 cpp, stride, size;

if (!dev->driver->dumb_create) @@ -91,6 +91,12 @@ int drm_mode_create_dumb_ioctl(struct drm_device *dev, return dev->driver->dumb_create(file_priv, dev, args); }

+int drm_mode_create_dumb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) +{ + return drm_mode_create_dumb(dev, data, file_priv); +} + /** * drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer * @dev: DRM device @@ -122,17 +128,22 @@ int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, &args->offset); }

+int drm_mode_destroy_dumb(struct drm_device *dev, u32 handle, + struct drm_file *file_priv) +{ + if (!dev->driver->dumb_create) + return -ENOSYS; + + if (dev->driver->dumb_destroy) + return dev->driver->dumb_destroy(file_priv, dev, handle); + else + return drm_gem_dumb_destroy(file_priv, dev, handle); +} + int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) { struct drm_mode_destroy_dumb *args = data;

- if (!dev->driver->dumb_create) - return -ENOSYS; - - if (dev->driver->dumb_destroy) - return dev->driver->dumb_destroy(file_priv, dev, args->handle); - else - return drm_gem_dumb_destroy(file_priv, dev, args->handle); + return drm_mode_destroy_dumb(dev, args->handle, file_priv); } - diff --git a/drivers/gpu/drm/drm_encoder.c b/drivers/gpu/drm/drm_encoder.c index 273e1c59c54a..466f3e28b3e9 100644 --- a/drivers/gpu/drm/drm_encoder.c +++ b/drivers/gpu/drm/drm_encoder.c @@ -214,10 +214,10 @@ static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder) return encoder->crtc; }

-int drm_mode_getencoder(struct drm_device *dev, void *data, +int drm_mode_getencoder(struct drm_device *dev, + struct drm_mode_get_encoder *enc_resp, struct drm_file *file_priv) { - struct drm_mode_get_encoder *enc_resp = data; struct drm_encoder *encoder; struct drm_crtc *crtc;

@@ -244,3 +244,9 @@ int drm_mode_getencoder(struct drm_device *dev, void *data,

return 0; } + +int drm_mode_getencoder_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) +{ + return drm_mode_getencoder(dev, data, file_priv); +} diff --git a/drivers/gpu/drm/drm_framebuffer.c b/drivers/gpu/drm/drm_framebuffer.c index e918c7124dcd..b41770d29e6c 100644 --- a/drivers/gpu/drm/drm_framebuffer.c +++ b/drivers/gpu/drm/drm_framebuffer.c @@ -121,7 +121,7 @@ int drm_mode_addfb(struct drm_device *dev, r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth); r.handles[0] = or->handle;

- ret = drm_mode_addfb2(dev, &r, file_priv); + ret = drm_mode_addfb2_ioctl(dev, &r, file_priv); if (ret) return ret;

@@ -305,23 +305,23 @@ drm_internal_framebuffer_create(struct drm_device *dev,

/** * drm_mode_addfb2 - add an FB to the graphics configuration - * @dev: drm device for the ioctl - * @data: data pointer for the ioctl - * @file_priv: drm file for the ioctl call + * @dev: drm device + * @r: pointer to request structure + * @file_priv: drm file + * @comm: optionally override the allocator name used for debug output * * Add a new FB to the specified CRTC, given a user request with format. This is * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers * and uses fourcc codes as pixel format specifiers. * - * Called by the user via ioctl. + * Called by the user via ioctl, or by an in-kernel client. * * Returns: * Zero on success, negative errno on failure. */ -int drm_mode_addfb2(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_addfb2(struct drm_device *dev, struct drm_mode_fb_cmd2 *r, + struct drm_file *file_priv, const char *comm) { - struct drm_mode_fb_cmd2 *r = data; struct drm_framebuffer *fb;

if (!drm_core_check_feature(dev, DRIVER_MODESET)) @@ -331,6 +331,9 @@ int drm_mode_addfb2(struct drm_device *dev, if (IS_ERR(fb)) return PTR_ERR(fb);

+ if (comm) + strscpy(fb->comm, comm, TASK_COMM_LEN); + DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); r->fb_id = fb->base.id;

@@ -342,6 +345,12 @@ int drm_mode_addfb2(struct drm_device *dev, return 0; }

+int drm_mode_addfb2_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) +{ + return drm_mode_addfb2(dev, data, file_priv, NULL); +} + struct drm_mode_rmfb_work { struct work_struct work; struct list_head fbs; @@ -362,29 +371,28 @@ static void drm_mode_rmfb_work_fn(struct work_struct *w)

/** * drm_mode_rmfb - remove an FB from the configuration - * @dev: drm device for the ioctl - * @data: data pointer for the ioctl - * @file_priv: drm file for the ioctl call + * @dev: drm device + * @fb_id: id of framebuffer to remove + * @file_priv: drm file * - * Remove the FB specified by the user. + * Remove the specified FB. * - * Called by the user via ioctl. + * Called by the user via ioctl, or by an in-kernel client. * * Returns: * Zero on success, negative errno on failure. */ -int drm_mode_rmfb(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_rmfb(struct drm_device *dev, u32 fb_id, + struct drm_file *file_priv) { struct drm_framebuffer *fb = NULL; struct drm_framebuffer *fbl = NULL; - uint32_t *id = data; int found = 0;

if (!drm_core_check_feature(dev, DRIVER_MODESET)) return -EINVAL;

- fb = drm_framebuffer_lookup(dev, file_priv, *id); + fb = drm_framebuffer_lookup(dev, file_priv, fb_id); if (!fb) return -ENOENT;

@@ -430,6 +438,14 @@ int drm_mode_rmfb(struct drm_device *dev, return -ENOENT; }

+int drm_mode_rmfb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) +{ + uint32_t *fb_id = data; + + return drm_mode_rmfb(dev, *fb_id, file_priv); +} + /** * drm_mode_getfb - get FB info * @dev: drm device for the ioctl diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h index 40179c5fc6b8..043814cbd286 100644 --- a/drivers/gpu/drm/drm_internal.h +++ b/drivers/gpu/drm/drm_internal.h @@ -37,6 +37,9 @@ void drm_pci_agp_destroy(struct drm_device *dev); int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master);

/* drm_prime.c */ +int drm_prime_handle_to_fd(struct drm_device *dev, + struct drm_prime_handle *args, + struct drm_file *file_priv); int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data, @@ -59,6 +62,8 @@ int drm_gem_name_info(struct seq_file *m, void *data); /* drm_vblank.c */ void drm_vblank_disable_and_save(struct drm_device *dev, unsigned int pipe); void drm_vblank_cleanup(struct drm_device *dev); +int drm_wait_vblank(struct drm_device *dev, union drm_wait_vblank *vblwait, + struct drm_file *file_priv);

/* IOCTLS */ int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, diff --git a/drivers/gpu/drm/drm_ioc32.c b/drivers/gpu/drm/drm_ioc32.c index f8e96e648acf..576d00b7dad5 100644 --- a/drivers/gpu/drm/drm_ioc32.c +++ b/drivers/gpu/drm/drm_ioc32.c @@ -884,7 +884,7 @@ static int compat_drm_mode_addfb2(struct file *file, unsigned int cmd, sizeof(req64.modifier))) return -EFAULT;

- err = drm_ioctl_kernel(file, drm_mode_addfb2, &req64, + err = drm_ioctl_kernel(file, drm_mode_addfb2_ioctl, &req64, DRM_CONTROL_ALLOW|DRM_UNLOCKED); if (err) return err; diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c index 346b8060df7c..726fbdb8a4b0 100644 --- a/drivers/gpu/drm/drm_ioctl.c +++ b/drivers/gpu/drm/drm_ioctl.c @@ -619,14 +619,14 @@ static const struct drm_ioctl_desc drm_ioctls[] = { DRM_IOCTL_DEF(DRM_IOCTL_PRIME_FD_TO_HANDLE, drm_prime_fd_to_handle_ioctl, DRM_AUTH|DRM_UNLOCKED|DRM_RENDER_ALLOW),

DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res, DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC, drm_mode_setcrtc_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR, drm_mode_cursor_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETGAMMA, drm_mode_gamma_set_ioctl, DRM_MASTER|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETENCODER, drm_mode_getencoder, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETENCODER, drm_mode_getencoder_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCONNECTOR, drm_mode_getconnector_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATTACHMODE, drm_noop, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_DETACHMODE, drm_noop, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), @@ -635,8 +635,8 @@ static const struct drm_ioctl_desc drm_ioctls[] = { DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPBLOB, drm_mode_getblob_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB2, drm_mode_addfb2, DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB2, drm_mode_addfb2_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_PAGE_FLIP, drm_mode_page_flip_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_DIRTYFB, drm_mode_dirtyfb_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_CREATE_DUMB, drm_mode_create_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), diff --git a/drivers/gpu/drm/drm_mode_object.c b/drivers/gpu/drm/drm_mode_object.c index ce4d2fb32810..2bf7a9e8ac08 100644 --- a/drivers/gpu/drm/drm_mode_object.c +++ b/drivers/gpu/drm/drm_mode_object.c @@ -496,10 +496,10 @@ static int set_property_atomic(struct drm_mode_object *obj, return ret; }

-int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv) +int drm_mode_obj_set_property(struct drm_device *dev, + struct drm_mode_obj_set_property *arg, + struct drm_file *file_priv) { - struct drm_mode_obj_set_property *arg = data; struct drm_mode_object *arg_obj; struct drm_property *property; int ret = -EINVAL; @@ -527,3 +527,9 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, drm_mode_object_put(arg_obj); return ret; } + +int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) +{ + return drm_mode_obj_set_property(dev, data, file_priv); +} diff --git a/drivers/gpu/drm/drm_plane.c b/drivers/gpu/drm/drm_plane.c index 22b54663b6e7..b1f55556e196 100644 --- a/drivers/gpu/drm/drm_plane.c +++ b/drivers/gpu/drm/drm_plane.c @@ -907,10 +907,10 @@ int drm_mode_cursor2_ioctl(struct drm_device *dev, return drm_mode_cursor_common(dev, req, file_priv); }

-int drm_mode_page_flip_ioctl(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_page_flip(struct drm_device *dev, + struct drm_mode_crtc_page_flip_target *page_flip, + struct drm_file *file_priv) { - struct drm_mode_crtc_page_flip_target *page_flip = data; struct drm_crtc *crtc; struct drm_framebuffer *fb = NULL; struct drm_pending_vblank_event *e = NULL; @@ -1082,3 +1082,9 @@ int drm_mode_page_flip_ioctl(struct drm_device *dev,

return ret; } + +int drm_mode_page_flip_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) +{ + return drm_mode_page_flip(dev, data, file_priv); +} diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c index e82a976f0fba..eaf8392ef815 100644 --- a/drivers/gpu/drm/drm_prime.c +++ b/drivers/gpu/drm/drm_prime.c @@ -853,11 +853,10 @@ int drm_gem_prime_fd_to_handle(struct drm_device *dev, } EXPORT_SYMBOL(drm_gem_prime_fd_to_handle);

-int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv) +int drm_prime_handle_to_fd(struct drm_device *dev, + struct drm_prime_handle *args, + struct drm_file *file_priv) { - struct drm_prime_handle *args = data; - if (!drm_core_check_feature(dev, DRIVER_PRIME)) return -EINVAL;

@@ -872,6 +871,12 @@ int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data, args->handle, args->flags, &args->fd); }

+int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) +{ + return drm_prime_handle_to_fd(dev, data, file_priv); +} + int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) { diff --git a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c index 32d9bcf5be7f..ef41508bc539 100644 --- a/drivers/gpu/drm/drm_vblank.c +++ b/drivers/gpu/drm/drm_vblank.c @@ -1445,12 +1445,11 @@ static void drm_wait_vblank_reply(struct drm_device *dev, unsigned int pipe, reply->tval_usec = ts.tv_nsec / 1000; }

-int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv) +int drm_wait_vblank(struct drm_device *dev, union drm_wait_vblank *vblwait, + struct drm_file *file_priv) { struct drm_crtc *crtc; struct drm_vblank_crtc *vblank; - union drm_wait_vblank *vblwait = data; int ret; u64 req_seq, seq; unsigned int pipe_index; @@ -1567,6 +1566,12 @@ int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, return ret; }

+int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) +{ + return drm_wait_vblank_ioctl(dev, data, file_priv); +} + static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe) { struct drm_pending_vblank_event *e, *t;

Add _ioctl suffix to the remaining ioctl functions so they match up with the others: - drm_mode_addfb() - drm_mode_getfb() - drm_mode_getplane_res() - drm_mode_getplane() - drm_mode_setplane()

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_crtc_internal.h | 20 ++++++++++---------- drivers/gpu/drm/drm_framebuffer.c | 12 ++++++------ drivers/gpu/drm/drm_ioctl.c | 10 +++++----- drivers/gpu/drm/drm_plane.c | 12 ++++++------ 4 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h index 45713af5a015..3a9dd1dae06e 100644 --- a/drivers/gpu/drm/drm_crtc_internal.h +++ b/drivers/gpu/drm/drm_crtc_internal.h @@ -192,14 +192,14 @@ int drm_mode_dirtyfb(struct drm_device *dev, struct drm_mode_fb_dirty_cmd *req, struct drm_file *file_priv, bool user);

/* IOCTL */ -int drm_mode_addfb(struct drm_device *dev, - void *data, struct drm_file *file_priv); +int drm_mode_addfb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); int drm_mode_addfb2_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); int drm_mode_rmfb_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -int drm_mode_getfb(struct drm_device *dev, - void *data, struct drm_file *file_priv); +int drm_mode_getfb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); int drm_mode_dirtyfb_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);

@@ -235,12 +235,12 @@ int drm_mode_page_flip(struct drm_device *dev, void drm_bridge_detach(struct drm_bridge *bridge);

/* IOCTL */ -int drm_mode_getplane_res(struct drm_device *dev, void *data, - struct drm_file *file_priv); -int drm_mode_getplane(struct drm_device *dev, - void *data, struct drm_file *file_priv); -int drm_mode_setplane(struct drm_device *dev, - void *data, struct drm_file *file_priv); +int drm_mode_getplane_res_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv); +int drm_mode_getplane_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); +int drm_mode_setplane_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); int drm_mode_cursor_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); int drm_mode_cursor2_ioctl(struct drm_device *dev, diff --git a/drivers/gpu/drm/drm_framebuffer.c b/drivers/gpu/drm/drm_framebuffer.c index b41770d29e6c..ad8f7d308656 100644 --- a/drivers/gpu/drm/drm_framebuffer.c +++ b/drivers/gpu/drm/drm_framebuffer.c @@ -93,7 +93,7 @@ int drm_framebuffer_check_src_coords(uint32_t src_x, uint32_t src_y, }

/** - * drm_mode_addfb - add an FB to the graphics configuration + * drm_mode_addfb_ioctl - add an FB to the graphics configuration * @dev: drm device for the ioctl * @data: data pointer for the ioctl * @file_priv: drm file for the ioctl call @@ -106,8 +106,8 @@ int drm_framebuffer_check_src_coords(uint32_t src_x, uint32_t src_y, * Returns: * Zero on success, negative errno on failure. */ -int drm_mode_addfb(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_addfb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) { struct drm_mode_fb_cmd *or = data; struct drm_mode_fb_cmd2 r = {}; @@ -447,7 +447,7 @@ int drm_mode_rmfb_ioctl(struct drm_device *dev, }

/** - * drm_mode_getfb - get FB info + * drm_mode_getfb_ioctl - get FB info * @dev: drm device for the ioctl * @data: data pointer for the ioctl * @file_priv: drm file for the ioctl call @@ -459,8 +459,8 @@ int drm_mode_rmfb_ioctl(struct drm_device *dev, * Returns: * Zero on success, negative errno on failure. */ -int drm_mode_getfb(struct drm_device *dev, - void *data, struct drm_file *file_priv) +int drm_mode_getfb_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv) { struct drm_mode_fb_cmd *r = data; struct drm_framebuffer *fb; diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c index 726fbdb8a4b0..f00bea8b0da3 100644 --- a/drivers/gpu/drm/drm_ioctl.c +++ b/drivers/gpu/drm/drm_ioctl.c @@ -618,11 +618,11 @@ static const struct drm_ioctl_desc drm_ioctls[] = { DRM_IOCTL_DEF(DRM_IOCTL_PRIME_HANDLE_TO_FD, drm_prime_handle_to_fd_ioctl, DRM_AUTH|DRM_UNLOCKED|DRM_RENDER_ALLOW), DRM_IOCTL_DEF(DRM_IOCTL_PRIME_FD_TO_HANDLE, drm_prime_fd_to_handle_ioctl, DRM_AUTH|DRM_UNLOCKED|DRM_RENDER_ALLOW),

- DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC, drm_mode_setcrtc_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane, DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR, drm_mode_cursor_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETGAMMA, drm_mode_gamma_set_ioctl, DRM_MASTER|DRM_UNLOCKED), @@ -633,8 +633,8 @@ static const struct drm_ioctl_desc drm_ioctls[] = { DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPERTY, drm_mode_getproperty_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPROPERTY, drm_mode_connector_property_set_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPBLOB, drm_mode_getblob_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED), - DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB2, drm_mode_addfb2_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED), DRM_IOCTL_DEF(DRM_IOCTL_MODE_PAGE_FLIP, drm_mode_page_flip_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), diff --git a/drivers/gpu/drm/drm_plane.c b/drivers/gpu/drm/drm_plane.c index b1f55556e196..be52e627fd41 100644 --- a/drivers/gpu/drm/drm_plane.c +++ b/drivers/gpu/drm/drm_plane.c @@ -455,8 +455,8 @@ int drm_mode_plane_set_obj_prop(struct drm_plane *plane, } EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);

-int drm_mode_getplane_res(struct drm_device *dev, void *data, - struct drm_file *file_priv) +int drm_mode_getplane_res_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) { struct drm_mode_get_plane_res *plane_resp = data; struct drm_mode_config *config; @@ -495,8 +495,8 @@ int drm_mode_getplane_res(struct drm_device *dev, void *data, return 0; }

-int drm_mode_getplane(struct drm_device *dev, void *data, - struct drm_file *file_priv) +int drm_mode_getplane_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) { struct drm_mode_get_plane *plane_resp = data; struct drm_plane *plane; @@ -679,8 +679,8 @@ static int setplane_internal(struct drm_plane *plane, return ret; }

-int drm_mode_setplane(struct drm_device *dev, void *data, - struct drm_file *file_priv) +int drm_mode_setplane_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) { struct drm_mode_set_plane *plane_req = data; struct drm_plane *plane;

Add a way to check if userspace modes are equal. Useful for in-kernel clients. Also export drm_mode_convert_umode().

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_modes.c | 50 +++++++++++++++++++++++++++++++++++++++++++++ include/drm/drm_modes.h | 2 ++ 2 files changed, 52 insertions(+)

diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c index 5a8033fda4e3..0e39164f15aa 100644 --- a/drivers/gpu/drm/drm_modes.c +++ b/drivers/gpu/drm/drm_modes.c @@ -1631,6 +1631,56 @@ int drm_mode_convert_umode(struct drm_device *dev, out: return ret; } +EXPORT_SYMBOL(drm_mode_convert_umode); + +/** + * drm_umode_equal - test modeinfo modes for equality + * @mode1: first mode + * @mode2: second mode + * + * Check to see if @mode1 and @mode2 are equivalent. + * + * Returns: + * True if the modes are equal, false otherwise. + */ +bool drm_umode_equal(const struct drm_mode_modeinfo *mode1, + const struct drm_mode_modeinfo *mode2) +{ + if (!mode1 && !mode2) + return true; + + if (!mode1 || !mode2) + return false; + + /* do clock check convert to PICOS so fb modes get matched the same */ + if (mode1->clock && mode2->clock) { + if (KHZ2PICOS(mode1->clock) != KHZ2PICOS(mode2->clock)) + return false; + } else if (mode1->clock != mode2->clock) { + return false; + } + + if ((mode1->flags & DRM_MODE_FLAG_3D_MASK) != + (mode2->flags & DRM_MODE_FLAG_3D_MASK)) + return false; + + if (mode1->hdisplay == mode2->hdisplay && + mode1->hsync_start == mode2->hsync_start && + mode1->hsync_end == mode2->hsync_end && + mode1->htotal == mode2->htotal && + mode1->hskew == mode2->hskew && + mode1->vdisplay == mode2->vdisplay && + mode1->vsync_start == mode2->vsync_start && + mode1->vsync_end == mode2->vsync_end && + mode1->vtotal == mode2->vtotal && + mode1->vscan == mode2->vscan && + (mode1->flags & ~DRM_MODE_FLAG_3D_MASK) == + (mode2->flags & ~DRM_MODE_FLAG_3D_MASK)) + return true; + + return false; +} +EXPORT_SYMBOL(drm_umode_equal);

/** * drm_mode_is_420_only - if a given videomode can be only supported in YCBCR420 diff --git a/include/drm/drm_modes.h b/include/drm/drm_modes.h index 0d310beae6af..05e73ca4f2ae 100644 --- a/include/drm/drm_modes.h +++ b/include/drm/drm_modes.h @@ -447,6 +447,8 @@ void drm_mode_convert_to_umode(struct drm_mode_modeinfo *out, int drm_mode_convert_umode(struct drm_device *dev, struct drm_display_mode *out, const struct drm_mode_modeinfo *in); +bool drm_umode_equal(const struct drm_mode_modeinfo *mode1, + const struct drm_mode_modeinfo *mode2); void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode); void drm_mode_debug_printmodeline(const struct drm_display_mode *mode); bool drm_mode_is_420_only(const struct drm_display_info *display,

Add a function so the generic fbdev client can check if the framebuffer does flushing. This is needed to set up deferred I/O.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_framebuffer.c | 31 +++++++++++++++++++++++++++++++ include/drm/drm_framebuffer.h | 2 ++ 2 files changed, 33 insertions(+)

diff --git a/drivers/gpu/drm/drm_framebuffer.c b/drivers/gpu/drm/drm_framebuffer.c index ad8f7d308656..a659cff45844 100644 --- a/drivers/gpu/drm/drm_framebuffer.c +++ b/drivers/gpu/drm/drm_framebuffer.c @@ -600,6 +600,37 @@ int drm_mode_dirtyfb_ioctl(struct drm_device *dev, return drm_mode_dirtyfb(dev, data, file_priv, true); }

+/** + * drm_mode_can_dirtyfb - check if the FB does flushing + * @dev: drm device + * @fb_id: Framebuffer id + * @file_priv: drm file + * + * Returns: + * True if the framebuffer does flushing, false otherwise. + */ +bool drm_mode_can_dirtyfb(struct drm_device *dev, u32 fb_id, + struct drm_file *file_priv) +{ + struct drm_framebuffer *fb; + bool ret = false; + + if (!drm_core_check_feature(dev, DRIVER_MODESET)) + return false; + + fb = drm_framebuffer_lookup(dev, file_priv, fb_id); + if (!fb) + return false; + + if (fb->funcs->dirty) + ret = true; + + drm_framebuffer_put(fb); + + return ret; +} +EXPORT_SYMBOL(drm_mode_can_dirtyfb); + /** * drm_fb_release - remove and free the FBs on this file * @priv: drm file for the ioctl diff --git a/include/drm/drm_framebuffer.h b/include/drm/drm_framebuffer.h index c50502c656e5..05d170f4e215 100644 --- a/include/drm/drm_framebuffer.h +++ b/include/drm/drm_framebuffer.h @@ -216,6 +216,8 @@ struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev, void drm_framebuffer_remove(struct drm_framebuffer *fb); void drm_framebuffer_cleanup(struct drm_framebuffer *fb); void drm_framebuffer_unregister_private(struct drm_framebuffer *fb); +bool drm_mode_can_dirtyfb(struct drm_device *dev, u32 fb_id, + struct drm_file *file_priv);

/** * drm_framebuffer_get - acquire a framebuffer reference

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: *