GNU Linux-libre 5.10.219-gnu1
[releases.git] / 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);