drm: Add generic fbdev emulation
Subsystems (3)
cover drm: Add generic fbdev emulation
This patchset explores the possibility of having generic fbdev emulation in DRM for drivers that supports dumb buffers which they can export.
I was about to polish up my 'vmalloc BO helper' series, which has fbdev support, when this idea[1] of Laurent popped into my mind:
Ideally I'd like to remove 100% of fbdev-related code from drivers. This includes
- initialization and cleanup of fbdev helpers
- fbdev restore in last_close()
- forwarding of hotplug events to fbdev compatibility layer
In practice we'll likely need to keep one initialization function (or a drm_driver flag) to let drivers opt-in to fbdev compatibility, but the rest should go away. Or maybe we could even enable fbdev compatibility in all drivers unconditionally.
So I set out to see what it would take to accomplish that.
Noralf.
[1] https://lists.freedesktop.org/archives/dri-devel/2017-September/152612.html
David Herrmann (1):
drm: provide management functions for drm_file
Noralf Trønnes (6):
drm/fb-helper: Ensure driver module is pinned in fb_open() drm/fb-helper: Don't restore if fbdev is not in use drm/prime: Clear drm_gem_object->dma_buf on release
drm: Handle fbdev emulation in core drm/fb-helper: Add generic fbdev emulation drm/vc4: Test generic fbdev emulation
drivers/gpu/drm/drm_fb_helper.c | 344 +++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_file.c | 321 ++++++++++++++++++++-------------- drivers/gpu/drm/drm_internal.h | 2 + drivers/gpu/drm/drm_mode_config.c | 10 ++ drivers/gpu/drm/drm_prime.c | 1 + drivers/gpu/drm/drm_probe_helper.c | 4 + drivers/gpu/drm/vc4/vc4_drv.c | 3 - drivers/gpu/drm/vc4/vc4_kms.c | 3 +- include/drm/drm_fb_helper.h | 95 ++++++++++ 9 files changed, 645 insertions(+), 138 deletions(-)
Signature · 6 lines
2.14.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
RFC 1/7 drm: provide management functions for drm_file
From: David Herrmann <[email protected]>
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.
--- drivers/gpu/drm/drm_file.c | 309 +++++++++++++++++++++++------------------ drivers/gpu/drm/drm_internal.h | 2 + 2 files changed, 179 insertions(+), 132 deletions(-)
drivers/gpu/drm/drm_file.c +177 -132
@@ -101,6 +101,179 @@ 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. +* +* The legacy paths might require the drm_global_mutex to be held. +* +* 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. +* +* The legacy paths might require the drm_global_mutex to be held. +* +* 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 +369,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 +379,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 +411,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 +477,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);
drivers/gpu/drm/drm_internal.h +2 -0
@@ -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 */
Signature · 6 lines
2.14.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
RFC 2/7 drm/fb-helper: Ensure driver module is pinned in fb_open()
In reply to Noralf TrønnesIf struct fb_ops is defined in a library like cma, fb_open() and fbcon takes a ref on the library instead of the driver module. Use fb_ops.fb_open/fb_release to ensure that the driver module is pinned.
Add drm_fb_helper_fb_open() and drm_fb_helper_fb_release() to DRM_FB_HELPER_DEFAULT_OPS().
--- drivers/gpu/drm/drm_fb_helper.c | 40 ++++++++++++++++++++++++++++++++++++++++ include/drm/drm_fb_helper.h | 15 +++++++++++++++ 2 files changed, 55 insertions(+)
drivers/gpu/drm/drm_fb_helper.c +40 -0
@@ -1207,6 +1207,46 @@ void drm_fb_helper_cfb_imageblit(struct fb_info *info, }EXPORT_SYMBOL (drm_fb_helper_cfb_imageblit); +/** +* drm_fb_helper_fb_open - implementation for &fb_ops.fb_open +* @info: fbdev registered by the helper +* @user: 1=userspace, 0=fbcon +* +* If &fb_ops is wrapped in a library, pin the driver module. +*/ +int drm_fb_helper_fb_open (struct fb_info *info,int user) +{ +struct drm_fb_helper *fb_helper = info->par; +struct drm_device *dev = fb_helper->dev; + +if (info->fbops->owner != dev->driver->fops->owner) { +if (!try_module_get (dev->driver->fops->owner)) +return -ENODEV ; + } + +return 0 ; +} +EXPORT_SYMBOL (drm_fb_helper_fb_open); + +/** +* drm_fb_helper_fb_release - implementation for &fb_ops.fb_release +* @info: fbdev registered by the helper +* @user: 1=userspace, 0=fbcon +* +* If &fb_ops is wrapped in a library, unpin the driver module. +*/ +int drm_fb_helper_fb_release (struct fb_info *info,int user) +{ +struct drm_fb_helper *fb_helper = info->par; +struct drm_device *dev = fb_helper->dev; + +if (info->fbops->owner != dev->driver->fops->owner) +module_put (dev->driver->fops->owner); + +return 0 ; +} +EXPORT_SYMBOL (drm_fb_helper_fb_release); +/** * drm_fb_helper_set_suspend - wrapper around fb_set_suspend * @fb_helper: driver-allocated fbdev helper, can be NULL
include/drm/drm_fb_helper.h +15 -0
@@ -241,6 +241,8 @@ struct drm_fb_helper {* functions. To be used in struct fb_ops of drm drivers. */ #define DRM_FB_HELPER_DEFAULT_OPS \ + .fb_open = drm_fb_helper_fb_open, \ + .fb_release = drm_fb_helper_fb_release, \ .fb_check_var = drm_fb_helper_check_var, \ .fb_set_par = drm_fb_helper_set_par, \ .fb_setcmap = drm_fb_helper_setcmap, \
@@ -297,6 +299,9 @@ void drm_fb_helper_cfb_copyarea(struct fb_info *info,void drm_fb_helper_cfb_imageblit (struct fb_info *info,const struct fb_image *image); +int drm_fb_helper_fb_open (struct fb_info *info,int user); +int drm_fb_helper_fb_release (struct fb_info *info,int user); +void drm_fb_helper_set_suspend (struct drm_fb_helper *fb_helper,bool suspend);void drm_fb_helper_set_suspend_unlocked (struct drm_fb_helper *fb_helper,bool suspend);
@@ -473,6 +478,16 @@ static inline void drm_fb_helper_cfb_imageblit(struct fb_info *info, { } +static inline int drm_fb_helper_fb_open (struct fb_info *info,int user) +{ +return -ENODEV ; +} + +static inline int drm_fb_helper_fb_release (struct fb_info *info,int user) +{ +return -ENODEV ; +} +static inline void drm_fb_helper_set_suspend (struct drm_fb_helper *fb_helper,bool suspend) {
Signature · 6 lines
2.14.2 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
RFC 3/7 drm/fb-helper: Don't restore if fbdev is not in use
In reply to Noralf TrønnesKeep track of fbdev users and only restore fbdev in drm_fb_helper_restore_fbdev_mode_unlocked() when in use. This avoids fbdev being restored in drm_driver.last_close when nothing uses it. Additionally fbdev is turned off when the last user is closing. fbcon is a user in this context.
--- drivers/gpu/drm/drm_fb_helper.c | 15 +++++++++++++++ include/drm/drm_fb_helper.h | 14 ++++++++++++++ 2 files changed, 29 insertions(+)
drivers/gpu/drm/drm_fb_helper.c +15 -0
@@ -522,6 +522,9 @@ int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)if (READ_ONCE (fb_helper->deferred_setup))return 0 ; +if (!atomic_read (&fb_helper->open_count)) +return 0 ; +mutex_lock (&fb_helper->lock); ret =restore_fbdev_mode (fb_helper);
@@ -781,6 +784,7 @@ void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,INIT_WORK (&helper->resume_work, drm_fb_helper_resume_worker);INIT_WORK (&helper->dirty_work, drm_fb_helper_dirty_work); helper->dirty_clip.x1 = helper->dirty_clip.y1 = ~0 ; +atomic_set (&helper->open_count,1 );mutex_init (&helper->lock); helper->funcs = funcs; helper->dev = dev;
@@ -1212,6 +1216,7 @@ EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit);* @info: fbdev registered by the helper * @user: 1=userspace, 0=fbcon * +* Increase fbdev use count. * If &fb_ops is wrapped in a library, pin the driver module. */ int drm_fb_helper_fb_open (struct fb_info *info,int user)
@@ -1224,6 +1229,8 @@ int drm_fb_helper_fb_open(struct fb_info *info, int user)return -ENODEV ; } +atomic_inc (&fb_helper->open_count); +return 0 ; }EXPORT_SYMBOL (drm_fb_helper_fb_open);
@@ -1233,6 +1240,7 @@ EXPORT_SYMBOL(drm_fb_helper_fb_open);* @info: fbdev registered by the helper * @user: 1=userspace, 0=fbcon * +* Decrease fbdev use count and turn off if there are no users left. * If &fb_ops is wrapped in a library, unpin the driver module. */ int drm_fb_helper_fb_release (struct fb_info *info,int user)
@@ -1240,6 +1248,10 @@ int drm_fb_helper_fb_release(struct fb_info *info, int user)struct drm_fb_helper *fb_helper = info->par;struct drm_device *dev = fb_helper->dev; +if (atomic_dec_and_test (&fb_helper->open_count) && + !drm_dev_is_unplugged (fb_helper->dev)) +drm_fb_helper_blank (FB_BLANK_POWERDOWN , info); +if (info->fbops->owner != dev->driver->fops->owner)module_put (dev->driver->fops->owner);
@@ -1936,6 +1948,9 @@ static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,if (ret <0 )return ret; +if (fb_helper->fbdev->fbops->fb_open == drm_fb_helper_fb_open) +atomic_set (&fb_helper->open_count,0 ); +strcpy (fb_helper->fb->comm,"[fbcon]" );return 0 ; }
include/drm/drm_fb_helper.h +14 -0
@@ -232,6 +232,20 @@ struct drm_fb_helper {* See also: @deferred_setup */ int preferred_bpp; + +/** +* @open_count: +* +* Keeps track of fbdev use to know when to not restore fbdev. +* +* Drivers that use DRM_FB_HELPER_DEFAULT_OPS and don't override +* \.fb_open will get an initial value of 0 and get restore based on +* actual use. Others will get an initial value of 1 which means that +* fbdev will always be restored. Drivers that call +* drm_fb_helper_fb_open() in their \.fb_open, thus needs to set the +* initial value to 0 themselves. +*/ +atomic_t open_count; };/**
Signature · 6 lines
2.14.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
RFC 4/7 drm/prime: Clear drm_gem_object->dma_buf on release
In reply to Noralf TrønnesClear the pointer so the buffer can be re-exported. Otherwise use after free happens in the next call to drm_gem_prime_handle_to_fd().
--- drivers/gpu/drm/drm_prime.c | 1 + 1 file changed, 1 insertion(+)
drivers/gpu/drm/drm_prime.c +1 -0
@@ -343,6 +343,7 @@ void drm_gem_dmabuf_release(struct dma_buf *dma_buf)/* drop the reference on the export fd holds */ drm_gem_object_put_unlocked (obj); + obj->dma_buf =NULL ;drm_dev_put (dev); }
Signature · 6 lines
2.14.2 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [RFC 4/7] drm/prime: Clear drm_gem_object->dma_buf on release
Quoting Noralf Trønnes (2017-12-31 13:58:40)
Quoted 13 lines
Clear the pointer so the buffer can be re-exported. Otherwise use after free happens in the next call to
drm_gem_prime_handle_to_fd().Signed-off-by Noralf Trønnes <[email protected]>--- drivers/gpu/drm/drm_prime.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/drm_prime.c +0
-0
drivers/gpu/drm/drm_prime.c void drm_gem_dmabuf_release(struct dma_buf *dma_buf) · line 346
Quoted 4 lines
drivers/gpu/drm/drm_prime.c +1
-0@@ -343,6 +343,7 @@ void drm_gem_dmabuf_release(struct dma_buf *dma_buf)/* drop the reference on the export fd holds */ drm_gem_object_put_unlocked (obj); + obj->dma_buf =NULL ;
obj->dma_buf holds a reference to the dma_buf, so to get to the dma_buf release we must have already called dma_buf_put(obj->dma_buf). See drm_gem_object_exported_dma_buf_free(). (Note you would do the obj->dma_buf = NULL before dropping the potentially last ref to obj.) A BUG_ON(obj->dma_buf) may help clarify the cache was already released. -Chris
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [RFC 4/7] drm/prime: Clear drm_gem_object->dma_buf on release
Den 31.12.2017 16.41, skrev Chris Wilson:
Quoted 15 lines
Quoting Noralf Trønnes (2017-12-31 13:58:40)
Quoted 14 lines
Clear the pointer so the buffer can be re-exported. Otherwise use after free happens in the next call to
drm_gem_prime_handle_to_fd().Signed-off-by Noralf Trønnes <[email protected]>--- drivers/gpu/drm/drm_prime.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/drm_prime.c +0
-0@@ -343,6 +343,7 @@ void drm_gem_dmabuf_release(struct dma_buf *dma_buf)
Quoted 8 lines
drivers/gpu/drm/drm_prime.c void drm_gem_dmabuf_release(struct dma_buf *dma_buf) · line 346
Quoted 3 lines
drivers/gpu/drm/drm_prime.c +1
-0/* drop the reference on the export fd holds */ drm_gem_object_put_unlocked (obj); + obj->dma_buf =NULL ;
obj->dma_bufholds a reference to thedma_buf, so to get to thedma_bufrelease we must have already calleddma_buf_put(obj->dma_buf). Seedrm_gem_object_exported_dma_buf_free(). (Note you would do theobj->dma_buf= NULL before dropping the potentially last ref to obj.) ABUG_ON(obj->dma_buf)may help clarify the cache was already released.
Hmm, okay it was a shot in the dark.
Maybe I can defer dumb_buffer and drm_framebuffer creation until fb_open and then free it all in fb_close. That would align fbdev emulation more with how DRM userspace operates. Let's see what assumptions the code has about drm_fb_helper->fb being set on probe...
Noralf.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
RFC 5/7 drm: Handle fbdev emulation in core
In reply to Noralf TrønnesPrepare for generic fbdev emulation by letting DRM core work directly with the fbdev compatibility layer. This is done by adding new fbdev helper vtable callbacks for restore, hotplug_event, unregister and release.
--- drivers/gpu/drm/drm_file.c | 12 +++++++++++- drivers/gpu/drm/drm_mode_config.c | 10 ++++++++++ drivers/gpu/drm/drm_probe_helper.c | 4 ++++ include/drm/drm_fb_helper.h | 33 +++++++++++++++++++++++++++++++++ 4 files changed, 58 insertions(+), 1 deletion(-)
drivers/gpu/drm/drm_file.c +11 -1
@@ -35,6 +35,7 @@#include <linux/slab.h> #include <linux/module.h> +#include <drm/drm_fb_helper.h> #include <drm/drm_file.h> #include <drm/drmP.h>
@@ -439,10 +440,19 @@ static void drm_legacy_dev_reinit(struct drm_device *dev)void drm_lastclose (struct drm_device * dev) { +struct drm_fb_helper *fb_helper = dev->fb_helper; +int ret; +DRM_DEBUG ("\n" ); -if (dev->driver->lastclose) +if (dev->driver->lastclose) { dev->driver->lastclose (dev); + }else if (fb_helper && fb_helper->funcs && fb_helper->funcs->restore) { + ret = fb_helper->funcs->restore (fb_helper); +if (ret) +DRM_ERROR ("Failed to restore fbdev: %d\n" , ret); + } +DRM_DEBUG ("driver lastclose completed\n" );if (drm_core_check_feature (dev,DRIVER_LEGACY ))
drivers/gpu/drm/drm_mode_config.c +10 -0
@@ -21,6 +21,7 @@*/ #include <drm/drm_encoder.h> +#include <drm/drm_fb_helper.h> #include <drm/drm_mode_config.h> #include <drm/drmP.h>
@@ -61,6 +62,11 @@ int drm_modeset_register_all(struct drm_device *dev)void drm_modeset_unregister_all (struct drm_device *dev) { +struct drm_fb_helper *fb_helper = dev->fb_helper; + +if (fb_helper && fb_helper->funcs && fb_helper->funcs->unregister) + fb_helper->funcs->unregister (fb_helper); +drm_connector_unregister_all (dev);drm_encoder_unregister_all (dev);drm_crtc_unregister_all (dev);
@@ -408,6 +414,7 @@ EXPORT_SYMBOL(drm_mode_config_init);*/ void drm_mode_config_cleanup (struct drm_device *dev) { +struct drm_fb_helper *fb_helper = dev->fb_helper;struct drm_connector *connector;struct drm_connector_list_iter conn_iter;struct drm_crtc *crtc, *ct;
@@ -417,6 +424,9 @@ void drm_mode_config_cleanup(struct drm_device *dev)struct drm_property_blob *blob, *bt;struct drm_plane *plane, *plt; +if (fb_helper && fb_helper->funcs && fb_helper->funcs->release) + fb_helper->funcs->release (fb_helper); +list_for_each_entry_safe (encoder, enct, &dev->mode_config.encoder_list, head) { encoder->funcs->destroy (encoder);
drivers/gpu/drm/drm_probe_helper.c +4 -0
@@ -559,10 +559,14 @@ EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);*/ void drm_kms_helper_hotplug_event (struct drm_device *dev) { +struct drm_fb_helper *fb_helper = dev->fb_helper; +/* send a uevent + call fbdev */ drm_sysfs_hotplug_event (dev);if (dev->mode_config.funcs->output_poll_changed) dev->mode_config.funcs->output_poll_changed (dev); +else if (fb_helper && fb_helper->funcs && fb_helper->funcs->hotplug_event) + fb_helper->funcs->hotplug_event (fb_helper); }EXPORT_SYMBOL (drm_kms_helper_hotplug_event);
include/drm/drm_fb_helper.h +33 -0
@@ -125,6 +125,39 @@ struct drm_fb_helper_funcs {struct drm_display_mode **modes, struct drm_fb_offset *offsets, bool *enabled, int width, int height); + +/** +* @restore: +* +* Optional callback for restoring fbdev emulation. +* Called by drm_lastclose() if &drm_driver->lastclose is not set. +*/ +int (*restore)(struct drm_fb_helper *fb_helper); + +/** +* @hotplug_event: +* +* Optional callback for hotplug events. +* Called by drm_kms_helper_hotplug_event() if +* &drm_mode_config_funcs->output_poll_changed is not set. +*/ +int (*hotplug_event)(struct drm_fb_helper *fb_helper); + +/** +* @unregister: +* +* Optional callback for unregistrering fbdev emulation. +* Called by drm_dev_unregister(). +*/ +void (*unregister)(struct drm_fb_helper *fb_helper); + +/** +* @release: +* +* Optional callback for releasing fbdev emulation resources. +* Called by drm_mode_config_cleanup(). +*/ +void (*release)(struct drm_fb_helper *fb_helper); };struct drm_fb_helper_connector {
Signature · 6 lines
2.14.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
RFC 6/7 drm/fb-helper: Add generic fbdev emulation
In reply to Noralf TrønnesAdd generic fbdev emulation which uses a drm_file to get a dumb_buffer and drm_framebuffer. The buffer is exported and vmap/mmap called on the dma-buf.
--- drivers/gpu/drm/drm_fb_helper.c | 289 ++++++++++++++++++++++++++++++++++++++++ include/drm/drm_fb_helper.h | 33 +++++ 2 files changed, 322 insertions(+)
drivers/gpu/drm/drm_fb_helper.c +289 -0
@@ -30,6 +30,7 @@#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt#include <linux/console.h> +#include <linux/dma-buf.h> #include <linux/kernel.h> #include <linux/sysrq.h> #include <linux/slab.h>
@@ -43,6 +44,7 @@#include "drm_crtc_internal.h" #include "drm_crtc_helper_internal.h" +#include "drm_internal.h" static bool drm_fbdev_emulation = true;module_param_named (fbdev_emulation, drm_fbdev_emulation, bool,0600 );
@@ -2975,6 +2977,293 @@ void drm_fb_helper_output_poll_changed(struct drm_device *dev) }EXPORT_SYMBOL (drm_fb_helper_output_poll_changed); +static int drm_fb_helper_generic_vmap (struct drm_fb_helper *fb_helper) +{ +struct drm_prime_handle prime_args = { + .handle = fb_helper->dumb_handle, + }; +struct dma_buf *dma_buf; +void *vaddr; +int ret; + + ret =drm_prime_handle_to_fd_ioctl (fb_helper->dev, &prime_args, + fb_helper->file); +if (ret) +return ret; + + dma_buf =dma_buf_get (prime_args.fd); +if (WARN_ON (IS_ERR (dma_buf))) +return PTR_ERR (dma_buf); + +/* drop the ref we picked up in handle_to_fd */ +dma_buf_put (dma_buf); + + vaddr =dma_buf_vmap (dma_buf); +if (!vaddr) { + ret = -ENOMEM ; + goto err_remove_handle; + } + +if (fb_helper->fbdev->fbdefio) +fb_deferred_io_init (fb_helper->fbdev); + + fb_helper->fbdev->screen_buffer = vaddr; + fb_helper->dma_buf = dma_buf; + +return 0 ; + +err_remove_handle: +drm_prime_remove_buf_handle_locked (&fb_helper->file->prime, + fb_helper->dma_buf); +dma_buf_put (dma_buf); + +return ret; +} + +static void drm_fb_helper_generic_vunmap (struct drm_fb_helper *fb_helper) +{ +if (fb_helper->fbdev->fbdefio) { +cancel_delayed_work_sync (&fb_helper->fbdev->deferred_work); +cancel_work_sync (&fb_helper->dirty_work); +fb_deferred_io_cleanup (fb_helper->fbdev); + } + +dma_buf_vunmap (fb_helper->dma_buf, fb_helper->fbdev->screen_buffer); + fb_helper->fbdev->screen_buffer =NULL ; + +drm_prime_remove_buf_handle_locked (&fb_helper->file->prime, + fb_helper->dma_buf); +dma_buf_put (fb_helper->dma_buf); + fb_helper->dma_buf =NULL ; +} + +static int drm_fb_helper_generic_fb_open (struct fb_info *info,int user) +{ +struct drm_fb_helper *fb_helper = info->par; +int ret; + + ret =drm_fb_helper_fb_open (info, user); +if (ret) +return ret; + +if (!fb_helper->fbdev->screen_buffer) { +/* +* Exporting a buffer to get a virtual address results in +* dma-buf pinning the driver module. This means that we have +* to vmap/vunmap in open/close to be able to unload the driver +* module. +*/ + ret =drm_fb_helper_generic_vmap (fb_helper); +if (ret) { +DRM_ERROR ("fbdev: Failed to vmap buffer: %d\n" , ret); +drm_fb_helper_fb_release (info, user); +return ret; + } + } + +return 0 ; +} + +static int drm_fb_helper_generic_fb_release (struct fb_info *info,int user) +{ +struct drm_fb_helper *fb_helper = info->par; + +drm_fb_helper_fb_release (info, user); + +if (!atomic_read (&fb_helper->open_count)) +drm_fb_helper_generic_vunmap (fb_helper); + +return 0 ; +} + +static int drm_fb_helper_generic_fb_mmap (struct fb_info *info, +struct vm_area_struct *vma) +{ +struct drm_fb_helper *fb_helper = info->par; + +return dma_buf_mmap (fb_helper->dma_buf, vma,0 ); +} + +static struct fb_ops drm_fb_helper_generic_fbdev_ops = { + .owner =THIS_MODULE , +DRM_FB_HELPER_DEFAULT_OPS , + .fb_open = drm_fb_helper_generic_fb_open, + .fb_release = drm_fb_helper_generic_fb_release, + .fb_mmap = drm_fb_helper_generic_fb_mmap, + .fb_read = drm_fb_helper_sys_read, + .fb_write = drm_fb_helper_sys_write, + .fb_fillrect = drm_fb_helper_sys_fillrect, + .fb_copyarea = drm_fb_helper_sys_copyarea, + .fb_imageblit = drm_fb_helper_sys_imageblit, +}; + +static struct fb_deferred_io drm_fb_helper_generic_defio = { + .delay =HZ /20 , + .deferred_io = drm_fb_helper_deferred_io, +}; + +static int drm_fb_helper_generic_probe (struct drm_fb_helper *fb_helper, +struct drm_fb_helper_surface_size *sizes) +{ +struct drm_mode_create_dumb dumb_args = {0 }; +struct drm_mode_fb_cmd2 fb_args = {0 }; +struct drm_device *dev = fb_helper->dev; +struct drm_framebuffer *fb; +struct drm_file *file; +struct fb_info *fbi; +int ret; + +DRM_DEBUG_KMS ("surface width(%d), height(%d) and bpp(%d)\n" , + sizes->surface_width, sizes->surface_height, + sizes->surface_bpp); + + file =drm_file_alloc (dev->primary); +if (IS_ERR (file)) +return PTR_ERR (file); + +drm_dropmaster_ioctl (dev,NULL , file); + + dumb_args.width = sizes->surface_width; + dumb_args.height = sizes->surface_height; + dumb_args.bpp = sizes->surface_bpp; + + ret =drm_mode_create_dumb_ioctl (dev, &dumb_args, file); +if (ret) + goto err_free_file; + + fb_args.width = dumb_args.width; + fb_args.height = dumb_args.height; + fb_args.pixel_format =drm_mode_legacy_fb_format (sizes->surface_bpp, + sizes->surface_depth); + fb_args.handles[0 ] = dumb_args.handle; + fb_args.pitches[0 ] = dumb_args.pitch; + + ret =drm_mode_addfb2 (dev, &fb_args, file); +if (ret) + goto err_free_file; + + fb =drm_framebuffer_lookup (dev, file, fb_args.fb_id); +if (!fb) { + ret = -ENOENT ; + goto err_free_file; + } + +/* drop the reference we picked up in framebuffer lookup */ +drm_framebuffer_put (fb); + + fb_helper->dumb_handle = dumb_args.handle; + fb_helper->file = file; + fb_helper->fb = fb; + + fbi =drm_fb_helper_alloc_fbi (fb_helper); +if (IS_ERR (fbi)) { + ret =PTR_ERR (fbi); + goto err_free_file; + } + + fbi->par = fb_helper; + fbi->fbops = &drm_fb_helper_generic_fbdev_ops; + fbi->screen_size = fb->height * fb->pitches[0 ]; + fbi->fix.smem_len = fbi->screen_size; +strcpy (fbi->fix.id,"generic" ); + +drm_fb_helper_fill_fix (fbi, fb->pitches[0 ], fb->format->depth); +drm_fb_helper_fill_var (fbi, fb_helper, sizes->fb_width, sizes->fb_height); + +if (fb->funcs->dirty) { +struct fb_ops *fbops; + +/* +* fb_deferred_io_cleanup() clears &fbops->fb_mmap so a per +* instance version is necessary. +*/ + fbops =kzalloc (sizeof (*fbops),GFP_KERNEL ); +if (!fbops) { + ret = -ENOMEM ; + goto err_fb_info_destroy; + } + + *fbops = *fbi->fbops; + fbi->fbops = fbops; + fbi->fbdefio = &drm_fb_helper_generic_defio; + } + +atomic_set (&fb_helper->open_count,0 ); + +return 0 ; + +err_fb_info_destroy: +drm_fb_helper_fini (fb_helper); +err_free_file: +drm_file_free (file); + +return ret; +} + +static void drm_fb_helper_generic_release (struct drm_fb_helper *fb_helper) +{ +struct fb_ops *fbops =NULL ; + +if (fb_helper->fbdev->fbdefio) + fbops = fb_helper->fbdev->fbops; + +drm_fb_helper_fini (fb_helper); +drm_file_free (fb_helper->file); + +kfree (fb_helper); +kfree (fbops); +} + +static const struct drm_fb_helper_funcs drm_fb_helper_generic_funcs = { + .fb_probe = drm_fb_helper_generic_probe, + .restore = drm_fb_helper_restore_fbdev_mode_unlocked, + .hotplug_event = drm_fb_helper_hotplug_event, + .unregister = drm_fb_helper_unregister_fbi, + .release = drm_fb_helper_generic_release, +}; + +/** +* drm_fb_helper_generic_fbdev_setup() - Setup generic fbdev emulation +* @dev: DRM device +* @preferred_bpp: Preferred bits per pixel for the device. +* @dev->mode_config.preferred_depth is used if this is zero. +* @max_conn_count: Maximum number of connectors. +* @dev->mode_config.num_connector is used if this is zero. +* +* This function sets up generic fbdev emulation for drivers that supports +* dumb buffers and provides exported buffers with a virtual address. +* The driver doesn't have to anything else than to call this function, +* restore, hotplug events and teardown are all taken care of. +* +* Returns: +* Zero on success or negative error code on failure. +*/ +int drm_fb_helper_generic_fbdev_setup (struct drm_device *dev, +unsigned int preferred_bpp, +unsigned int max_conn_count) +{ +struct drm_fb_helper *fb_helper; +int ret; + +if (!drm_fbdev_emulation) +return 0 ; + + fb_helper =kzalloc (sizeof (*fb_helper),GFP_KERNEL ); +if (!fb_helper) +return -ENOMEM ; + + ret =drm_fb_helper_fbdev_setup (dev, fb_helper, + &drm_fb_helper_generic_funcs, + preferred_bpp, max_conn_count); +if (ret) { +kfree (fb_helper); +return ret; + } + +return 0 ; +} +EXPORT_SYMBOL (drm_fb_helper_generic_fbdev_setup); +/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT) * but the module doesn't depend on any fb console symbols. At least * attempt to load fbcon to avoid leaving the system without a usable console.
include/drm/drm_fb_helper.h +33 -0
@@ -279,6 +279,28 @@ struct drm_fb_helper {* initial value to 0 themselves. */ atomic_t open_count; + +/** +* @file: +* +* Optional DRM file. Used by the generic fbdev code. +*/ +struct drm_file *file; + +/** +* @dumb_handle: +* +* Optional dumb buffer handle. Used by the generic fbdev code. +*/ +u32 dumb_handle; + +/** +* @dma_buf: +* +* Optional pointer to a DMA buffer object. +* Used by the generic fbdev code. +*/ +struct dma_buf *dma_buf; };/**
@@ -382,6 +404,10 @@ void drm_fb_helper_fbdev_teardown(struct drm_device *dev);void drm_fb_helper_lastclose (struct drm_device *dev);void drm_fb_helper_output_poll_changed (struct drm_device *dev); + +int drm_fb_helper_generic_fbdev_setup (struct drm_device *dev, +unsigned int preferred_bpp, +unsigned int max_conn_count);#else static inline void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
@@ -626,6 +652,13 @@ static inline void drm_fb_helper_output_poll_changed(struct drm_device *dev) { } +static inline int +drm_fb_helper_generic_fbdev_setup (struct drm_device *dev, +unsigned int preferred_bpp, +unsigned int max_conn_count) +{ +return 0 ; +}#endif static inline int
Signature · 6 lines
2.14.2 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
RFC 7/7 drm/vc4: Test generic fbdev emulation
In reply to Noralf Trønnes--- drivers/gpu/drm/vc4/vc4_drv.c | 3 --- drivers/gpu/drm/vc4/vc4_kms.c | 3 +-- 2 files changed, 1 insertion(+), 5 deletions(-)
drivers/gpu/drm/vc4/vc4_drv.c +0 -3
@@ -152,7 +152,6 @@ static struct drm_driver vc4_drm_driver = {DRIVER_HAVE_IRQ |DRIVER_RENDER | DRIVER_PRIME), - .lastclose = drm_fb_helper_lastclose, .irq_handler = vc4_irq, .irq_preinstall = vc4_irq_preinstall, .irq_postinstall = vc4_irq_postinstall,
@@ -297,8 +296,6 @@ static void vc4_drm_unbind(struct device *dev)drm_dev_unregister (drm); -drm_fb_cma_fbdev_fini (drm); -drm_mode_config_cleanup (drm);drm_dev_unref (drm);
drivers/gpu/drm/vc4/vc4_kms.c +1 -2
@@ -188,7 +188,6 @@ static struct drm_framebuffer *vc4_fb_create(struct drm_device *dev, }static const struct drm_mode_config_funcs vc4_mode_funcs = { - .output_poll_changed = drm_fb_helper_output_poll_changed, .atomic_check = drm_atomic_helper_check, .atomic_commit = vc4_atomic_commit, .fb_create = vc4_fb_create,
@@ -219,7 +218,7 @@ int vc4_kms_load(struct drm_device *dev)drm_mode_config_reset (dev);if (dev->mode_config.num_connector) -drm_fb_cma_fbdev_init (dev,32 ,0 ); +drm_fb_helper_generic_fbdev_setup (dev,32 ,0 );drm_kms_helper_poll_init (dev);
Signature · 6 lines
2.14.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Patchwork
CI✗ Fi.CI.BAT: warning for drm: Add generic fbdev emulation
In reply to Noralf Trønnes== Series Details ==
== Series Details ==
Series: drm: Add generic fbdev emulation
URL : https://patchwork.freedesktop.org/series/35873/
State : warning
== Summary ==
Series 35873v1 drm: Add generic fbdev emulation
https://patchwork.freedesktop.org/api/1.0/series/35873/revisions/1/mbox/
Test core_prop_blob:
Subgroup basic:
pass -> DMESG-WARN (fi-elk-e7500)
Test debugfs_test:
Subgroup read_all_entries:
dmesg-fail -> DMESG-WARN (fi-elk-e7500) fdo#103989
Test drv_getparams_basic:
Subgroup basic-eu-total:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-subslice-total:
pass -> DMESG-WARN (fi-elk-e7500)
Test drv_hangman:
Subgroup error-state-basic:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_basic:
Subgroup bad-close:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup create-close:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup create-fd-close:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_busy:
Subgroup basic-busy-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-hang-default:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_close_race:
Subgroup basic-process:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-threads:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_cpu_reloc:
Subgroup basic:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_cs_tlb:
Subgroup basic-default:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_exec_basic:
Subgroup basic-bsd:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-render:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup gtt-bsd:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup gtt-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup gtt-render:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup readonly-bsd:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup readonly-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup readonly-render:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_exec_create:
Subgroup basic:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_exec_fence:
Subgroup basic-busy-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wait-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-await-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup await-hang-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup nb-await-default:
pass -> DMESG-WARN (fi-elk-e7500)
Test gem_exec_flush:
Subgroup basic-batch-kernel-default-uc:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-batch-kernel-default-wb:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-uc-pro-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-uc-prw-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-uc-ro-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-uc-rw-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-uc-set-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wb-pro-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wb-prw-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wb-ro-before-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wb-ro-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wb-rw-before-default:
pass -> DMESG-WARN (fi-elk-e7500)
Subgroup basic-wb-rw-default:
pass -> DMESG-WARN (fi-elk-e7500)WARNING: Long output truncated
fi-ilk-650 failed to collect. IGT log at Patchwork_7593/fi-ilk-650/igt.log
16432d39f2cbdc7a8798df3ebb4f7c882fb23132 drm-tip: 2017y-12m-30d-02h-25m-26s UTC integration manifest 2d7b02fbcdc1 drm/vc4: Test generic fbdev emulation5e8d502b385b drm/fb-helper: Add generic fbdev emulationcca8dc2718b2 drm: Handle fbdev emulation in core0fb70b30a370 drm/prime: Clear drm_gem_object->dma_buf on release62fa7d13869e drm/fb-helper: Don't restore if fbdev is not in use105bcaf70f49 drm/fb-helper: Ensure driver module is pinned in fb_open()dcec14502862 drm: provide management functions for drm_file
== Logs ==
For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_7593/issues.html
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx