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