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 /**
  31  * drm_flip_work_allocate_task - allocate a flip-work task
  32  * @data: data associated to the task
  33  * @flags: allocator flags
  34  *
  35  * Allocate a drm_flip_task object and attach private data to it.
  36  */
  37 struct drm_flip_task *drm_flip_work_allocate_task(void *data, gfp_t flags)
  38 {
  39         struct drm_flip_task *task;
  40
  41         task = kzalloc(sizeof(*task), flags);
  42         if (task)
  43                 task->data = data;
  44
  45         return task;
  46 }
  47 EXPORT_SYMBOL(drm_flip_work_allocate_task);
  48
  49 /**
  50  * drm_flip_work_queue_task - queue a specific task
  51  * @work: the flip-work
  52  * @task: the task to handle
  53  *
  54  * Queues task, that will later be run (passed back to drm_flip_func_t
  55  * func) on a work queue after drm_flip_work_commit() is called.
  56  */
  57 void drm_flip_work_queue_task(struct drm_flip_work *work,
  58                               struct drm_flip_task *task)
  59 {
  60         unsigned long flags;
  61
  62         spin_lock_irqsave(&work->lock, flags);
  63         list_add_tail(&task->node, &work->queued);
  64         spin_unlock_irqrestore(&work->lock, flags);
  65 }
  66 EXPORT_SYMBOL(drm_flip_work_queue_task);
  67
  68 /**
  69  * drm_flip_work_queue - queue work
  70  * @work: the flip-work
  71  * @val: the value to queue
  72  *
  73  * Queues work, that will later be run (passed back to drm_flip_func_t
  74  * func) on a work queue after drm_flip_work_commit() is called.
  75  */
  76 void drm_flip_work_queue(struct drm_flip_work *work, void *val)
  77 {
  78         struct drm_flip_task *task;
  79
  80         task = drm_flip_work_allocate_task(val,
  81                                 drm_can_sleep() ? GFP_KERNEL : GFP_ATOMIC);
  82         if (task) {
  83                 drm_flip_work_queue_task(work, task);
  84         } else {
  85                 DRM_ERROR("%s could not allocate task!\n", work->name);
  86                 work->func(work, val);
  87         }
  88 }
  89 EXPORT_SYMBOL(drm_flip_work_queue);
  90
  91 /**
  92  * drm_flip_work_commit - commit queued work
  93  * @work: the flip-work
  94  * @wq: the work-queue to run the queued work on
  95  *
  96  * Trigger work previously queued by drm_flip_work_queue() to run
  97  * on a workqueue.  The typical usage would be to queue work (via
  98  * drm_flip_work_queue()) at any point (from vblank irq and/or
  99  * prior), and then from vblank irq commit the queued work.
 100  */
 101 void drm_flip_work_commit(struct drm_flip_work *work,
 102                 struct workqueue_struct *wq)
 103 {
 104         unsigned long flags;
 105
 106         spin_lock_irqsave(&work->lock, flags);
 107         list_splice_tail(&work->queued, &work->commited);
 108         INIT_LIST_HEAD(&work->queued);
 109         spin_unlock_irqrestore(&work->lock, flags);
 110         queue_work(wq, &work->worker);
 111 }
 112 EXPORT_SYMBOL(drm_flip_work_commit);
 113
 114 static void flip_worker(struct work_struct *w)
 115 {
 116         struct drm_flip_work *work = container_of(w, struct drm_flip_work, worker);
 117         struct list_head tasks;
 118         unsigned long flags;
 119
 120         while (1) {
 121                 struct drm_flip_task *task, *tmp;
 122
 123                 INIT_LIST_HEAD(&tasks);
 124                 spin_lock_irqsave(&work->lock, flags);
 125                 list_splice_tail(&work->commited, &tasks);
 126                 INIT_LIST_HEAD(&work->commited);
 127                 spin_unlock_irqrestore(&work->lock, flags);
 128
 129                 if (list_empty(&tasks))
 130                         break;
 131
 132                 list_for_each_entry_safe(task, tmp, &tasks, node) {
 133                         work->func(work, task->data);
 134                         kfree(task);
 135                 }
 136         }
 137 }
 138
 139 /**
 140  * drm_flip_work_init - initialize flip-work
 141  * @work: the flip-work to initialize
 142  * @name: debug name
 143  * @func: the callback work function
 144  *
 145  * Initializes/allocates resources for the flip-work
 146  */
 147 void drm_flip_work_init(struct drm_flip_work *work,
 148                 const char *name, drm_flip_func_t func)
 149 {
 150         work->name = name;
 151         INIT_LIST_HEAD(&work->queued);
 152         INIT_LIST_HEAD(&work->commited);
 153         spin_lock_init(&work->lock);
 154         work->func = func;
 155
 156         INIT_WORK(&work->worker, flip_worker);
 157 }
 158 EXPORT_SYMBOL(drm_flip_work_init);
 159
 160 /**
 161  * drm_flip_work_cleanup - cleans up flip-work
 162  * @work: the flip-work to cleanup
 163  *
 164  * Destroy resources allocated for the flip-work
 165  */
 166 void drm_flip_work_cleanup(struct drm_flip_work *work)
 167 {
 168         WARN_ON(!list_empty(&work->queued) || !list_empty(&work->commited));
 169 }
 170 EXPORT_SYMBOL(drm_flip_work_cleanup);