1 // SPDX-License-Identifier: MIT
2
3 #include <uapi/linux/sched/types.h>
4
5 #include <drm/drm_print.h>
6 #include <drm/drm_vblank.h>
7 #include <drm/drm_vblank_work.h>
8 #include <drm/drm_crtc.h>
9
10 #include "drm_internal.h"
11
12 /**
13 * DOC: vblank works
14 *
15 * Many DRM drivers need to program hardware in a time-sensitive manner, many
16 * times with a deadline of starting and finishing within a certain region of
17 * the scanout. Most of the time the safest way to accomplish this is to
18 * simply do said time-sensitive programming in the driver's IRQ handler,
19 * which allows drivers to avoid being preempted during these critical
20 * regions. Or even better, the hardware may even handle applying such
21 * time-critical programming independently of the CPU.
22 *
23 * While there's a decent amount of hardware that's designed so that the CPU
24 * doesn't need to be concerned with extremely time-sensitive programming,
25 * there's a few situations where it can't be helped. Some unforgiving
26 * hardware may require that certain time-sensitive programming be handled
27 * completely by the CPU, and said programming may even take too long to
28 * handle in an IRQ handler. Another such situation would be where the driver
29 * needs to perform a task that needs to complete within a specific scanout
30 * period, but might possibly block and thus cannot be handled in an IRQ
31 * context. Both of these situations can't be solved perfectly in Linux since
32 * we're not a realtime kernel, and thus the scheduler may cause us to miss
33 * our deadline if it decides to preempt us. But for some drivers, it's good
34 * enough if we can lower our chance of being preempted to an absolute
35 * minimum.
36 *
37 * This is where &drm_vblank_work comes in. &drm_vblank_work provides a simple
38 * generic delayed work implementation which delays work execution until a
39 * particular vblank has passed, and then executes the work at realtime
40 * priority. This provides the best possible chance at performing
41 * time-sensitive hardware programming on time, even when the system is under
42 * heavy load. &drm_vblank_work also supports rescheduling, so that self
43 * re-arming work items can be easily implemented.
44 */
45
drm_handle_vblank_works(struct drm_vblank_crtc * vblank)46 void drm_handle_vblank_works(struct drm_vblank_crtc *vblank)
47 {
48 struct drm_vblank_work *work, *next;
49 u64 count = atomic64_read(&vblank->count);
50 bool wake = false;
51
52 assert_spin_locked(&vblank->dev->event_lock);
53
54 list_for_each_entry_safe(work, next, &vblank->pending_work, node) {
55 if (!drm_vblank_passed(count, work->count))
56 continue;
57
58 list_del_init(&work->node);
59 drm_vblank_put(vblank->dev, vblank->pipe);
60 kthread_queue_work(vblank->worker, &work->base);
61 wake = true;
62 }
63 if (wake)
64 wake_up_all(&vblank->work_wait_queue);
65 }
66
67 /* Handle cancelling any pending vblank work items and drop respective vblank
68 * references in response to vblank interrupts being disabled.
69 */
drm_vblank_cancel_pending_works(struct drm_vblank_crtc * vblank)70 void drm_vblank_cancel_pending_works(struct drm_vblank_crtc *vblank)
71 {
72 struct drm_vblank_work *work, *next;
73
74 assert_spin_locked(&vblank->dev->event_lock);
75
76 drm_WARN_ONCE(vblank->dev, !list_empty(&vblank->pending_work),
77 "Cancelling pending vblank works!\n");
78
79 list_for_each_entry_safe(work, next, &vblank->pending_work, node) {
80 list_del_init(&work->node);
81 drm_vblank_put(vblank->dev, vblank->pipe);
82 }
83
84 wake_up_all(&vblank->work_wait_queue);
85 }
86
87 /**
88 * drm_vblank_work_schedule - schedule a vblank work
89 * @work: vblank work to schedule
90 * @count: target vblank count
91 * @nextonmiss: defer until the next vblank if target vblank was missed
92 *
93 * Schedule @work for execution once the crtc vblank count reaches @count.
94 *
95 * If the crtc vblank count has already reached @count and @nextonmiss is
96 * %false the work starts to execute immediately.
97 *
98 * If the crtc vblank count has already reached @count and @nextonmiss is
99 * %true the work is deferred until the next vblank (as if @count has been
100 * specified as crtc vblank count + 1).
101 *
102 * If @work is already scheduled, this function will reschedule said work
103 * using the new @count. This can be used for self-rearming work items.
104 *
105 * Returns:
106 * %1 if @work was successfully (re)scheduled, %0 if it was either already
107 * scheduled or cancelled, or a negative error code on failure.
108 */
drm_vblank_work_schedule(struct drm_vblank_work * work,u64 count,bool nextonmiss)109 int drm_vblank_work_schedule(struct drm_vblank_work *work,
110 u64 count, bool nextonmiss)
111 {
112 struct drm_vblank_crtc *vblank = work->vblank;
113 struct drm_device *dev = vblank->dev;
114 u64 cur_vbl;
115 unsigned long irqflags;
116 bool passed, inmodeset, rescheduling = false, wake = false;
117 int ret = 0;
118
119 spin_lock_irqsave(&dev->event_lock, irqflags);
120 if (work->cancelling)
121 goto out;
122
123 spin_lock(&dev->vbl_lock);
124 inmodeset = vblank->inmodeset;
125 spin_unlock(&dev->vbl_lock);
126 if (inmodeset)
127 goto out;
128
129 if (list_empty(&work->node)) {
130 ret = drm_vblank_get(dev, vblank->pipe);
131 if (ret < 0)
132 goto out;
133 } else if (work->count == count) {
134 /* Already scheduled w/ same vbl count */
135 goto out;
136 } else {
137 rescheduling = true;
138 }
139
140 work->count = count;
141 cur_vbl = drm_vblank_count(dev, vblank->pipe);
142 passed = drm_vblank_passed(cur_vbl, count);
143 if (passed)
144 drm_dbg_core(dev,
145 "crtc %d vblank %llu already passed (current %llu)\n",
146 vblank->pipe, count, cur_vbl);
147
148 if (!nextonmiss && passed) {
149 drm_vblank_put(dev, vblank->pipe);
150 ret = kthread_queue_work(vblank->worker, &work->base);
151
152 if (rescheduling) {
153 list_del_init(&work->node);
154 wake = true;
155 }
156 } else {
157 if (!rescheduling)
158 list_add_tail(&work->node, &vblank->pending_work);
159 ret = true;
160 }
161
162 out:
163 spin_unlock_irqrestore(&dev->event_lock, irqflags);
164 if (wake)
165 wake_up_all(&vblank->work_wait_queue);
166 return ret;
167 }
168 EXPORT_SYMBOL(drm_vblank_work_schedule);
169
170 /**
171 * drm_vblank_work_cancel_sync - cancel a vblank work and wait for it to
172 * finish executing
173 * @work: vblank work to cancel
174 *
175 * Cancel an already scheduled vblank work and wait for its
176 * execution to finish.
177 *
178 * On return, @work is guaranteed to no longer be scheduled or running, even
179 * if it's self-arming.
180 *
181 * Returns:
182 * %True if the work was cancelled before it started to execute, %false
183 * otherwise.
184 */
drm_vblank_work_cancel_sync(struct drm_vblank_work * work)185 bool drm_vblank_work_cancel_sync(struct drm_vblank_work *work)
186 {
187 struct drm_vblank_crtc *vblank = work->vblank;
188 struct drm_device *dev = vblank->dev;
189 bool ret = false;
190
191 spin_lock_irq(&dev->event_lock);
192 if (!list_empty(&work->node)) {
193 list_del_init(&work->node);
194 drm_vblank_put(vblank->dev, vblank->pipe);
195 ret = true;
196 }
197
198 work->cancelling++;
199 spin_unlock_irq(&dev->event_lock);
200
201 wake_up_all(&vblank->work_wait_queue);
202
203 if (kthread_cancel_work_sync(&work->base))
204 ret = true;
205
206 spin_lock_irq(&dev->event_lock);
207 work->cancelling--;
208 spin_unlock_irq(&dev->event_lock);
209
210 return ret;
211 }
212 EXPORT_SYMBOL(drm_vblank_work_cancel_sync);
213
214 /**
215 * drm_vblank_work_flush - wait for a scheduled vblank work to finish
216 * executing
217 * @work: vblank work to flush
218 *
219 * Wait until @work has finished executing once.
220 */
drm_vblank_work_flush(struct drm_vblank_work * work)221 void drm_vblank_work_flush(struct drm_vblank_work *work)
222 {
223 struct drm_vblank_crtc *vblank = work->vblank;
224 struct drm_device *dev = vblank->dev;
225
226 spin_lock_irq(&dev->event_lock);
227 wait_event_lock_irq(vblank->work_wait_queue, list_empty(&work->node),
228 dev->event_lock);
229 spin_unlock_irq(&dev->event_lock);
230
231 kthread_flush_work(&work->base);
232 }
233 EXPORT_SYMBOL(drm_vblank_work_flush);
234
235 /**
236 * drm_vblank_work_flush_all - flush all currently pending vblank work on crtc.
237 * @crtc: crtc for which vblank work to flush
238 *
239 * Wait until all currently queued vblank work on @crtc
240 * has finished executing once.
241 */
drm_vblank_work_flush_all(struct drm_crtc * crtc)242 void drm_vblank_work_flush_all(struct drm_crtc *crtc)
243 {
244 struct drm_device *dev = crtc->dev;
245 struct drm_vblank_crtc *vblank = &dev->vblank[drm_crtc_index(crtc)];
246
247 spin_lock_irq(&dev->event_lock);
248 wait_event_lock_irq(vblank->work_wait_queue,
249 list_empty(&vblank->pending_work),
250 dev->event_lock);
251 spin_unlock_irq(&dev->event_lock);
252
253 kthread_flush_worker(vblank->worker);
254 }
255 EXPORT_SYMBOL(drm_vblank_work_flush_all);
256
257 /**
258 * drm_vblank_work_init - initialize a vblank work item
259 * @work: vblank work item
260 * @crtc: CRTC whose vblank will trigger the work execution
261 * @func: work function to be executed
262 *
263 * Initialize a vblank work item for a specific crtc.
264 */
drm_vblank_work_init(struct drm_vblank_work * work,struct drm_crtc * crtc,void (* func)(struct kthread_work * work))265 void drm_vblank_work_init(struct drm_vblank_work *work, struct drm_crtc *crtc,
266 void (*func)(struct kthread_work *work))
267 {
268 kthread_init_work(&work->base, func);
269 INIT_LIST_HEAD(&work->node);
270 work->vblank = drm_crtc_vblank_crtc(crtc);
271 }
272 EXPORT_SYMBOL(drm_vblank_work_init);
273
drm_vblank_worker_init(struct drm_vblank_crtc * vblank)274 int drm_vblank_worker_init(struct drm_vblank_crtc *vblank)
275 {
276 struct kthread_worker *worker;
277
278 INIT_LIST_HEAD(&vblank->pending_work);
279 init_waitqueue_head(&vblank->work_wait_queue);
280 worker = kthread_create_worker(0, "card%d-crtc%d",
281 vblank->dev->primary->index,
282 vblank->pipe);
283 if (IS_ERR(worker))
284 return PTR_ERR(worker);
285
286 vblank->worker = worker;
287
288 sched_set_fifo(worker->task);
289 return 0;
290 }
291