drivers/gpu/drm/drm_flip_work.c

   1 /*
   2  * Copyright (C) 2013 Red Hat
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #include <linux/slab.h>
  25
  26 #include <drm/drm_flip_work.h>
  27 #include <drm/drm_print.h>
  28 #include <drm/drm_util.h>
  29
  30 struct drm_flip_task {
  31         struct list_head node;
  32         void *data;
  33 };
  34
  35 static struct drm_flip_task *drm_flip_work_allocate_task(void *data, gfp_t flags)
  36 {
  37         struct drm_flip_task *task;
  38
  39         task = kzalloc(sizeof(*task), flags);
  40         if (task)
  41                 task->data = data;
  42
  43         return task;
  44 }
  45
  46 static void drm_flip_work_queue_task(struct drm_flip_work *work, struct drm_flip_task *task)
  47 {
  48         unsigned long flags;
  49
  50         spin_lock_irqsave(&work->lock, flags);
  51         list_add_tail(&task->node, &work->queued);
  52         spin_unlock_irqrestore(&work->lock, flags);
  53 }
  54
  55 /**
  56  * drm_flip_work_queue - queue work
  57  * @work: the flip-work
  58  * @val: the value to queue
  59  *
  60  * Queues work, that will later be run (passed back to drm_flip_func_t
  61  * func) on a work queue after drm_flip_work_commit() is called.
  62  */
  63 void drm_flip_work_queue(struct drm_flip_work *work, void *val)
  64 {
  65         struct drm_flip_task *task;
  66
  67         task = drm_flip_work_allocate_task(val,
  68                                 drm_can_sleep() ? GFP_KERNEL : GFP_ATOMIC);
  69         if (task) {
  70                 drm_flip_work_queue_task(work, task);
  71         } else {
  72                 DRM_ERROR("%s could not allocate task!\n", work->name);
  73                 work->func(work, val);
  74         }
  75 }
  76 EXPORT_SYMBOL(drm_flip_work_queue);
  77
  78 /**
  79  * drm_flip_work_commit - commit queued work
  80  * @work: the flip-work
  81  * @wq: the work-queue to run the queued work on
  82  *
  83  * Trigger work previously queued by drm_flip_work_queue() to run
  84  * on a workqueue.  The typical usage would be to queue work (via
  85  * drm_flip_work_queue()) at any point (from vblank irq and/or
  86  * prior), and then from vblank irq commit the queued work.
  87  */
  88 void drm_flip_work_commit(struct drm_flip_work *work,
  89                 struct workqueue_struct *wq)
  90 {
  91         unsigned long flags;
  92
  93         spin_lock_irqsave(&work->lock, flags);
  94         list_splice_tail(&work->queued, &work->commited);
  95         INIT_LIST_HEAD(&work->queued);
  96         spin_unlock_irqrestore(&work->lock, flags);
  97         queue_work(wq, &work->worker);
  98 }
  99 EXPORT_SYMBOL(drm_flip_work_commit);
 100
 101 static void flip_worker(struct work_struct *w)
 102 {
 103         struct drm_flip_work *work = container_of(w, struct drm_flip_work, worker);
 104         struct list_head tasks;
 105         unsigned long flags;
 106
 107         while (1) {
 108                 struct drm_flip_task *task, *tmp;
 109
 110                 INIT_LIST_HEAD(&tasks);
 111                 spin_lock_irqsave(&work->lock, flags);
 112                 list_splice_tail(&work->commited, &tasks);
 113                 INIT_LIST_HEAD(&work->commited);
 114                 spin_unlock_irqrestore(&work->lock, flags);
 115
 116                 if (list_empty(&tasks))
 117                         break;
 118
 119                 list_for_each_entry_safe(task, tmp, &tasks, node) {
 120                         work->func(work, task->data);
 121                         kfree(task);
 122                 }
 123         }
 124 }
 125
 126 /**
 127  * drm_flip_work_init - initialize flip-work
 128  * @work: the flip-work to initialize
 129  * @name: debug name
 130  * @func: the callback work function
 131  *
 132  * Initializes/allocates resources for the flip-work
 133  */
 134 void drm_flip_work_init(struct drm_flip_work *work,
 135                 const char *name, drm_flip_func_t func)
 136 {
 137         work->name = name;
 138         INIT_LIST_HEAD(&work->queued);
 139         INIT_LIST_HEAD(&work->commited);
 140         spin_lock_init(&work->lock);
 141         work->func = func;
 142
 143         INIT_WORK(&work->worker, flip_worker);
 144 }
 145 EXPORT_SYMBOL(drm_flip_work_init);
 146
 147 /**
 148  * drm_flip_work_cleanup - cleans up flip-work
 149  * @work: the flip-work to cleanup
 150  *
 151  * Destroy resources allocated for the flip-work
 152  */
 153 void drm_flip_work_cleanup(struct drm_flip_work *work)
 154 {
 155         WARN_ON(!list_empty(&work->queued) || !list_empty(&work->commited));
 156 }
 157 EXPORT_SYMBOL(drm_flip_work_cleanup);