1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "msm_drv.h"
19#include "msm_kms.h"
20#include "msm_gem.h"
21
22struct msm_commit {
23 struct drm_device *dev;
24 struct drm_atomic_state *state;
25 uint32_t fence;
26 struct msm_fence_cb fence_cb;
27 uint32_t crtc_mask;
28};
29
30static void fence_cb(struct msm_fence_cb *cb);
31
32
33
34
35static int start_atomic(struct msm_drm_private *priv, uint32_t crtc_mask)
36{
37 int ret;
38
39 spin_lock(&priv->pending_crtcs_event.lock);
40 ret = wait_event_interruptible_locked(priv->pending_crtcs_event,
41 !(priv->pending_crtcs & crtc_mask));
42 if (ret == 0) {
43 DBG("start: %08x", crtc_mask);
44 priv->pending_crtcs |= crtc_mask;
45 }
46 spin_unlock(&priv->pending_crtcs_event.lock);
47
48 return ret;
49}
50
51
52
53static void end_atomic(struct msm_drm_private *priv, uint32_t crtc_mask)
54{
55 spin_lock(&priv->pending_crtcs_event.lock);
56 DBG("end: %08x", crtc_mask);
57 priv->pending_crtcs &= ~crtc_mask;
58 wake_up_all_locked(&priv->pending_crtcs_event);
59 spin_unlock(&priv->pending_crtcs_event.lock);
60}
61
62static struct msm_commit *commit_init(struct drm_atomic_state *state)
63{
64 struct msm_commit *c = kzalloc(sizeof(*c), GFP_KERNEL);
65
66 if (!c)
67 return NULL;
68
69 c->dev = state->dev;
70 c->state = state;
71
72
73
74
75
76 INIT_FENCE_CB(&c->fence_cb, fence_cb);
77
78 return c;
79}
80
81static void commit_destroy(struct msm_commit *c)
82{
83 end_atomic(c->dev->dev_private, c->crtc_mask);
84 kfree(c);
85}
86
87static void msm_atomic_wait_for_commit_done(struct drm_device *dev,
88 struct drm_atomic_state *old_state)
89{
90 struct drm_crtc *crtc;
91 struct msm_drm_private *priv = old_state->dev->dev_private;
92 struct msm_kms *kms = priv->kms;
93 int ncrtcs = old_state->dev->mode_config.num_crtc;
94 int i;
95
96 for (i = 0; i < ncrtcs; i++) {
97 crtc = old_state->crtcs[i];
98
99 if (!crtc)
100 continue;
101
102 if (!crtc->state->enable)
103 continue;
104
105
106
107 if (old_state->legacy_cursor_update)
108 continue;
109
110 kms->funcs->wait_for_crtc_commit_done(kms, crtc);
111 }
112}
113
114
115
116
117static void complete_commit(struct msm_commit *c)
118{
119 struct drm_atomic_state *state = c->state;
120 struct drm_device *dev = state->dev;
121 struct msm_drm_private *priv = dev->dev_private;
122 struct msm_kms *kms = priv->kms;
123
124 kms->funcs->prepare_commit(kms, state);
125
126 drm_atomic_helper_commit_modeset_disables(dev, state);
127
128 drm_atomic_helper_commit_planes(dev, state, false);
129
130 drm_atomic_helper_commit_modeset_enables(dev, state);
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145 msm_atomic_wait_for_commit_done(dev, state);
146
147 drm_atomic_helper_cleanup_planes(dev, state);
148
149 kms->funcs->complete_commit(kms, state);
150
151 drm_atomic_state_free(state);
152
153 commit_destroy(c);
154}
155
156static void fence_cb(struct msm_fence_cb *cb)
157{
158 struct msm_commit *c =
159 container_of(cb, struct msm_commit, fence_cb);
160 complete_commit(c);
161}
162
163static void add_fb(struct msm_commit *c, struct drm_framebuffer *fb)
164{
165 struct drm_gem_object *obj = msm_framebuffer_bo(fb, 0);
166 c->fence = max(c->fence, msm_gem_fence(to_msm_bo(obj), MSM_PREP_READ));
167}
168
169int msm_atomic_check(struct drm_device *dev,
170 struct drm_atomic_state *state)
171{
172 int ret;
173
174
175
176
177
178 ret = drm_atomic_helper_check_planes(dev, state);
179 if (ret)
180 return ret;
181
182 ret = drm_atomic_helper_check_modeset(dev, state);
183 if (ret)
184 return ret;
185
186 return ret;
187}
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202int msm_atomic_commit(struct drm_device *dev,
203 struct drm_atomic_state *state, bool async)
204{
205 int nplanes = dev->mode_config.num_total_plane;
206 int ncrtcs = dev->mode_config.num_crtc;
207 ktime_t timeout;
208 struct msm_commit *c;
209 int i, ret;
210
211 ret = drm_atomic_helper_prepare_planes(dev, state);
212 if (ret)
213 return ret;
214
215 c = commit_init(state);
216 if (!c) {
217 ret = -ENOMEM;
218 goto error;
219 }
220
221
222
223
224 for (i = 0; i < ncrtcs; i++) {
225 struct drm_crtc *crtc = state->crtcs[i];
226 if (!crtc)
227 continue;
228 c->crtc_mask |= (1 << drm_crtc_index(crtc));
229 }
230
231
232
233
234 for (i = 0; i < nplanes; i++) {
235 struct drm_plane *plane = state->planes[i];
236 struct drm_plane_state *new_state = state->plane_states[i];
237
238 if (!plane)
239 continue;
240
241 if ((plane->state->fb != new_state->fb) && new_state->fb)
242 add_fb(c, new_state->fb);
243 }
244
245
246
247
248
249 ret = start_atomic(dev->dev_private, c->crtc_mask);
250 if (ret) {
251 kfree(c);
252 goto error;
253 }
254
255
256
257
258
259
260
261 drm_atomic_helper_swap_state(dev, state);
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279 if (async) {
280 msm_queue_fence_cb(dev, &c->fence_cb, c->fence);
281 return 0;
282 }
283
284 timeout = ktime_add_ms(ktime_get(), 1000);
285
286
287 msm_wait_fence(dev, c->fence, &timeout, false);
288
289 complete_commit(c);
290
291 return 0;
292
293error:
294 drm_atomic_helper_cleanup_planes(dev, state);
295 return ret;
296}
297