drm: rework flip-work helpers to avoid calling func when the FIFO is full (8bd4ae20) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/gpu/drm/drm_flip_work.c

+73 −24

Original line number	Original line	Diff line number	Diff line
	@@ -24,6 +24,44 @@
	#include "drmP.h"		#include "drmP.h"
	#include "drm_flip_work.h"		#include "drm_flip_work.h"

			/**
			* drm_flip_work_allocate_task - allocate a flip-work task
			* @data: data associated to the task
			* @flags: allocator flags
			*
			* Allocate a drm_flip_task object and attach private data to it.
			*/
			struct drm_flip_task drm_flip_work_allocate_task(void data, gfp_t flags)
			{
			struct drm_flip_task *task;

			task = kzalloc(sizeof(*task), flags);
			if (task)
			task->data = data;

			return task;
			}
			EXPORT_SYMBOL(drm_flip_work_allocate_task);

			/**
			* drm_flip_work_queue_task - queue a specific task
			* @work: the flip-work
			* @task: the task to handle
			*
			* Queues task, that will later be run (passed back to drm_flip_func_t
			* func) on a work queue after drm_flip_work_commit() is called.
			*/
			void drm_flip_work_queue_task(struct drm_flip_work *work,
			struct drm_flip_task *task)
			{
			unsigned long flags;

			spin_lock_irqsave(&work->lock, flags);
			list_add_tail(&task->node, &work->queued);
			spin_unlock_irqrestore(&work->lock, flags);
			}
			EXPORT_SYMBOL(drm_flip_work_queue_task);

	/**		/**
	* drm_flip_work_queue - queue work		* drm_flip_work_queue - queue work
	* @work: the flip-work		* @work: the flip-work
	@@ -34,10 +72,14 @@
	*/		*/
	void drm_flip_work_queue(struct drm_flip_work work, void val)		void drm_flip_work_queue(struct drm_flip_work work, void val)
	{		{
	if (kfifo_put(&work->fifo, val)) {		struct drm_flip_task *task;
	atomic_inc(&work->pending);
			task = drm_flip_work_allocate_task(val,
			drm_can_sleep() ? GFP_KERNEL : GFP_ATOMIC);
			if (task) {
			drm_flip_work_queue_task(work, task);
	} else {		} else {
	DRM_ERROR("%s fifo full!\n", work->name);		DRM_ERROR("%s could not allocate task!\n", work->name);
	work->func(work, val);		work->func(work, val);
	}		}
	}		}
	@@ -56,9 +98,12 @@ EXPORT_SYMBOL(drm_flip_work_queue);
	void drm_flip_work_commit(struct drm_flip_work *work,		void drm_flip_work_commit(struct drm_flip_work *work,
	struct workqueue_struct *wq)		struct workqueue_struct *wq)
	{		{
	uint32_t pending = atomic_read(&work->pending);		unsigned long flags;
	atomic_add(pending, &work->count);
	atomic_sub(pending, &work->pending);		spin_lock_irqsave(&work->lock, flags);
			list_splice_tail(&work->queued, &work->commited);
			INIT_LIST_HEAD(&work->queued);
			spin_unlock_irqrestore(&work->lock, flags);
	queue_work(wq, &work->worker);		queue_work(wq, &work->worker);
	}		}
	EXPORT_SYMBOL(drm_flip_work_commit);		EXPORT_SYMBOL(drm_flip_work_commit);
	@@ -66,14 +111,26 @@ EXPORT_SYMBOL(drm_flip_work_commit);
	static void flip_worker(struct work_struct *w)		static void flip_worker(struct work_struct *w)
	{		{
	struct drm_flip_work *work = container_of(w, struct drm_flip_work, worker);		struct drm_flip_work *work = container_of(w, struct drm_flip_work, worker);
	uint32_t count = atomic_read(&work->count);		struct list_head tasks;
	void *val = NULL;		unsigned long flags;

	atomic_sub(count, &work->count);		while (1) {
			struct drm_flip_task task, tmp;

	while(count--)		INIT_LIST_HEAD(&tasks);
	if (!WARN_ON(!kfifo_get(&work->fifo, &val)))		spin_lock_irqsave(&work->lock, flags);
	work->func(work, val);		list_splice_tail(&work->commited, &tasks);
			INIT_LIST_HEAD(&work->commited);
			spin_unlock_irqrestore(&work->lock, flags);

			if (list_empty(&tasks))
			break;

			list_for_each_entry_safe(task, tmp, &tasks, node) {
			work->func(work, task->data);
			kfree(task);
			}
			}
	}		}

	/**		/**
	@@ -91,19 +148,12 @@ static void flip_worker(struct work_struct *w)
	int drm_flip_work_init(struct drm_flip_work *work, int size,		int drm_flip_work_init(struct drm_flip_work *work, int size,
	const char *name, drm_flip_func_t func)		const char *name, drm_flip_func_t func)
	{		{
	int ret;

	work->name = name;		work->name = name;
	atomic_set(&work->count, 0);		INIT_LIST_HEAD(&work->queued);
	atomic_set(&work->pending, 0);		INIT_LIST_HEAD(&work->commited);
			spin_lock_init(&work->lock);
	work->func = func;		work->func = func;

	ret = kfifo_alloc(&work->fifo, size, GFP_KERNEL);
	if (ret) {
	DRM_ERROR("could not allocate %s fifo\n", name);
	return ret;
	}

	INIT_WORK(&work->worker, flip_worker);		INIT_WORK(&work->worker, flip_worker);

	return 0;		return 0;
	@@ -118,7 +168,6 @@ EXPORT_SYMBOL(drm_flip_work_init);
	*/		*/
	void drm_flip_work_cleanup(struct drm_flip_work *work)		void drm_flip_work_cleanup(struct drm_flip_work *work)
	{		{
	WARN_ON(!kfifo_is_empty(&work->fifo));		WARN_ON(!list_empty(&work->queued) \|\| !list_empty(&work->commited));
	kfifo_free(&work->fifo);
	}		}
	EXPORT_SYMBOL(drm_flip_work_cleanup);		EXPORT_SYMBOL(drm_flip_work_cleanup);

include/drm/drm_flip_work.h

+23 −8

Original line number	Original line	Diff line number	Diff line
	@@ -25,6 +25,7 @@
	#define DRM_FLIP_WORK_H		#define DRM_FLIP_WORK_H

	#include <linux/kfifo.h>		#include <linux/kfifo.h>
			#include <linux/spinlock.h>
	#include <linux/workqueue.h>		#include <linux/workqueue.h>

	/**		/**
	@@ -32,9 +33,9 @@
	*		*
	* Util to queue up work to run from work-queue context after flip/vblank.		* Util to queue up work to run from work-queue context after flip/vblank.
	* Typically this can be used to defer unref of framebuffer's, cursor		* Typically this can be used to defer unref of framebuffer's, cursor
	* bo's, etc until after vblank. The APIs are all safe (and lockless)		* bo's, etc until after vblank. The APIs are all thread-safe.
	* for up to one producer and once consumer at a time. The single-consumer		* Moreover, drm_flip_work_queue_task and drm_flip_work_queue can be called
	* aspect is ensured by committing the queued work to a single work-queue.		* in atomic context.
	*/		*/

	struct drm_flip_work;		struct drm_flip_work;
	@@ -50,23 +51,37 @@ struct drm_flip_work;
	*/		*/
	typedef void (drm_flip_func_t)(struct drm_flip_work work, void *val);		typedef void (drm_flip_func_t)(struct drm_flip_work work, void *val);

			/**
			* struct drm_flip_task - flip work task
			* @node: list entry element
			* @data: data to pass to work->func
			*/
			struct drm_flip_task {
			struct list_head node;
			void *data;
			};

	/**		/**
	* struct drm_flip_work - flip work queue		* struct drm_flip_work - flip work queue
	* @name: debug name		* @name: debug name
	* @pending: number of queued but not committed items
	* @count: number of committed items
	* @func: callback fxn called for each committed item		* @func: callback fxn called for each committed item
	* @worker: worker which calls @func		* @worker: worker which calls @func
	* @fifo: queue of committed items		* @queued: queued tasks
			* @commited: commited tasks
			* @lock: lock to access queued and commited lists
	*/		*/
	struct drm_flip_work {		struct drm_flip_work {
	const char *name;		const char *name;
	atomic_t pending, count;
	drm_flip_func_t func;		drm_flip_func_t func;
	struct work_struct worker;		struct work_struct worker;
	DECLARE_KFIFO_PTR(fifo, void *);		struct list_head queued;
			struct list_head commited;
			spinlock_t lock;
	};		};

			struct drm_flip_task drm_flip_work_allocate_task(void data, gfp_t flags);
			void drm_flip_work_queue_task(struct drm_flip_work *work,
			struct drm_flip_task *task);
	void drm_flip_work_queue(struct drm_flip_work work, void val);		void drm_flip_work_queue(struct drm_flip_work work, void val);
	void drm_flip_work_commit(struct drm_flip_work *work,		void drm_flip_work_commit(struct drm_flip_work *work,
	struct workqueue_struct *wq);		struct workqueue_struct *wq);