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 
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  */
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 	list_for_each_entry_safe(work, next, &vblank->pending_work, node) {
77 		list_del_init(&work->node);
78 		drm_vblank_put(vblank->dev, vblank->pipe);
79 	}
80 
81 	wake_up_all(&vblank->work_wait_queue);
82 }
83 
84 /**
85  * drm_vblank_work_schedule - schedule a vblank work
86  * @work: vblank work to schedule
87  * @count: target vblank count
88  * @nextonmiss: defer until the next vblank if target vblank was missed
89  *
90  * Schedule @work for execution once the crtc vblank count reaches @count.
91  *
92  * If the crtc vblank count has already reached @count and @nextonmiss is
93  * %false the work starts to execute immediately.
94  *
95  * If the crtc vblank count has already reached @count and @nextonmiss is
96  * %true the work is deferred until the next vblank (as if @count has been
97  * specified as crtc vblank count + 1).
98  *
99  * If @work is already scheduled, this function will reschedule said work
100  * using the new @count. This can be used for self-rearming work items.
101  *
102  * Returns:
103  * %1 if @work was successfully (re)scheduled, %0 if it was either already
104  * scheduled or cancelled, or a negative error code on failure.
105  */
106 int drm_vblank_work_schedule(struct drm_vblank_work *work,
107 			     u64 count, bool nextonmiss)
108 {
109 	struct drm_vblank_crtc *vblank = work->vblank;
110 	struct drm_device *dev = vblank->dev;
111 	u64 cur_vbl;
112 	unsigned long irqflags;
113 	bool passed, inmodeset, rescheduling = false, wake = false;
114 	int ret = 0;
115 
116 	spin_lock_irqsave(&dev->event_lock, irqflags);
117 	if (work->cancelling)
118 		goto out;
119 
120 	spin_lock(&dev->vbl_lock);
121 	inmodeset = vblank->inmodeset;
122 	spin_unlock(&dev->vbl_lock);
123 	if (inmodeset)
124 		goto out;
125 
126 	if (list_empty(&work->node)) {
127 		ret = drm_vblank_get(dev, vblank->pipe);
128 		if (ret < 0)
129 			goto out;
130 	} else if (work->count == count) {
131 		/* Already scheduled w/ same vbl count */
132 		goto out;
133 	} else {
134 		rescheduling = true;
135 	}
136 
137 	work->count = count;
138 	cur_vbl = drm_vblank_count(dev, vblank->pipe);
139 	passed = drm_vblank_passed(cur_vbl, count);
140 	if (passed)
141 		drm_dbg_core(dev,
142 			     "crtc %d vblank %llu already passed (current %llu)\n",
143 			     vblank->pipe, count, cur_vbl);
144 
145 	if (!nextonmiss && passed) {
146 		drm_vblank_put(dev, vblank->pipe);
147 		ret = kthread_queue_work(vblank->worker, &work->base);
148 
149 		if (rescheduling) {
150 			list_del_init(&work->node);
151 			wake = true;
152 		}
153 	} else {
154 		if (!rescheduling)
155 			list_add_tail(&work->node, &vblank->pending_work);
156 		ret = true;
157 	}
158 
159 out:
160 	spin_unlock_irqrestore(&dev->event_lock, irqflags);
161 	if (wake)
162 		wake_up_all(&vblank->work_wait_queue);
163 	return ret;
164 }
165 EXPORT_SYMBOL(drm_vblank_work_schedule);
166 
167 /**
168  * drm_vblank_work_cancel_sync - cancel a vblank work and wait for it to
169  * finish executing
170  * @work: vblank work to cancel
171  *
172  * Cancel an already scheduled vblank work and wait for its
173  * execution to finish.
174  *
175  * On return, @work is guaranteed to no longer be scheduled or running, even
176  * if it's self-arming.
177  *
178  * Returns:
179  * %True if the work was cancelled before it started to execute, %false
180  * otherwise.
181  */
182 bool drm_vblank_work_cancel_sync(struct drm_vblank_work *work)
183 {
184 	struct drm_vblank_crtc *vblank = work->vblank;
185 	struct drm_device *dev = vblank->dev;
186 	bool ret = false;
187 
188 	spin_lock_irq(&dev->event_lock);
189 	if (!list_empty(&work->node)) {
190 		list_del_init(&work->node);
191 		drm_vblank_put(vblank->dev, vblank->pipe);
192 		ret = true;
193 	}
194 
195 	work->cancelling++;
196 	spin_unlock_irq(&dev->event_lock);
197 
198 	wake_up_all(&vblank->work_wait_queue);
199 
200 	if (kthread_cancel_work_sync(&work->base))
201 		ret = true;
202 
203 	spin_lock_irq(&dev->event_lock);
204 	work->cancelling--;
205 	spin_unlock_irq(&dev->event_lock);
206 
207 	return ret;
208 }
209 EXPORT_SYMBOL(drm_vblank_work_cancel_sync);
210 
211 /**
212  * drm_vblank_work_flush - wait for a scheduled vblank work to finish
213  * executing
214  * @work: vblank work to flush
215  *
216  * Wait until @work has finished executing once.
217  */
218 void drm_vblank_work_flush(struct drm_vblank_work *work)
219 {
220 	struct drm_vblank_crtc *vblank = work->vblank;
221 	struct drm_device *dev = vblank->dev;
222 
223 	spin_lock_irq(&dev->event_lock);
224 	wait_event_lock_irq(vblank->work_wait_queue, list_empty(&work->node),
225 			    dev->event_lock);
226 	spin_unlock_irq(&dev->event_lock);
227 
228 	kthread_flush_work(&work->base);
229 }
230 EXPORT_SYMBOL(drm_vblank_work_flush);
231 
232 /**
233  * drm_vblank_work_init - initialize a vblank work item
234  * @work: vblank work item
235  * @crtc: CRTC whose vblank will trigger the work execution
236  * @func: work function to be executed
237  *
238  * Initialize a vblank work item for a specific crtc.
239  */
240 void drm_vblank_work_init(struct drm_vblank_work *work, struct drm_crtc *crtc,
241 			  void (*func)(struct kthread_work *work))
242 {
243 	kthread_init_work(&work->base, func);
244 	INIT_LIST_HEAD(&work->node);
245 	work->vblank = &crtc->dev->vblank[drm_crtc_index(crtc)];
246 }
247 EXPORT_SYMBOL(drm_vblank_work_init);
248 
249 int drm_vblank_worker_init(struct drm_vblank_crtc *vblank)
250 {
251 	struct kthread_worker *worker;
252 
253 	INIT_LIST_HEAD(&vblank->pending_work);
254 	init_waitqueue_head(&vblank->work_wait_queue);
255 	worker = kthread_create_worker(0, "card%d-crtc%d",
256 				       vblank->dev->primary->index,
257 				       vblank->pipe);
258 	if (IS_ERR(worker))
259 		return PTR_ERR(worker);
260 
261 	vblank->worker = worker;
262 
263 	sched_set_fifo(worker->task);
264 	return 0;
265 }
266