blob: 1d2ca52530d5f3148fec55d72d22c79f2eaa8949 [file] [log] [blame]
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001/*
2 * Copyright (C) 2014 Red Hat
3 * Copyright (C) 2014 Intel Corp.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Rob Clark <robdclark@gmail.com>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
26 */
27
28#include <drm/drmP.h>
29#include <drm/drm_atomic.h>
30#include <drm/drm_plane_helper.h>
31#include <drm/drm_crtc_helper.h>
Daniel Vetter623369e2014-09-16 17:50:47 +020032#include <drm/drm_atomic_helper.h>
Daniel Vettere2330f02014-10-29 11:34:56 +010033#include <linux/fence.h>
Daniel Vetterc2fcd272014-11-05 00:14:14 +010034
Daniel Vetter3150c7d2014-11-06 20:53:29 +010035/**
36 * DOC: overview
37 *
38 * This helper library provides implementations of check and commit functions on
39 * top of the CRTC modeset helper callbacks and the plane helper callbacks. It
40 * also provides convenience implementations for the atomic state handling
41 * callbacks for drivers which don't need to subclass the drm core structures to
42 * add their own additional internal state.
43 *
44 * This library also provides default implementations for the check callback in
45 * drm_atomic_helper_check and for the commit callback with
46 * drm_atomic_helper_commit. But the individual stages and callbacks are expose
47 * to allow drivers to mix and match and e.g. use the plane helpers only
48 * together with a driver private modeset implementation.
49 *
50 * This library also provides implementations for all the legacy driver
51 * interfaces on top of the atomic interface. See drm_atomic_helper_set_config,
52 * drm_atomic_helper_disable_plane, drm_atomic_helper_disable_plane and the
53 * various functions to implement set_property callbacks. New drivers must not
54 * implement these functions themselves but must use the provided helpers.
55 */
Daniel Vetterc2fcd272014-11-05 00:14:14 +010056static void
57drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
58 struct drm_plane_state *plane_state,
59 struct drm_plane *plane)
60{
61 struct drm_crtc_state *crtc_state;
62
63 if (plane->state->crtc) {
Rob Clark4b08eae2014-12-08 10:45:43 -050064 crtc_state = state->crtc_states[drm_crtc_index(plane->state->crtc)];
Daniel Vetterc2fcd272014-11-05 00:14:14 +010065
66 if (WARN_ON(!crtc_state))
67 return;
68
69 crtc_state->planes_changed = true;
70 }
71
72 if (plane_state->crtc) {
73 crtc_state =
74 state->crtc_states[drm_crtc_index(plane_state->crtc)];
75
76 if (WARN_ON(!crtc_state))
77 return;
78
79 crtc_state->planes_changed = true;
80 }
81}
82
Daniel Vetter623369e2014-09-16 17:50:47 +020083static struct drm_crtc *
84get_current_crtc_for_encoder(struct drm_device *dev,
85 struct drm_encoder *encoder)
86{
87 struct drm_mode_config *config = &dev->mode_config;
88 struct drm_connector *connector;
89
90 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
91
92 list_for_each_entry(connector, &config->connector_list, head) {
93 if (connector->state->best_encoder != encoder)
94 continue;
95
96 return connector->state->crtc;
97 }
98
99 return NULL;
100}
101
102static int
103steal_encoder(struct drm_atomic_state *state,
104 struct drm_encoder *encoder,
105 struct drm_crtc *encoder_crtc)
106{
107 struct drm_mode_config *config = &state->dev->mode_config;
108 struct drm_crtc_state *crtc_state;
109 struct drm_connector *connector;
110 struct drm_connector_state *connector_state;
Daniel Vetter042652e2014-07-27 13:46:52 +0200111 int ret;
Daniel Vetter623369e2014-09-16 17:50:47 +0200112
113 /*
114 * We can only steal an encoder coming from a connector, which means we
115 * must already hold the connection_mutex.
116 */
117 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
118
Daniel Vetter17a38d92015-02-22 12:24:16 +0100119 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d], stealing it\n",
120 encoder->base.id, encoder->name,
121 encoder_crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200122
123 crtc_state = drm_atomic_get_crtc_state(state, encoder_crtc);
124 if (IS_ERR(crtc_state))
125 return PTR_ERR(crtc_state);
126
127 crtc_state->mode_changed = true;
128
129 list_for_each_entry(connector, &config->connector_list, head) {
130 if (connector->state->best_encoder != encoder)
131 continue;
132
Daniel Vetter17a38d92015-02-22 12:24:16 +0100133 DRM_DEBUG_ATOMIC("Stealing encoder from [CONNECTOR:%d:%s]\n",
134 connector->base.id,
135 connector->name);
Daniel Vetter623369e2014-09-16 17:50:47 +0200136
137 connector_state = drm_atomic_get_connector_state(state,
138 connector);
139 if (IS_ERR(connector_state))
140 return PTR_ERR(connector_state);
141
Daniel Vetter042652e2014-07-27 13:46:52 +0200142 ret = drm_atomic_set_crtc_for_connector(connector_state, NULL);
143 if (ret)
144 return ret;
Daniel Vetter623369e2014-09-16 17:50:47 +0200145 connector_state->best_encoder = NULL;
146 }
147
148 return 0;
149}
150
151static int
152update_connector_routing(struct drm_atomic_state *state, int conn_idx)
153{
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200154 const struct drm_connector_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200155 struct drm_encoder *new_encoder;
156 struct drm_crtc *encoder_crtc;
157 struct drm_connector *connector;
158 struct drm_connector_state *connector_state;
159 struct drm_crtc_state *crtc_state;
160 int idx, ret;
161
162 connector = state->connectors[conn_idx];
163 connector_state = state->connector_states[conn_idx];
164
165 if (!connector)
166 return 0;
167
Daniel Vetter17a38d92015-02-22 12:24:16 +0100168 DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n",
169 connector->base.id,
170 connector->name);
Daniel Vetter623369e2014-09-16 17:50:47 +0200171
172 if (connector->state->crtc != connector_state->crtc) {
173 if (connector->state->crtc) {
174 idx = drm_crtc_index(connector->state->crtc);
175
176 crtc_state = state->crtc_states[idx];
177 crtc_state->mode_changed = true;
178 }
179
180 if (connector_state->crtc) {
181 idx = drm_crtc_index(connector_state->crtc);
182
183 crtc_state = state->crtc_states[idx];
184 crtc_state->mode_changed = true;
185 }
186 }
187
188 if (!connector_state->crtc) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100189 DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n",
Daniel Vetter623369e2014-09-16 17:50:47 +0200190 connector->base.id,
191 connector->name);
192
193 connector_state->best_encoder = NULL;
194
195 return 0;
196 }
197
198 funcs = connector->helper_private;
199 new_encoder = funcs->best_encoder(connector);
200
201 if (!new_encoder) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100202 DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n",
203 connector->base.id,
204 connector->name);
Daniel Vetter623369e2014-09-16 17:50:47 +0200205 return -EINVAL;
206 }
207
208 if (new_encoder == connector_state->best_encoder) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100209 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d]\n",
210 connector->base.id,
211 connector->name,
212 new_encoder->base.id,
213 new_encoder->name,
214 connector_state->crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200215
216 return 0;
217 }
218
219 encoder_crtc = get_current_crtc_for_encoder(state->dev,
220 new_encoder);
221
222 if (encoder_crtc) {
223 ret = steal_encoder(state, new_encoder, encoder_crtc);
224 if (ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100225 DRM_DEBUG_ATOMIC("Encoder stealing failed for [CONNECTOR:%d:%s]\n",
226 connector->base.id,
227 connector->name);
Daniel Vetter623369e2014-09-16 17:50:47 +0200228 return ret;
229 }
230 }
231
232 connector_state->best_encoder = new_encoder;
233 idx = drm_crtc_index(connector_state->crtc);
234
235 crtc_state = state->crtc_states[idx];
236 crtc_state->mode_changed = true;
237
Daniel Vetter17a38d92015-02-22 12:24:16 +0100238 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d]\n",
239 connector->base.id,
240 connector->name,
241 new_encoder->base.id,
242 new_encoder->name,
243 connector_state->crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200244
245 return 0;
246}
247
248static int
249mode_fixup(struct drm_atomic_state *state)
250{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300251 struct drm_crtc *crtc;
Daniel Vetter623369e2014-09-16 17:50:47 +0200252 struct drm_crtc_state *crtc_state;
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300253 struct drm_connector *connector;
Daniel Vetter623369e2014-09-16 17:50:47 +0200254 struct drm_connector_state *conn_state;
255 int i;
256 bool ret;
257
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300258 for_each_crtc_in_state(state, crtc, crtc_state, i) {
259 if (!crtc_state->mode_changed)
Daniel Vetter623369e2014-09-16 17:50:47 +0200260 continue;
261
262 drm_mode_copy(&crtc_state->adjusted_mode, &crtc_state->mode);
263 }
264
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300265 for_each_connector_in_state(state, connector, conn_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200266 const struct drm_encoder_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200267 struct drm_encoder *encoder;
268
Daniel Vetter623369e2014-09-16 17:50:47 +0200269 WARN_ON(!!conn_state->best_encoder != !!conn_state->crtc);
270
271 if (!conn_state->crtc || !conn_state->best_encoder)
272 continue;
273
274 crtc_state =
275 state->crtc_states[drm_crtc_index(conn_state->crtc)];
276
277 /*
278 * Each encoder has at most one connector (since we always steal
279 * it away), so we won't call ->mode_fixup twice.
280 */
281 encoder = conn_state->best_encoder;
282 funcs = encoder->helper_private;
283
284 if (encoder->bridge && encoder->bridge->funcs->mode_fixup) {
285 ret = encoder->bridge->funcs->mode_fixup(
286 encoder->bridge, &crtc_state->mode,
287 &crtc_state->adjusted_mode);
288 if (!ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100289 DRM_DEBUG_ATOMIC("Bridge fixup failed\n");
Daniel Vetter623369e2014-09-16 17:50:47 +0200290 return -EINVAL;
291 }
292 }
293
Thierry Reding4cd4df82014-12-03 16:44:34 +0100294 if (funcs->atomic_check) {
295 ret = funcs->atomic_check(encoder, crtc_state,
296 conn_state);
297 if (ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100298 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n",
299 encoder->base.id, encoder->name);
Thierry Reding4cd4df82014-12-03 16:44:34 +0100300 return ret;
301 }
302 } else {
303 ret = funcs->mode_fixup(encoder, &crtc_state->mode,
304 &crtc_state->adjusted_mode);
305 if (!ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100306 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n",
307 encoder->base.id, encoder->name);
Thierry Reding4cd4df82014-12-03 16:44:34 +0100308 return -EINVAL;
309 }
Daniel Vetter623369e2014-09-16 17:50:47 +0200310 }
311 }
312
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300313 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200314 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200315
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300316 if (!crtc_state->mode_changed)
Daniel Vetter623369e2014-09-16 17:50:47 +0200317 continue;
318
319 funcs = crtc->helper_private;
320 ret = funcs->mode_fixup(crtc, &crtc_state->mode,
321 &crtc_state->adjusted_mode);
322 if (!ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100323 DRM_DEBUG_ATOMIC("[CRTC:%d] fixup failed\n",
324 crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200325 return -EINVAL;
326 }
327 }
328
329 return 0;
330}
331
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100332static bool
333needs_modeset(struct drm_crtc_state *state)
334{
335 return state->mode_changed || state->active_changed;
336}
337
Daniel Vetterd9b13622014-11-26 16:57:41 +0100338/**
John Hunterf98bd3e2015-03-17 15:30:26 +0800339 * drm_atomic_helper_check_modeset - validate state object for modeset changes
Daniel Vetterd9b13622014-11-26 16:57:41 +0100340 * @dev: DRM device
341 * @state: the driver state object
342 *
343 * Check the state object to see if the requested state is physically possible.
344 * This does all the crtc and connector related computations for an atomic
345 * update. It computes and updates crtc_state->mode_changed, adds any additional
346 * connectors needed for full modesets and calls down into ->mode_fixup
347 * functions of the driver backend.
348 *
349 * IMPORTANT:
350 *
351 * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a
352 * plane update can't be done without a full modeset) _must_ call this function
353 * afterwards after that change. It is permitted to call this function multiple
354 * times for the same update, e.g. when the ->atomic_check functions depend upon
355 * the adjusted dotclock for fifo space allocation and watermark computation.
356 *
357 * RETURNS
358 * Zero for success or -errno
359 */
360int
Rob Clark934ce1c2014-11-19 16:41:33 -0500361drm_atomic_helper_check_modeset(struct drm_device *dev,
Daniel Vetter623369e2014-09-16 17:50:47 +0200362 struct drm_atomic_state *state)
363{
Daniel Vetter623369e2014-09-16 17:50:47 +0200364 struct drm_crtc *crtc;
365 struct drm_crtc_state *crtc_state;
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300366 struct drm_connector *connector;
367 struct drm_connector_state *connector_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200368 int i, ret;
369
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300370 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Daniel Vetter623369e2014-09-16 17:50:47 +0200371 if (!drm_mode_equal(&crtc->state->mode, &crtc_state->mode)) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100372 DRM_DEBUG_ATOMIC("[CRTC:%d] mode changed\n",
373 crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200374 crtc_state->mode_changed = true;
375 }
376
377 if (crtc->state->enable != crtc_state->enable) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100378 DRM_DEBUG_ATOMIC("[CRTC:%d] enable changed\n",
379 crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200380 crtc_state->mode_changed = true;
381 }
382 }
383
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300384 for_each_connector_in_state(state, connector, connector_state, i) {
Daniel Vetter623369e2014-09-16 17:50:47 +0200385 /*
386 * This only sets crtc->mode_changed for routing changes,
387 * drivers must set crtc->mode_changed themselves when connector
388 * properties need to be updated.
389 */
390 ret = update_connector_routing(state, i);
391 if (ret)
392 return ret;
393 }
394
395 /*
396 * After all the routing has been prepared we need to add in any
397 * connector which is itself unchanged, but who's crtc changes it's
398 * configuration. This must be done before calling mode_fixup in case a
399 * crtc only changed its mode but has the same set of connectors.
400 */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300401 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Daniel Vetter623369e2014-09-16 17:50:47 +0200402 int num_connectors;
403
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100404 /*
405 * We must set ->active_changed after walking connectors for
406 * otherwise an update that only changes active would result in
407 * a full modeset because update_connector_routing force that.
408 */
409 if (crtc->state->active != crtc_state->active) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100410 DRM_DEBUG_ATOMIC("[CRTC:%d] active changed\n",
411 crtc->base.id);
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100412 crtc_state->active_changed = true;
413 }
414
415 if (!needs_modeset(crtc_state))
416 continue;
417
Daniel Vetter17a38d92015-02-22 12:24:16 +0100418 DRM_DEBUG_ATOMIC("[CRTC:%d] needs all connectors, enable: %c, active: %c\n",
419 crtc->base.id,
420 crtc_state->enable ? 'y' : 'n',
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100421 crtc_state->active ? 'y' : 'n');
Daniel Vetter623369e2014-09-16 17:50:47 +0200422
423 ret = drm_atomic_add_affected_connectors(state, crtc);
424 if (ret != 0)
425 return ret;
426
427 num_connectors = drm_atomic_connectors_for_crtc(state,
428 crtc);
429
430 if (crtc_state->enable != !!num_connectors) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100431 DRM_DEBUG_ATOMIC("[CRTC:%d] enabled/connectors mismatch\n",
432 crtc->base.id);
Daniel Vetter623369e2014-09-16 17:50:47 +0200433
434 return -EINVAL;
435 }
436 }
437
438 return mode_fixup(state);
439}
Daniel Vetterd9b13622014-11-26 16:57:41 +0100440EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
Daniel Vetter623369e2014-09-16 17:50:47 +0200441
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100442/**
John Hunterf98bd3e2015-03-17 15:30:26 +0800443 * drm_atomic_helper_check_planes - validate state object for planes changes
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100444 * @dev: DRM device
445 * @state: the driver state object
446 *
447 * Check the state object to see if the requested state is physically possible.
Daniel Vetterd9b13622014-11-26 16:57:41 +0100448 * This does all the plane update related checks using by calling into the
449 * ->atomic_check hooks provided by the driver.
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100450 *
451 * RETURNS
452 * Zero for success or -errno
453 */
Daniel Vetterd9b13622014-11-26 16:57:41 +0100454int
455drm_atomic_helper_check_planes(struct drm_device *dev,
456 struct drm_atomic_state *state)
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100457{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300458 struct drm_crtc *crtc;
459 struct drm_crtc_state *crtc_state;
460 struct drm_plane *plane;
461 struct drm_plane_state *plane_state;
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100462 int i, ret = 0;
463
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300464 for_each_plane_in_state(state, plane, plane_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200465 const struct drm_plane_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100466
467 funcs = plane->helper_private;
468
469 drm_atomic_helper_plane_changed(state, plane_state, plane);
470
471 if (!funcs || !funcs->atomic_check)
472 continue;
473
474 ret = funcs->atomic_check(plane, plane_state);
475 if (ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100476 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic driver check failed\n",
477 plane->base.id);
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100478 return ret;
479 }
480 }
481
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300482 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200483 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100484
485 funcs = crtc->helper_private;
486
487 if (!funcs || !funcs->atomic_check)
488 continue;
489
490 ret = funcs->atomic_check(crtc, state->crtc_states[i]);
491 if (ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100492 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic driver check failed\n",
493 crtc->base.id);
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100494 return ret;
495 }
496 }
497
Daniel Vetterd9b13622014-11-26 16:57:41 +0100498 return ret;
499}
500EXPORT_SYMBOL(drm_atomic_helper_check_planes);
501
502/**
503 * drm_atomic_helper_check - validate state object
504 * @dev: DRM device
505 * @state: the driver state object
506 *
507 * Check the state object to see if the requested state is physically possible.
508 * Only crtcs and planes have check callbacks, so for any additional (global)
509 * checking that a driver needs it can simply wrap that around this function.
510 * Drivers without such needs can directly use this as their ->atomic_check()
511 * callback.
512 *
Daniel Vetterb4274fb2014-11-26 17:02:18 +0100513 * This just wraps the two parts of the state checking for planes and modeset
514 * state in the default order: First it calls drm_atomic_helper_check_modeset()
515 * and then drm_atomic_helper_check_planes(). The assumption is that the
516 * ->atomic_check functions depend upon an updated adjusted_mode.clock to
517 * e.g. properly compute watermarks.
518 *
Daniel Vetterd9b13622014-11-26 16:57:41 +0100519 * RETURNS
520 * Zero for success or -errno
521 */
522int drm_atomic_helper_check(struct drm_device *dev,
523 struct drm_atomic_state *state)
524{
525 int ret;
526
Daniel Vetterb4274fb2014-11-26 17:02:18 +0100527 ret = drm_atomic_helper_check_modeset(dev, state);
Daniel Vetterd9b13622014-11-26 16:57:41 +0100528 if (ret)
529 return ret;
530
Daniel Vetterb4274fb2014-11-26 17:02:18 +0100531 ret = drm_atomic_helper_check_planes(dev, state);
Rob Clark934ce1c2014-11-19 16:41:33 -0500532 if (ret)
533 return ret;
534
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100535 return ret;
536}
537EXPORT_SYMBOL(drm_atomic_helper_check);
538
Daniel Vetter623369e2014-09-16 17:50:47 +0200539static void
540disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
541{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300542 struct drm_connector *connector;
543 struct drm_connector_state *old_conn_state;
544 struct drm_crtc *crtc;
545 struct drm_crtc_state *old_crtc_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200546 int i;
547
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300548 for_each_connector_in_state(old_state, connector, old_conn_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200549 const struct drm_encoder_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200550 struct drm_encoder *encoder;
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100551 struct drm_crtc_state *old_crtc_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200552
Daniel Vetter623369e2014-09-16 17:50:47 +0200553 /* Shut down everything that's in the changeset and currently
554 * still on. So need to check the old, saved state. */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300555 if (!old_conn_state->crtc)
Daniel Vetter623369e2014-09-16 17:50:47 +0200556 continue;
557
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100558 old_crtc_state = old_state->crtc_states[drm_crtc_index(old_conn_state->crtc)];
559
Daniel Vetter4218a322015-03-26 22:18:40 +0100560 if (!old_crtc_state->active ||
561 !needs_modeset(old_conn_state->crtc->state))
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100562 continue;
563
Rob Clark46df9ad2014-11-20 15:40:36 -0500564 encoder = old_conn_state->best_encoder;
Daniel Vetter623369e2014-09-16 17:50:47 +0200565
Rob Clark46df9ad2014-11-20 15:40:36 -0500566 /* We shouldn't get this far if we didn't previously have
567 * an encoder.. but WARN_ON() rather than explode.
568 */
569 if (WARN_ON(!encoder))
Daniel Vetter623369e2014-09-16 17:50:47 +0200570 continue;
571
572 funcs = encoder->helper_private;
573
Daniel Vetter17a38d92015-02-22 12:24:16 +0100574 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
575 encoder->base.id, encoder->name);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100576
Daniel Vetter623369e2014-09-16 17:50:47 +0200577 /*
578 * Each encoder has at most one connector (since we always steal
John Hunterf98bd3e2015-03-17 15:30:26 +0800579 * it away), so we won't call disable hooks twice.
Daniel Vetter623369e2014-09-16 17:50:47 +0200580 */
581 if (encoder->bridge)
582 encoder->bridge->funcs->disable(encoder->bridge);
583
584 /* Right function depends upon target state. */
Daniel Vetteree0a89c2015-01-22 16:36:24 +0100585 if (connector->state->crtc && funcs->prepare)
Daniel Vetter623369e2014-09-16 17:50:47 +0200586 funcs->prepare(encoder);
587 else if (funcs->disable)
588 funcs->disable(encoder);
589 else
590 funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
591
592 if (encoder->bridge)
593 encoder->bridge->funcs->post_disable(encoder->bridge);
594 }
595
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300596 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200597 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200598
599 /* Shut down everything that needs a full modeset. */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300600 if (!needs_modeset(crtc->state))
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100601 continue;
602
603 if (!old_crtc_state->active)
Daniel Vetter623369e2014-09-16 17:50:47 +0200604 continue;
605
606 funcs = crtc->helper_private;
607
Daniel Vetter17a38d92015-02-22 12:24:16 +0100608 DRM_DEBUG_ATOMIC("disabling [CRTC:%d]\n",
609 crtc->base.id);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100610
611
Daniel Vetter623369e2014-09-16 17:50:47 +0200612 /* Right function depends upon target state. */
Daniel Vetteree0a89c2015-01-22 16:36:24 +0100613 if (crtc->state->enable && funcs->prepare)
Daniel Vetter623369e2014-09-16 17:50:47 +0200614 funcs->prepare(crtc);
615 else if (funcs->disable)
616 funcs->disable(crtc);
617 else
618 funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
619 }
620}
621
622static void
623set_routing_links(struct drm_device *dev, struct drm_atomic_state *old_state)
624{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300625 struct drm_connector *connector;
626 struct drm_connector_state *old_conn_state;
627 struct drm_crtc *crtc;
628 struct drm_crtc_state *old_crtc_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200629 int i;
630
631 /* clear out existing links */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300632 for_each_connector_in_state(old_state, connector, old_conn_state, i) {
633 if (!connector->encoder)
Daniel Vetter623369e2014-09-16 17:50:47 +0200634 continue;
635
636 WARN_ON(!connector->encoder->crtc);
637
638 connector->encoder->crtc = NULL;
639 connector->encoder = NULL;
640 }
641
642 /* set new links */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300643 for_each_connector_in_state(old_state, connector, old_conn_state, i) {
644 if (!connector->state->crtc)
Daniel Vetter623369e2014-09-16 17:50:47 +0200645 continue;
646
647 if (WARN_ON(!connector->state->best_encoder))
648 continue;
649
650 connector->encoder = connector->state->best_encoder;
651 connector->encoder->crtc = connector->state->crtc;
652 }
653
654 /* set legacy state in the crtc structure */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300655 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Daniel Vetter623369e2014-09-16 17:50:47 +0200656 crtc->mode = crtc->state->mode;
657 crtc->enabled = crtc->state->enable;
658 crtc->x = crtc->primary->state->src_x >> 16;
659 crtc->y = crtc->primary->state->src_y >> 16;
660 }
661}
662
663static void
664crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
665{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300666 struct drm_crtc *crtc;
667 struct drm_crtc_state *old_crtc_state;
668 struct drm_connector *connector;
669 struct drm_connector_state *old_conn_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200670 int i;
671
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300672 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200673 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200674
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300675 if (!crtc->state->mode_changed)
Daniel Vetter623369e2014-09-16 17:50:47 +0200676 continue;
677
678 funcs = crtc->helper_private;
679
Daniel Vetterc982bd92015-02-22 12:24:20 +0100680 if (crtc->state->enable && funcs->mode_set_nofb) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100681 DRM_DEBUG_ATOMIC("modeset on [CRTC:%d]\n",
682 crtc->base.id);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100683
Daniel Vetter623369e2014-09-16 17:50:47 +0200684 funcs->mode_set_nofb(crtc);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100685 }
Daniel Vetter623369e2014-09-16 17:50:47 +0200686 }
687
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300688 for_each_connector_in_state(old_state, connector, old_conn_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200689 const struct drm_encoder_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200690 struct drm_crtc_state *new_crtc_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200691 struct drm_encoder *encoder;
692 struct drm_display_mode *mode, *adjusted_mode;
693
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300694 if (!connector->state->best_encoder)
Daniel Vetter623369e2014-09-16 17:50:47 +0200695 continue;
696
697 encoder = connector->state->best_encoder;
698 funcs = encoder->helper_private;
699 new_crtc_state = connector->state->crtc->state;
700 mode = &new_crtc_state->mode;
701 adjusted_mode = &new_crtc_state->adjusted_mode;
702
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100703 if (!new_crtc_state->mode_changed)
704 continue;
705
Daniel Vetter17a38d92015-02-22 12:24:16 +0100706 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
707 encoder->base.id, encoder->name);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100708
Daniel Vetter623369e2014-09-16 17:50:47 +0200709 /*
710 * Each encoder has at most one connector (since we always steal
John Hunterf98bd3e2015-03-17 15:30:26 +0800711 * it away), so we won't call mode_set hooks twice.
Daniel Vetter623369e2014-09-16 17:50:47 +0200712 */
Daniel Vetterc982bd92015-02-22 12:24:20 +0100713 if (funcs->mode_set)
714 funcs->mode_set(encoder, mode, adjusted_mode);
Daniel Vetter623369e2014-09-16 17:50:47 +0200715
716 if (encoder->bridge && encoder->bridge->funcs->mode_set)
717 encoder->bridge->funcs->mode_set(encoder->bridge,
718 mode, adjusted_mode);
719 }
720}
721
722/**
Daniel Vetter1af434a2015-02-22 12:24:19 +0100723 * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
Daniel Vetter623369e2014-09-16 17:50:47 +0200724 * @dev: DRM device
Laurent Pincharta072f802015-02-22 12:24:18 +0100725 * @old_state: atomic state object with old state structures
Daniel Vetter623369e2014-09-16 17:50:47 +0200726 *
Daniel Vetter1af434a2015-02-22 12:24:19 +0100727 * This function shuts down all the outputs that need to be shut down and
Daniel Vetter623369e2014-09-16 17:50:47 +0200728 * prepares them (if required) with the new mode.
Daniel Vetter1af434a2015-02-22 12:24:19 +0100729 *
730 * For compatability with legacy crtc helpers this should be called before
731 * drm_atomic_helper_commit_planes(), which is what the default commit function
732 * does. But drivers with different needs can group the modeset commits together
733 * and do the plane commits at the end. This is useful for drivers doing runtime
734 * PM since planes updates then only happen when the CRTC is actually enabled.
Daniel Vetter623369e2014-09-16 17:50:47 +0200735 */
Daniel Vetter1af434a2015-02-22 12:24:19 +0100736void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
737 struct drm_atomic_state *old_state)
Daniel Vetter623369e2014-09-16 17:50:47 +0200738{
Laurent Pincharta072f802015-02-22 12:24:18 +0100739 disable_outputs(dev, old_state);
740 set_routing_links(dev, old_state);
741 crtc_set_mode(dev, old_state);
Daniel Vetter623369e2014-09-16 17:50:47 +0200742}
Daniel Vetter1af434a2015-02-22 12:24:19 +0100743EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
Daniel Vetter623369e2014-09-16 17:50:47 +0200744
745/**
Daniel Vetter1af434a2015-02-22 12:24:19 +0100746 * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
Daniel Vetter623369e2014-09-16 17:50:47 +0200747 * @dev: DRM device
748 * @old_state: atomic state object with old state structures
749 *
Daniel Vetter1af434a2015-02-22 12:24:19 +0100750 * This function enables all the outputs with the new configuration which had to
751 * be turned off for the update.
752 *
753 * For compatability with legacy crtc helpers this should be called after
754 * drm_atomic_helper_commit_planes(), which is what the default commit function
755 * does. But drivers with different needs can group the modeset commits together
756 * and do the plane commits at the end. This is useful for drivers doing runtime
757 * PM since planes updates then only happen when the CRTC is actually enabled.
Daniel Vetter623369e2014-09-16 17:50:47 +0200758 */
Daniel Vetter1af434a2015-02-22 12:24:19 +0100759void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
760 struct drm_atomic_state *old_state)
Daniel Vetter623369e2014-09-16 17:50:47 +0200761{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300762 struct drm_crtc *crtc;
763 struct drm_crtc_state *old_crtc_state;
764 struct drm_connector *connector;
765 struct drm_connector_state *old_conn_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200766 int i;
767
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300768 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200769 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200770
771 /* Need to filter out CRTCs where only planes change. */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300772 if (!needs_modeset(crtc->state))
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100773 continue;
774
775 if (!crtc->state->active)
Daniel Vetter623369e2014-09-16 17:50:47 +0200776 continue;
777
778 funcs = crtc->helper_private;
779
Daniel Vetteree0a89c2015-01-22 16:36:24 +0100780 if (crtc->state->enable) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100781 DRM_DEBUG_ATOMIC("enabling [CRTC:%d]\n",
782 crtc->base.id);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100783
Daniel Vetteree0a89c2015-01-22 16:36:24 +0100784 if (funcs->enable)
785 funcs->enable(crtc);
786 else
787 funcs->commit(crtc);
788 }
Daniel Vetter623369e2014-09-16 17:50:47 +0200789 }
790
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300791 for_each_connector_in_state(old_state, connector, old_conn_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +0200792 const struct drm_encoder_helper_funcs *funcs;
Daniel Vetter623369e2014-09-16 17:50:47 +0200793 struct drm_encoder *encoder;
794
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300795 if (!connector->state->best_encoder)
Daniel Vetter623369e2014-09-16 17:50:47 +0200796 continue;
797
Daniel Vetter4218a322015-03-26 22:18:40 +0100798 if (!connector->state->crtc->state->active ||
799 !needs_modeset(connector->state->crtc->state))
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100800 continue;
801
Daniel Vetter623369e2014-09-16 17:50:47 +0200802 encoder = connector->state->best_encoder;
803 funcs = encoder->helper_private;
804
Daniel Vetter17a38d92015-02-22 12:24:16 +0100805 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
806 encoder->base.id, encoder->name);
Daniel Vetter95d6eb32015-01-22 16:36:25 +0100807
Daniel Vetter623369e2014-09-16 17:50:47 +0200808 /*
809 * Each encoder has at most one connector (since we always steal
John Hunterf98bd3e2015-03-17 15:30:26 +0800810 * it away), so we won't call enable hooks twice.
Daniel Vetter623369e2014-09-16 17:50:47 +0200811 */
812 if (encoder->bridge)
813 encoder->bridge->funcs->pre_enable(encoder->bridge);
814
Daniel Vetteree0a89c2015-01-22 16:36:24 +0100815 if (funcs->enable)
816 funcs->enable(encoder);
817 else
818 funcs->commit(encoder);
Daniel Vetter623369e2014-09-16 17:50:47 +0200819
820 if (encoder->bridge)
821 encoder->bridge->funcs->enable(encoder->bridge);
822 }
823}
Daniel Vetter1af434a2015-02-22 12:24:19 +0100824EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
Daniel Vetter623369e2014-09-16 17:50:47 +0200825
Daniel Vettere2330f02014-10-29 11:34:56 +0100826static void wait_for_fences(struct drm_device *dev,
827 struct drm_atomic_state *state)
828{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300829 struct drm_plane *plane;
830 struct drm_plane_state *plane_state;
Daniel Vettere2330f02014-10-29 11:34:56 +0100831 int i;
832
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300833 for_each_plane_in_state(state, plane, plane_state, i) {
834 if (!plane->state->fence)
Daniel Vettere2330f02014-10-29 11:34:56 +0100835 continue;
836
837 WARN_ON(!plane->state->fb);
838
839 fence_wait(plane->state->fence, false);
840 fence_put(plane->state->fence);
841 plane->state->fence = NULL;
842 }
843}
844
Daniel Vetterab58e332014-11-24 20:42:42 +0100845static bool framebuffer_changed(struct drm_device *dev,
846 struct drm_atomic_state *old_state,
847 struct drm_crtc *crtc)
848{
849 struct drm_plane *plane;
850 struct drm_plane_state *old_plane_state;
Daniel Vetterab58e332014-11-24 20:42:42 +0100851 int i;
852
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300853 for_each_plane_in_state(old_state, plane, old_plane_state, i) {
Daniel Vetterab58e332014-11-24 20:42:42 +0100854 if (plane->state->crtc != crtc &&
855 old_plane_state->crtc != crtc)
856 continue;
857
858 if (plane->state->fb != old_plane_state->fb)
859 return true;
860 }
861
862 return false;
863}
864
Rob Clark5ee32292014-11-11 19:38:59 -0500865/**
866 * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
867 * @dev: DRM device
868 * @old_state: atomic state object with old state structures
869 *
870 * Helper to, after atomic commit, wait for vblanks on all effected
871 * crtcs (ie. before cleaning up old framebuffers using
Daniel Vetterab58e332014-11-24 20:42:42 +0100872 * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the
873 * framebuffers have actually changed to optimize for the legacy cursor and
874 * plane update use-case.
Rob Clark5ee32292014-11-11 19:38:59 -0500875 */
876void
877drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
878 struct drm_atomic_state *old_state)
Daniel Vetter623369e2014-09-16 17:50:47 +0200879{
880 struct drm_crtc *crtc;
881 struct drm_crtc_state *old_crtc_state;
Daniel Vetter623369e2014-09-16 17:50:47 +0200882 int i, ret;
883
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300884 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Daniel Vetter623369e2014-09-16 17:50:47 +0200885 /* No one cares about the old state, so abuse it for tracking
886 * and store whether we hold a vblank reference (and should do a
887 * vblank wait) in the ->enable boolean. */
888 old_crtc_state->enable = false;
889
890 if (!crtc->state->enable)
891 continue;
892
Daniel Vetterf02ad902015-01-22 16:36:23 +0100893 /* Legacy cursor ioctls are completely unsynced, and userspace
894 * relies on that (by doing tons of cursor updates). */
895 if (old_state->legacy_cursor_update)
896 continue;
897
Daniel Vetterab58e332014-11-24 20:42:42 +0100898 if (!framebuffer_changed(dev, old_state, crtc))
899 continue;
900
Daniel Vetter623369e2014-09-16 17:50:47 +0200901 ret = drm_crtc_vblank_get(crtc);
902 if (ret != 0)
903 continue;
904
905 old_crtc_state->enable = true;
906 old_crtc_state->last_vblank_count = drm_vblank_count(dev, i);
907 }
908
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300909 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
910 if (!old_crtc_state->enable)
Daniel Vetter623369e2014-09-16 17:50:47 +0200911 continue;
912
913 ret = wait_event_timeout(dev->vblank[i].queue,
914 old_crtc_state->last_vblank_count !=
915 drm_vblank_count(dev, i),
916 msecs_to_jiffies(50));
917
918 drm_crtc_vblank_put(crtc);
919 }
920}
Rob Clark5ee32292014-11-11 19:38:59 -0500921EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
Daniel Vetter623369e2014-09-16 17:50:47 +0200922
923/**
924 * drm_atomic_helper_commit - commit validated state object
925 * @dev: DRM device
926 * @state: the driver state object
927 * @async: asynchronous commit
928 *
929 * This function commits a with drm_atomic_helper_check() pre-validated state
930 * object. This can still fail when e.g. the framebuffer reservation fails. For
931 * now this doesn't implement asynchronous commits.
932 *
933 * RETURNS
934 * Zero for success or -errno.
935 */
936int drm_atomic_helper_commit(struct drm_device *dev,
937 struct drm_atomic_state *state,
938 bool async)
939{
940 int ret;
941
942 if (async)
943 return -EBUSY;
944
945 ret = drm_atomic_helper_prepare_planes(dev, state);
946 if (ret)
947 return ret;
948
949 /*
950 * This is the point of no return - everything below never fails except
951 * when the hw goes bonghits. Which means we can commit the new state on
952 * the software side now.
953 */
954
955 drm_atomic_helper_swap_state(dev, state);
956
957 /*
958 * Everything below can be run asynchronously without the need to grab
John Hunterf98bd3e2015-03-17 15:30:26 +0800959 * any modeset locks at all under one condition: It must be guaranteed
Daniel Vetter623369e2014-09-16 17:50:47 +0200960 * that the asynchronous work has either been cancelled (if the driver
961 * supports it, which at least requires that the framebuffers get
962 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
963 * before the new state gets committed on the software side with
964 * drm_atomic_helper_swap_state().
965 *
966 * This scheme allows new atomic state updates to be prepared and
967 * checked in parallel to the asynchronous completion of the previous
968 * update. Which is important since compositors need to figure out the
969 * composition of the next frame right after having submitted the
970 * current layout.
971 */
972
Daniel Vettere2330f02014-10-29 11:34:56 +0100973 wait_for_fences(dev, state);
974
Daniel Vetter1af434a2015-02-22 12:24:19 +0100975 drm_atomic_helper_commit_modeset_disables(dev, state);
Daniel Vetter623369e2014-09-16 17:50:47 +0200976
977 drm_atomic_helper_commit_planes(dev, state);
978
Daniel Vetter1af434a2015-02-22 12:24:19 +0100979 drm_atomic_helper_commit_modeset_enables(dev, state);
Daniel Vetter623369e2014-09-16 17:50:47 +0200980
Rob Clark5ee32292014-11-11 19:38:59 -0500981 drm_atomic_helper_wait_for_vblanks(dev, state);
Daniel Vetter623369e2014-09-16 17:50:47 +0200982
983 drm_atomic_helper_cleanup_planes(dev, state);
984
985 drm_atomic_state_free(state);
986
987 return 0;
988}
989EXPORT_SYMBOL(drm_atomic_helper_commit);
990
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100991/**
Daniel Vettere8c833a2014-07-27 18:30:19 +0200992 * DOC: implementing async commit
993 *
994 * For now the atomic helpers don't support async commit directly. If there is
995 * real need it could be added though, using the dma-buf fence infrastructure
996 * for generic synchronization with outstanding rendering.
997 *
998 * For now drivers have to implement async commit themselves, with the following
999 * sequence being the recommended one:
1000 *
1001 * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1002 * which commit needs to call which can fail, so we want to run it first and
1003 * synchronously.
1004 *
1005 * 2. Synchronize with any outstanding asynchronous commit worker threads which
1006 * might be affected the new state update. This can be done by either cancelling
1007 * or flushing the work items, depending upon whether the driver can deal with
1008 * cancelled updates. Note that it is important to ensure that the framebuffer
1009 * cleanup is still done when cancelling.
1010 *
1011 * For sufficient parallelism it is recommended to have a work item per crtc
1012 * (for updates which don't touch global state) and a global one. Then we only
1013 * need to synchronize with the crtc work items for changed crtcs and the global
1014 * work item, which allows nice concurrent updates on disjoint sets of crtcs.
1015 *
1016 * 3. The software state is updated synchronously with
1017 * drm_atomic_helper_swap_state. Doing this under the protection of all modeset
1018 * locks means concurrent callers never see inconsistent state. And doing this
1019 * while it's guaranteed that no relevant async worker runs means that async
1020 * workers do not need grab any locks. Actually they must not grab locks, for
1021 * otherwise the work flushing will deadlock.
1022 *
1023 * 4. Schedule a work item to do all subsequent steps, using the split-out
1024 * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1025 * then cleaning up the framebuffers after the old framebuffer is no longer
1026 * being displayed.
1027 */
1028
1029/**
Daniel Vetter2e3afd42015-02-26 14:17:38 +01001030 * drm_atomic_helper_prepare_planes - prepare plane resources before commit
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001031 * @dev: DRM device
Daniel Vetter2e3afd42015-02-26 14:17:38 +01001032 * @state: atomic state object with new state structures
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001033 *
1034 * This function prepares plane state, specifically framebuffers, for the new
1035 * configuration. If any failure is encountered this function will call
1036 * ->cleanup_fb on any already successfully prepared framebuffer.
1037 *
1038 * Returns:
1039 * 0 on success, negative error code on failure.
1040 */
1041int drm_atomic_helper_prepare_planes(struct drm_device *dev,
1042 struct drm_atomic_state *state)
1043{
1044 int nplanes = dev->mode_config.num_total_plane;
1045 int ret, i;
1046
1047 for (i = 0; i < nplanes; i++) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +02001048 const struct drm_plane_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001049 struct drm_plane *plane = state->planes[i];
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001050 struct drm_plane_state *plane_state = state->plane_states[i];
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001051 struct drm_framebuffer *fb;
1052
1053 if (!plane)
1054 continue;
1055
1056 funcs = plane->helper_private;
1057
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001058 fb = plane_state->fb;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001059
1060 if (fb && funcs->prepare_fb) {
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001061 ret = funcs->prepare_fb(plane, fb, plane_state);
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001062 if (ret)
1063 goto fail;
1064 }
1065 }
1066
1067 return 0;
1068
1069fail:
1070 for (i--; i >= 0; i--) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +02001071 const struct drm_plane_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001072 struct drm_plane *plane = state->planes[i];
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001073 struct drm_plane_state *plane_state = state->plane_states[i];
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001074 struct drm_framebuffer *fb;
1075
1076 if (!plane)
1077 continue;
1078
1079 funcs = plane->helper_private;
1080
1081 fb = state->plane_states[i]->fb;
1082
1083 if (fb && funcs->cleanup_fb)
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001084 funcs->cleanup_fb(plane, fb, plane_state);
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001085
1086 }
1087
1088 return ret;
1089}
1090EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
1091
1092/**
1093 * drm_atomic_helper_commit_planes - commit plane state
1094 * @dev: DRM device
Daniel Vetterb0fcfc82014-11-19 18:38:11 +01001095 * @old_state: atomic state object with old state structures
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001096 *
1097 * This function commits the new plane state using the plane and atomic helper
1098 * functions for planes and crtcs. It assumes that the atomic state has already
1099 * been pushed into the relevant object state pointers, since this step can no
1100 * longer fail.
1101 *
Daniel Vetterb0fcfc82014-11-19 18:38:11 +01001102 * It still requires the global state object @old_state to know which planes and
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001103 * crtcs need to be updated though.
1104 */
1105void drm_atomic_helper_commit_planes(struct drm_device *dev,
Daniel Vetterb0fcfc82014-11-19 18:38:11 +01001106 struct drm_atomic_state *old_state)
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001107{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001108 struct drm_crtc *crtc;
1109 struct drm_crtc_state *old_crtc_state;
1110 struct drm_plane *plane;
1111 struct drm_plane_state *old_plane_state;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001112 int i;
1113
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001114 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +02001115 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001116
1117 funcs = crtc->helper_private;
1118
1119 if (!funcs || !funcs->atomic_begin)
1120 continue;
1121
1122 funcs->atomic_begin(crtc);
1123 }
1124
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001125 for_each_plane_in_state(old_state, plane, old_plane_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +02001126 const struct drm_plane_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001127
1128 funcs = plane->helper_private;
1129
Thierry Reding3cad4b62014-11-25 13:05:12 +01001130 if (!funcs)
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001131 continue;
1132
Thierry Redingf1c37e12014-11-25 12:09:44 +01001133 old_plane_state = old_state->plane_states[i];
1134
Thierry Reding407b8bd2014-11-20 12:05:50 +01001135 /*
1136 * Special-case disabling the plane if drivers support it.
1137 */
1138 if (drm_atomic_plane_disabling(plane, old_plane_state) &&
1139 funcs->atomic_disable)
1140 funcs->atomic_disable(plane, old_plane_state);
1141 else
1142 funcs->atomic_update(plane, old_plane_state);
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001143 }
1144
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001145 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +02001146 const struct drm_crtc_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001147
1148 funcs = crtc->helper_private;
1149
1150 if (!funcs || !funcs->atomic_flush)
1151 continue;
1152
1153 funcs->atomic_flush(crtc);
1154 }
1155}
1156EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
1157
1158/**
1159 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
1160 * @dev: DRM device
1161 * @old_state: atomic state object with old state structures
1162 *
1163 * This function cleans up plane state, specifically framebuffers, from the old
1164 * configuration. Hence the old configuration must be perserved in @old_state to
1165 * be able to call this function.
1166 *
1167 * This function must also be called on the new state when the atomic update
1168 * fails at any point after calling drm_atomic_helper_prepare_planes().
1169 */
1170void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
1171 struct drm_atomic_state *old_state)
1172{
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001173 struct drm_plane *plane;
1174 struct drm_plane_state *plane_state;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001175 int i;
1176
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001177 for_each_plane_in_state(old_state, plane, plane_state, i) {
Ville Syrjäläb5ceff22015-03-10 14:35:20 +02001178 const struct drm_plane_helper_funcs *funcs;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001179 struct drm_framebuffer *old_fb;
1180
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001181 funcs = plane->helper_private;
1182
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001183 old_fb = plane_state->fb;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001184
1185 if (old_fb && funcs->cleanup_fb)
Tvrtko Ursulind136dfe2015-03-03 14:22:31 +00001186 funcs->cleanup_fb(plane, old_fb, plane_state);
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001187 }
1188}
1189EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
1190
1191/**
1192 * drm_atomic_helper_swap_state - store atomic state into current sw state
1193 * @dev: DRM device
1194 * @state: atomic state
1195 *
1196 * This function stores the atomic state into the current state pointers in all
1197 * driver objects. It should be called after all failing steps have been done
1198 * and succeeded, but before the actual hardware state is committed.
1199 *
1200 * For cleanup and error recovery the current state for all changed objects will
1201 * be swaped into @state.
1202 *
1203 * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
1204 *
1205 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
1206 *
1207 * 2. Do any other steps that might fail.
1208 *
1209 * 3. Put the staged state into the current state pointers with this function.
1210 *
1211 * 4. Actually commit the hardware state.
1212 *
1213 * 5. Call drm_atomic_helper_cleanup_planes with @state, which since step 3
1214 * contains the old state. Also do any other cleanup required with that state.
1215 */
1216void drm_atomic_helper_swap_state(struct drm_device *dev,
1217 struct drm_atomic_state *state)
1218{
1219 int i;
1220
1221 for (i = 0; i < dev->mode_config.num_connector; i++) {
1222 struct drm_connector *connector = state->connectors[i];
1223
1224 if (!connector)
1225 continue;
1226
1227 connector->state->state = state;
1228 swap(state->connector_states[i], connector->state);
1229 connector->state->state = NULL;
1230 }
1231
1232 for (i = 0; i < dev->mode_config.num_crtc; i++) {
1233 struct drm_crtc *crtc = state->crtcs[i];
1234
1235 if (!crtc)
1236 continue;
1237
1238 crtc->state->state = state;
1239 swap(state->crtc_states[i], crtc->state);
1240 crtc->state->state = NULL;
1241 }
1242
1243 for (i = 0; i < dev->mode_config.num_total_plane; i++) {
1244 struct drm_plane *plane = state->planes[i];
1245
1246 if (!plane)
1247 continue;
1248
1249 plane->state->state = state;
1250 swap(state->plane_states[i], plane->state);
1251 plane->state->state = NULL;
1252 }
1253}
1254EXPORT_SYMBOL(drm_atomic_helper_swap_state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001255
1256/**
1257 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
1258 * @plane: plane object to update
1259 * @crtc: owning CRTC of owning plane
1260 * @fb: framebuffer to flip onto plane
1261 * @crtc_x: x offset of primary plane on crtc
1262 * @crtc_y: y offset of primary plane on crtc
1263 * @crtc_w: width of primary plane rectangle on crtc
1264 * @crtc_h: height of primary plane rectangle on crtc
1265 * @src_x: x offset of @fb for panning
1266 * @src_y: y offset of @fb for panning
1267 * @src_w: width of source rectangle in @fb
1268 * @src_h: height of source rectangle in @fb
1269 *
1270 * Provides a default plane update handler using the atomic driver interface.
1271 *
1272 * RETURNS:
1273 * Zero on success, error code on failure
1274 */
1275int drm_atomic_helper_update_plane(struct drm_plane *plane,
1276 struct drm_crtc *crtc,
1277 struct drm_framebuffer *fb,
1278 int crtc_x, int crtc_y,
1279 unsigned int crtc_w, unsigned int crtc_h,
1280 uint32_t src_x, uint32_t src_y,
1281 uint32_t src_w, uint32_t src_h)
1282{
1283 struct drm_atomic_state *state;
1284 struct drm_plane_state *plane_state;
1285 int ret = 0;
1286
1287 state = drm_atomic_state_alloc(plane->dev);
1288 if (!state)
1289 return -ENOMEM;
1290
1291 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1292retry:
1293 plane_state = drm_atomic_get_plane_state(state, plane);
1294 if (IS_ERR(plane_state)) {
1295 ret = PTR_ERR(plane_state);
1296 goto fail;
1297 }
1298
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001299 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
Daniel Vetter042652e2014-07-27 13:46:52 +02001300 if (ret != 0)
1301 goto fail;
Daniel Vetter321ebf02014-11-04 22:57:27 +01001302 drm_atomic_set_fb_for_plane(plane_state, fb);
Daniel Vetter042652e2014-07-27 13:46:52 +02001303 plane_state->crtc_x = crtc_x;
1304 plane_state->crtc_y = crtc_y;
1305 plane_state->crtc_h = crtc_h;
1306 plane_state->crtc_w = crtc_w;
1307 plane_state->src_x = src_x;
1308 plane_state->src_y = src_y;
1309 plane_state->src_h = src_h;
1310 plane_state->src_w = src_w;
1311
1312 ret = drm_atomic_commit(state);
1313 if (ret != 0)
1314 goto fail;
1315
Daniel Vetterf02ad902015-01-22 16:36:23 +01001316 if (plane == crtc->cursor)
1317 state->legacy_cursor_update = true;
1318
Daniel Vetter042652e2014-07-27 13:46:52 +02001319 /* Driver takes ownership of state on successful commit. */
1320 return 0;
1321fail:
1322 if (ret == -EDEADLK)
1323 goto backoff;
1324
1325 drm_atomic_state_free(state);
1326
1327 return ret;
1328backoff:
Daniel Vetter042652e2014-07-27 13:46:52 +02001329 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001330 drm_atomic_legacy_backoff(state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001331
1332 /*
1333 * Someone might have exchanged the framebuffer while we dropped locks
1334 * in the backoff code. We need to fix up the fb refcount tracking the
1335 * core does for us.
1336 */
1337 plane->old_fb = plane->fb;
1338
1339 goto retry;
1340}
1341EXPORT_SYMBOL(drm_atomic_helper_update_plane);
1342
1343/**
1344 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
1345 * @plane: plane to disable
1346 *
1347 * Provides a default plane disable handler using the atomic driver interface.
1348 *
1349 * RETURNS:
1350 * Zero on success, error code on failure
1351 */
1352int drm_atomic_helper_disable_plane(struct drm_plane *plane)
1353{
1354 struct drm_atomic_state *state;
1355 struct drm_plane_state *plane_state;
1356 int ret = 0;
1357
Jasper St. Pierreaa54e2e2014-11-20 19:59:15 -08001358 /*
1359 * FIXME: Without plane->crtc set we can't get at the implicit legacy
1360 * acquire context. The real fix will be to wire the acquire ctx through
1361 * everywhere we need it, but meanwhile prevent chaos by just skipping
1362 * this noop. The critical case is the cursor ioctls which a) only grab
1363 * crtc/cursor-plane locks (so we need the crtc to get at the right
1364 * acquire context) and b) can try to disable the plane multiple times.
1365 */
1366 if (!plane->crtc)
1367 return 0;
1368
Daniel Vetter042652e2014-07-27 13:46:52 +02001369 state = drm_atomic_state_alloc(plane->dev);
1370 if (!state)
1371 return -ENOMEM;
1372
1373 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc);
1374retry:
1375 plane_state = drm_atomic_get_plane_state(state, plane);
1376 if (IS_ERR(plane_state)) {
1377 ret = PTR_ERR(plane_state);
1378 goto fail;
1379 }
1380
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001381 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
Daniel Vetter042652e2014-07-27 13:46:52 +02001382 if (ret != 0)
1383 goto fail;
Daniel Vetter321ebf02014-11-04 22:57:27 +01001384 drm_atomic_set_fb_for_plane(plane_state, NULL);
Daniel Vetter042652e2014-07-27 13:46:52 +02001385 plane_state->crtc_x = 0;
1386 plane_state->crtc_y = 0;
1387 plane_state->crtc_h = 0;
1388 plane_state->crtc_w = 0;
1389 plane_state->src_x = 0;
1390 plane_state->src_y = 0;
1391 plane_state->src_h = 0;
1392 plane_state->src_w = 0;
1393
Daniel Vetterf02ad902015-01-22 16:36:23 +01001394 if (plane == plane->crtc->cursor)
1395 state->legacy_cursor_update = true;
1396
Daniel Vetter042652e2014-07-27 13:46:52 +02001397 ret = drm_atomic_commit(state);
1398 if (ret != 0)
1399 goto fail;
1400
1401 /* Driver takes ownership of state on successful commit. */
1402 return 0;
1403fail:
1404 if (ret == -EDEADLK)
1405 goto backoff;
1406
1407 drm_atomic_state_free(state);
1408
1409 return ret;
1410backoff:
Daniel Vetter042652e2014-07-27 13:46:52 +02001411 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001412 drm_atomic_legacy_backoff(state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001413
1414 /*
1415 * Someone might have exchanged the framebuffer while we dropped locks
1416 * in the backoff code. We need to fix up the fb refcount tracking the
1417 * core does for us.
1418 */
1419 plane->old_fb = plane->fb;
1420
1421 goto retry;
1422}
1423EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
1424
1425static int update_output_state(struct drm_atomic_state *state,
1426 struct drm_mode_set *set)
1427{
1428 struct drm_device *dev = set->crtc->dev;
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001429 struct drm_crtc *crtc;
1430 struct drm_crtc_state *crtc_state;
1431 struct drm_connector *connector;
Daniel Vetter042652e2014-07-27 13:46:52 +02001432 struct drm_connector_state *conn_state;
Daniel Vetter042652e2014-07-27 13:46:52 +02001433 int ret, i, j;
1434
1435 ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
1436 state->acquire_ctx);
1437 if (ret)
1438 return ret;
1439
1440 /* First grab all affected connector/crtc states. */
1441 for (i = 0; i < set->num_connectors; i++) {
1442 conn_state = drm_atomic_get_connector_state(state,
1443 set->connectors[i]);
1444 if (IS_ERR(conn_state))
1445 return PTR_ERR(conn_state);
1446 }
1447
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001448 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Daniel Vetter042652e2014-07-27 13:46:52 +02001449 ret = drm_atomic_add_affected_connectors(state, crtc);
1450 if (ret)
1451 return ret;
1452 }
1453
1454 /* Then recompute connector->crtc links and crtc enabling state. */
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001455 for_each_connector_in_state(state, connector, conn_state, i) {
Daniel Vetter042652e2014-07-27 13:46:52 +02001456 if (conn_state->crtc == set->crtc) {
1457 ret = drm_atomic_set_crtc_for_connector(conn_state,
1458 NULL);
1459 if (ret)
1460 return ret;
1461 }
1462
1463 for (j = 0; j < set->num_connectors; j++) {
1464 if (set->connectors[j] == connector) {
1465 ret = drm_atomic_set_crtc_for_connector(conn_state,
1466 set->crtc);
1467 if (ret)
1468 return ret;
1469 break;
1470 }
1471 }
1472 }
1473
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001474 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Daniel Vetter042652e2014-07-27 13:46:52 +02001475 /* Don't update ->enable for the CRTC in the set_config request,
1476 * since a mismatch would indicate a bug in the upper layers.
1477 * The actual modeset code later on will catch any
1478 * inconsistencies here. */
1479 if (crtc == set->crtc)
1480 continue;
1481
1482 crtc_state->enable =
1483 drm_atomic_connectors_for_crtc(state, crtc);
1484 }
1485
1486 return 0;
1487}
1488
1489/**
1490 * drm_atomic_helper_set_config - set a new config from userspace
1491 * @set: mode set configuration
1492 *
1493 * Provides a default crtc set_config handler using the atomic driver interface.
1494 *
1495 * Returns:
1496 * Returns 0 on success, negative errno numbers on failure.
1497 */
1498int drm_atomic_helper_set_config(struct drm_mode_set *set)
1499{
1500 struct drm_atomic_state *state;
1501 struct drm_crtc *crtc = set->crtc;
1502 struct drm_crtc_state *crtc_state;
1503 struct drm_plane_state *primary_state;
1504 int ret = 0;
1505
1506 state = drm_atomic_state_alloc(crtc->dev);
1507 if (!state)
1508 return -ENOMEM;
1509
1510 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1511retry:
1512 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1513 if (IS_ERR(crtc_state)) {
1514 ret = PTR_ERR(crtc_state);
1515 goto fail;
1516 }
1517
Rob Clarke5b53412014-11-26 18:58:04 -05001518 primary_state = drm_atomic_get_plane_state(state, crtc->primary);
1519 if (IS_ERR(primary_state)) {
1520 ret = PTR_ERR(primary_state);
1521 goto fail;
1522 }
1523
Daniel Vetter042652e2014-07-27 13:46:52 +02001524 if (!set->mode) {
1525 WARN_ON(set->fb);
1526 WARN_ON(set->num_connectors);
1527
1528 crtc_state->enable = false;
Daniel Vettereab3bbe2015-01-22 16:36:21 +01001529 crtc_state->active = false;
Rob Clarke5b53412014-11-26 18:58:04 -05001530
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001531 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
Rob Clarke5b53412014-11-26 18:58:04 -05001532 if (ret != 0)
1533 goto fail;
1534
1535 drm_atomic_set_fb_for_plane(primary_state, NULL);
1536
Daniel Vetter042652e2014-07-27 13:46:52 +02001537 goto commit;
1538 }
1539
1540 WARN_ON(!set->fb);
1541 WARN_ON(!set->num_connectors);
1542
1543 crtc_state->enable = true;
Daniel Vettereab3bbe2015-01-22 16:36:21 +01001544 crtc_state->active = true;
Daniel Vetter042652e2014-07-27 13:46:52 +02001545 drm_mode_copy(&crtc_state->mode, set->mode);
1546
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001547 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
Daniel Vetter042652e2014-07-27 13:46:52 +02001548 if (ret != 0)
1549 goto fail;
Daniel Vetter321ebf02014-11-04 22:57:27 +01001550 drm_atomic_set_fb_for_plane(primary_state, set->fb);
Daniel Vetter042652e2014-07-27 13:46:52 +02001551 primary_state->crtc_x = 0;
1552 primary_state->crtc_y = 0;
1553 primary_state->crtc_h = set->mode->vdisplay;
1554 primary_state->crtc_w = set->mode->hdisplay;
1555 primary_state->src_x = set->x << 16;
1556 primary_state->src_y = set->y << 16;
1557 primary_state->src_h = set->mode->vdisplay << 16;
1558 primary_state->src_w = set->mode->hdisplay << 16;
1559
1560commit:
1561 ret = update_output_state(state, set);
1562 if (ret)
1563 goto fail;
1564
1565 ret = drm_atomic_commit(state);
1566 if (ret != 0)
1567 goto fail;
1568
1569 /* Driver takes ownership of state on successful commit. */
1570 return 0;
1571fail:
1572 if (ret == -EDEADLK)
1573 goto backoff;
1574
1575 drm_atomic_state_free(state);
1576
1577 return ret;
1578backoff:
Daniel Vetter042652e2014-07-27 13:46:52 +02001579 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001580 drm_atomic_legacy_backoff(state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001581
1582 /*
1583 * Someone might have exchanged the framebuffer while we dropped locks
1584 * in the backoff code. We need to fix up the fb refcount tracking the
1585 * core does for us.
1586 */
1587 crtc->primary->old_fb = crtc->primary->fb;
1588
1589 goto retry;
1590}
1591EXPORT_SYMBOL(drm_atomic_helper_set_config);
1592
1593/**
Laurent Pinchart7f500022015-02-23 02:50:23 +02001594 * drm_atomic_helper_crtc_set_property - helper for crtc properties
Daniel Vetter042652e2014-07-27 13:46:52 +02001595 * @crtc: DRM crtc
1596 * @property: DRM property
1597 * @val: value of property
1598 *
Laurent Pinchart7f500022015-02-23 02:50:23 +02001599 * Provides a default crtc set_property handler using the atomic driver
1600 * interface.
Daniel Vetter042652e2014-07-27 13:46:52 +02001601 *
1602 * RETURNS:
1603 * Zero on success, error code on failure
1604 */
1605int
1606drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc,
1607 struct drm_property *property,
1608 uint64_t val)
1609{
1610 struct drm_atomic_state *state;
1611 struct drm_crtc_state *crtc_state;
1612 int ret = 0;
1613
1614 state = drm_atomic_state_alloc(crtc->dev);
1615 if (!state)
1616 return -ENOMEM;
1617
1618 /* ->set_property is always called with all locks held. */
1619 state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
1620retry:
1621 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1622 if (IS_ERR(crtc_state)) {
1623 ret = PTR_ERR(crtc_state);
1624 goto fail;
1625 }
1626
Rob Clark40ecc692014-12-18 16:01:46 -05001627 ret = drm_atomic_crtc_set_property(crtc, crtc_state,
1628 property, val);
Daniel Vetter042652e2014-07-27 13:46:52 +02001629 if (ret)
1630 goto fail;
1631
1632 ret = drm_atomic_commit(state);
1633 if (ret != 0)
1634 goto fail;
1635
1636 /* Driver takes ownership of state on successful commit. */
1637 return 0;
1638fail:
1639 if (ret == -EDEADLK)
1640 goto backoff;
1641
1642 drm_atomic_state_free(state);
1643
1644 return ret;
1645backoff:
Daniel Vetter042652e2014-07-27 13:46:52 +02001646 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001647 drm_atomic_legacy_backoff(state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001648
1649 goto retry;
1650}
1651EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property);
1652
1653/**
Laurent Pinchart7f500022015-02-23 02:50:23 +02001654 * drm_atomic_helper_plane_set_property - helper for plane properties
Daniel Vetter042652e2014-07-27 13:46:52 +02001655 * @plane: DRM plane
1656 * @property: DRM property
1657 * @val: value of property
1658 *
Laurent Pinchart7f500022015-02-23 02:50:23 +02001659 * Provides a default plane set_property handler using the atomic driver
1660 * interface.
Daniel Vetter042652e2014-07-27 13:46:52 +02001661 *
1662 * RETURNS:
1663 * Zero on success, error code on failure
1664 */
1665int
1666drm_atomic_helper_plane_set_property(struct drm_plane *plane,
1667 struct drm_property *property,
1668 uint64_t val)
1669{
1670 struct drm_atomic_state *state;
1671 struct drm_plane_state *plane_state;
1672 int ret = 0;
1673
1674 state = drm_atomic_state_alloc(plane->dev);
1675 if (!state)
1676 return -ENOMEM;
1677
1678 /* ->set_property is always called with all locks held. */
1679 state->acquire_ctx = plane->dev->mode_config.acquire_ctx;
1680retry:
1681 plane_state = drm_atomic_get_plane_state(state, plane);
1682 if (IS_ERR(plane_state)) {
1683 ret = PTR_ERR(plane_state);
1684 goto fail;
1685 }
1686
Rob Clark40ecc692014-12-18 16:01:46 -05001687 ret = drm_atomic_plane_set_property(plane, plane_state,
1688 property, val);
Daniel Vetter042652e2014-07-27 13:46:52 +02001689 if (ret)
1690 goto fail;
1691
1692 ret = drm_atomic_commit(state);
1693 if (ret != 0)
1694 goto fail;
1695
1696 /* Driver takes ownership of state on successful commit. */
1697 return 0;
1698fail:
1699 if (ret == -EDEADLK)
1700 goto backoff;
1701
1702 drm_atomic_state_free(state);
1703
1704 return ret;
1705backoff:
Daniel Vetter042652e2014-07-27 13:46:52 +02001706 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001707 drm_atomic_legacy_backoff(state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001708
1709 goto retry;
1710}
1711EXPORT_SYMBOL(drm_atomic_helper_plane_set_property);
1712
1713/**
Laurent Pinchart7f500022015-02-23 02:50:23 +02001714 * drm_atomic_helper_connector_set_property - helper for connector properties
Daniel Vetter042652e2014-07-27 13:46:52 +02001715 * @connector: DRM connector
1716 * @property: DRM property
1717 * @val: value of property
1718 *
Laurent Pinchart7f500022015-02-23 02:50:23 +02001719 * Provides a default connector set_property handler using the atomic driver
1720 * interface.
Daniel Vetter042652e2014-07-27 13:46:52 +02001721 *
1722 * RETURNS:
1723 * Zero on success, error code on failure
1724 */
1725int
1726drm_atomic_helper_connector_set_property(struct drm_connector *connector,
1727 struct drm_property *property,
1728 uint64_t val)
1729{
1730 struct drm_atomic_state *state;
1731 struct drm_connector_state *connector_state;
1732 int ret = 0;
1733
1734 state = drm_atomic_state_alloc(connector->dev);
1735 if (!state)
1736 return -ENOMEM;
1737
1738 /* ->set_property is always called with all locks held. */
1739 state->acquire_ctx = connector->dev->mode_config.acquire_ctx;
1740retry:
1741 connector_state = drm_atomic_get_connector_state(state, connector);
1742 if (IS_ERR(connector_state)) {
1743 ret = PTR_ERR(connector_state);
1744 goto fail;
1745 }
1746
Rob Clark40ecc692014-12-18 16:01:46 -05001747 ret = drm_atomic_connector_set_property(connector, connector_state,
1748 property, val);
Daniel Vetter042652e2014-07-27 13:46:52 +02001749 if (ret)
1750 goto fail;
1751
1752 ret = drm_atomic_commit(state);
1753 if (ret != 0)
1754 goto fail;
1755
1756 /* Driver takes ownership of state on successful commit. */
1757 return 0;
1758fail:
1759 if (ret == -EDEADLK)
1760 goto backoff;
1761
1762 drm_atomic_state_free(state);
1763
1764 return ret;
1765backoff:
Daniel Vetter042652e2014-07-27 13:46:52 +02001766 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001767 drm_atomic_legacy_backoff(state);
Daniel Vetter042652e2014-07-27 13:46:52 +02001768
1769 goto retry;
1770}
1771EXPORT_SYMBOL(drm_atomic_helper_connector_set_property);
Daniel Vetter8bc0f312014-07-27 18:42:37 +02001772
1773/**
1774 * drm_atomic_helper_page_flip - execute a legacy page flip
1775 * @crtc: DRM crtc
1776 * @fb: DRM framebuffer
1777 * @event: optional DRM event to signal upon completion
1778 * @flags: flip flags for non-vblank sync'ed updates
1779 *
1780 * Provides a default page flip implementation using the atomic driver interface.
1781 *
1782 * Note that for now so called async page flips (i.e. updates which are not
1783 * synchronized to vblank) are not supported, since the atomic interfaces have
1784 * no provisions for this yet.
1785 *
1786 * Returns:
1787 * Returns 0 on success, negative errno numbers on failure.
1788 */
1789int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
1790 struct drm_framebuffer *fb,
1791 struct drm_pending_vblank_event *event,
1792 uint32_t flags)
1793{
1794 struct drm_plane *plane = crtc->primary;
1795 struct drm_atomic_state *state;
1796 struct drm_plane_state *plane_state;
1797 struct drm_crtc_state *crtc_state;
1798 int ret = 0;
1799
1800 if (flags & DRM_MODE_PAGE_FLIP_ASYNC)
1801 return -EINVAL;
1802
1803 state = drm_atomic_state_alloc(plane->dev);
1804 if (!state)
1805 return -ENOMEM;
1806
1807 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1808retry:
1809 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1810 if (IS_ERR(crtc_state)) {
1811 ret = PTR_ERR(crtc_state);
1812 goto fail;
1813 }
1814 crtc_state->event = event;
1815
1816 plane_state = drm_atomic_get_plane_state(state, plane);
1817 if (IS_ERR(plane_state)) {
1818 ret = PTR_ERR(plane_state);
1819 goto fail;
1820 }
1821
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001822 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
Daniel Vetter8bc0f312014-07-27 18:42:37 +02001823 if (ret != 0)
1824 goto fail;
Daniel Vetter321ebf02014-11-04 22:57:27 +01001825 drm_atomic_set_fb_for_plane(plane_state, fb);
Daniel Vetter8bc0f312014-07-27 18:42:37 +02001826
1827 ret = drm_atomic_async_commit(state);
1828 if (ret != 0)
1829 goto fail;
1830
1831 /* TODO: ->page_flip is the only driver callback where the core
1832 * doesn't update plane->fb. For now patch it up here. */
1833 plane->fb = plane->state->fb;
1834
1835 /* Driver takes ownership of state on successful async commit. */
1836 return 0;
1837fail:
1838 if (ret == -EDEADLK)
1839 goto backoff;
1840
1841 drm_atomic_state_free(state);
1842
1843 return ret;
1844backoff:
Daniel Vetter8bc0f312014-07-27 18:42:37 +02001845 drm_atomic_state_clear(state);
Daniel Vetter6f75cea2014-11-19 18:38:07 +01001846 drm_atomic_legacy_backoff(state);
Daniel Vetter8bc0f312014-07-27 18:42:37 +02001847
1848 /*
1849 * Someone might have exchanged the framebuffer while we dropped locks
1850 * in the backoff code. We need to fix up the fb refcount tracking the
1851 * core does for us.
1852 */
1853 plane->old_fb = plane->fb;
1854
1855 goto retry;
1856}
1857EXPORT_SYMBOL(drm_atomic_helper_page_flip);
Daniel Vetterd4617012014-11-03 15:56:43 +01001858
1859/**
Daniel Vetterb486e0e2015-01-22 18:53:05 +01001860 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation
1861 * @connector: affected connector
1862 * @mode: DPMS mode
1863 *
1864 * This is the main helper function provided by the atomic helper framework for
1865 * implementing the legacy DPMS connector interface. It computes the new desired
1866 * ->active state for the corresponding CRTC (if the connector is enabled) and
1867 * updates it.
1868 */
1869void drm_atomic_helper_connector_dpms(struct drm_connector *connector,
1870 int mode)
1871{
1872 struct drm_mode_config *config = &connector->dev->mode_config;
1873 struct drm_atomic_state *state;
1874 struct drm_crtc_state *crtc_state;
1875 struct drm_crtc *crtc;
1876 struct drm_connector *tmp_connector;
1877 int ret;
1878 bool active = false;
1879
1880 if (mode != DRM_MODE_DPMS_ON)
1881 mode = DRM_MODE_DPMS_OFF;
1882
1883 connector->dpms = mode;
1884 crtc = connector->state->crtc;
1885
1886 if (!crtc)
1887 return;
1888
1889 /* FIXME: ->dpms has no return value so can't forward the -ENOMEM. */
1890 state = drm_atomic_state_alloc(connector->dev);
1891 if (!state)
1892 return;
1893
1894 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1895retry:
1896 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1897 if (IS_ERR(crtc_state))
1898 return;
1899
1900 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
1901
1902 list_for_each_entry(tmp_connector, &config->connector_list, head) {
John Hunter0388df02015-03-17 15:30:28 +08001903 if (tmp_connector->state->crtc != crtc)
Daniel Vetterb486e0e2015-01-22 18:53:05 +01001904 continue;
1905
John Hunter0388df02015-03-17 15:30:28 +08001906 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) {
Daniel Vetterb486e0e2015-01-22 18:53:05 +01001907 active = true;
1908 break;
1909 }
1910 }
1911 crtc_state->active = active;
1912
1913 ret = drm_atomic_commit(state);
1914 if (ret != 0)
1915 goto fail;
1916
1917 /* Driver takes ownership of state on successful async commit. */
1918 return;
1919fail:
1920 if (ret == -EDEADLK)
1921 goto backoff;
1922
1923 drm_atomic_state_free(state);
1924
1925 WARN(1, "Driver bug: Changing ->active failed with ret=%i\n", ret);
1926
1927 return;
1928backoff:
1929 drm_atomic_state_clear(state);
1930 drm_atomic_legacy_backoff(state);
1931
1932 goto retry;
1933}
1934EXPORT_SYMBOL(drm_atomic_helper_connector_dpms);
1935
1936/**
Daniel Vetter3150c7d2014-11-06 20:53:29 +01001937 * DOC: atomic state reset and initialization
1938 *
1939 * Both the drm core and the atomic helpers assume that there is always the full
1940 * and correct atomic software state for all connectors, CRTCs and planes
1941 * available. Which is a bit a problem on driver load and also after system
1942 * suspend. One way to solve this is to have a hardware state read-out
1943 * infrastructure which reconstructs the full software state (e.g. the i915
1944 * driver).
1945 *
1946 * The simpler solution is to just reset the software state to everything off,
1947 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
1948 * the atomic helpers provide default reset implementations for all hooks.
1949 */
1950
1951/**
Daniel Vetterd4617012014-11-03 15:56:43 +01001952 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs
1953 * @crtc: drm CRTC
1954 *
1955 * Resets the atomic state for @crtc by freeing the state pointer (which might
1956 * be NULL, e.g. at driver load time) and allocating a new empty state object.
1957 */
1958void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
1959{
1960 kfree(crtc->state);
1961 crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001962
1963 if (crtc->state)
1964 crtc->state->crtc = crtc;
Daniel Vetterd4617012014-11-03 15:56:43 +01001965}
1966EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
1967
1968/**
Thierry Redingf5e78402015-01-28 14:54:32 +01001969 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
1970 * @crtc: CRTC object
1971 * @state: atomic CRTC state
1972 *
1973 * Copies atomic state from a CRTC's current state and resets inferred values.
1974 * This is useful for drivers that subclass the CRTC state.
1975 */
1976void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
1977 struct drm_crtc_state *state)
1978{
1979 memcpy(state, crtc->state, sizeof(*state));
1980
1981 state->mode_changed = false;
1982 state->active_changed = false;
1983 state->planes_changed = false;
1984 state->event = NULL;
1985}
1986EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
1987
1988/**
Daniel Vetterd4617012014-11-03 15:56:43 +01001989 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
1990 * @crtc: drm CRTC
1991 *
1992 * Default CRTC state duplicate hook for drivers which don't have their own
1993 * subclassed CRTC state structure.
1994 */
1995struct drm_crtc_state *
1996drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
1997{
1998 struct drm_crtc_state *state;
1999
2000 if (WARN_ON(!crtc->state))
2001 return NULL;
2002
Thierry Redingf5e78402015-01-28 14:54:32 +01002003 state = kmalloc(sizeof(*state), GFP_KERNEL);
2004 if (state)
2005 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
Daniel Vetterd4617012014-11-03 15:56:43 +01002006
2007 return state;
2008}
2009EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
2010
2011/**
Thierry Redingf5e78402015-01-28 14:54:32 +01002012 * __drm_atomic_helper_crtc_destroy_state - release CRTC state
2013 * @crtc: CRTC object
2014 * @state: CRTC state object to release
2015 *
2016 * Releases all resources stored in the CRTC state without actually freeing
2017 * the memory of the CRTC state. This is useful for drivers that subclass the
2018 * CRTC state.
2019 */
2020void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2021 struct drm_crtc_state *state)
2022{
2023 /*
2024 * This is currently a placeholder so that drivers that subclass the
2025 * state will automatically do the right thing if code is ever added
2026 * to this function.
2027 */
2028}
2029EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
2030
2031/**
Daniel Vetterd4617012014-11-03 15:56:43 +01002032 * drm_atomic_helper_crtc_destroy_state - default state destroy hook
2033 * @crtc: drm CRTC
2034 * @state: CRTC state object to release
2035 *
2036 * Default CRTC state destroy hook for drivers which don't have their own
2037 * subclassed CRTC state structure.
2038 */
2039void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2040 struct drm_crtc_state *state)
2041{
Thierry Redingf5e78402015-01-28 14:54:32 +01002042 __drm_atomic_helper_crtc_destroy_state(crtc, state);
Daniel Vetterd4617012014-11-03 15:56:43 +01002043 kfree(state);
2044}
2045EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
2046
2047/**
2048 * drm_atomic_helper_plane_reset - default ->reset hook for planes
2049 * @plane: drm plane
2050 *
2051 * Resets the atomic state for @plane by freeing the state pointer (which might
2052 * be NULL, e.g. at driver load time) and allocating a new empty state object.
2053 */
2054void drm_atomic_helper_plane_reset(struct drm_plane *plane)
2055{
Daniel Vetter321ebf02014-11-04 22:57:27 +01002056 if (plane->state && plane->state->fb)
2057 drm_framebuffer_unreference(plane->state->fb);
2058
Daniel Vetterd4617012014-11-03 15:56:43 +01002059 kfree(plane->state);
2060 plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01002061
2062 if (plane->state)
2063 plane->state->plane = plane;
Daniel Vetterd4617012014-11-03 15:56:43 +01002064}
2065EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
2066
2067/**
Thierry Redingf5e78402015-01-28 14:54:32 +01002068 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
2069 * @plane: plane object
2070 * @state: atomic plane state
2071 *
2072 * Copies atomic state from a plane's current state. This is useful for
2073 * drivers that subclass the plane state.
2074 */
2075void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
2076 struct drm_plane_state *state)
2077{
2078 memcpy(state, plane->state, sizeof(*state));
2079
2080 if (state->fb)
2081 drm_framebuffer_reference(state->fb);
2082}
2083EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
2084
2085/**
Daniel Vetterd4617012014-11-03 15:56:43 +01002086 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
2087 * @plane: drm plane
2088 *
2089 * Default plane state duplicate hook for drivers which don't have their own
2090 * subclassed plane state structure.
2091 */
2092struct drm_plane_state *
2093drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
2094{
Daniel Vetter321ebf02014-11-04 22:57:27 +01002095 struct drm_plane_state *state;
2096
Daniel Vetterd4617012014-11-03 15:56:43 +01002097 if (WARN_ON(!plane->state))
2098 return NULL;
2099
Thierry Redingf5e78402015-01-28 14:54:32 +01002100 state = kmalloc(sizeof(*state), GFP_KERNEL);
2101 if (state)
2102 __drm_atomic_helper_plane_duplicate_state(plane, state);
Daniel Vetter321ebf02014-11-04 22:57:27 +01002103
2104 return state;
Daniel Vetterd4617012014-11-03 15:56:43 +01002105}
2106EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
2107
2108/**
Thierry Redingf5e78402015-01-28 14:54:32 +01002109 * __drm_atomic_helper_plane_destroy_state - release plane state
2110 * @plane: plane object
2111 * @state: plane state object to release
2112 *
2113 * Releases all resources stored in the plane state without actually freeing
2114 * the memory of the plane state. This is useful for drivers that subclass the
2115 * plane state.
2116 */
2117void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2118 struct drm_plane_state *state)
2119{
2120 if (state->fb)
2121 drm_framebuffer_unreference(state->fb);
2122}
2123EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
2124
2125/**
Daniel Vetterd4617012014-11-03 15:56:43 +01002126 * drm_atomic_helper_plane_destroy_state - default state destroy hook
2127 * @plane: drm plane
2128 * @state: plane state object to release
2129 *
2130 * Default plane state destroy hook for drivers which don't have their own
2131 * subclassed plane state structure.
2132 */
2133void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
Daniel Vetter321ebf02014-11-04 22:57:27 +01002134 struct drm_plane_state *state)
Daniel Vetterd4617012014-11-03 15:56:43 +01002135{
Thierry Redingf5e78402015-01-28 14:54:32 +01002136 __drm_atomic_helper_plane_destroy_state(plane, state);
Daniel Vetterd4617012014-11-03 15:56:43 +01002137 kfree(state);
2138}
2139EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
2140
2141/**
2142 * drm_atomic_helper_connector_reset - default ->reset hook for connectors
2143 * @connector: drm connector
2144 *
2145 * Resets the atomic state for @connector by freeing the state pointer (which
2146 * might be NULL, e.g. at driver load time) and allocating a new empty state
2147 * object.
2148 */
2149void drm_atomic_helper_connector_reset(struct drm_connector *connector)
2150{
2151 kfree(connector->state);
2152 connector->state = kzalloc(sizeof(*connector->state), GFP_KERNEL);
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01002153
2154 if (connector->state)
2155 connector->state->connector = connector;
Daniel Vetterd4617012014-11-03 15:56:43 +01002156}
2157EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
2158
2159/**
Thierry Redingf5e78402015-01-28 14:54:32 +01002160 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
2161 * @connector: connector object
2162 * @state: atomic connector state
2163 *
2164 * Copies atomic state from a connector's current state. This is useful for
2165 * drivers that subclass the connector state.
2166 */
2167void
2168__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
2169 struct drm_connector_state *state)
2170{
2171 memcpy(state, connector->state, sizeof(*state));
2172}
2173EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
2174
2175/**
Daniel Vetterd4617012014-11-03 15:56:43 +01002176 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
2177 * @connector: drm connector
2178 *
2179 * Default connector state duplicate hook for drivers which don't have their own
2180 * subclassed connector state structure.
2181 */
2182struct drm_connector_state *
2183drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
2184{
Thierry Redingf5e78402015-01-28 14:54:32 +01002185 struct drm_connector_state *state;
2186
Daniel Vetterd4617012014-11-03 15:56:43 +01002187 if (WARN_ON(!connector->state))
2188 return NULL;
2189
Thierry Redingf5e78402015-01-28 14:54:32 +01002190 state = kmalloc(sizeof(*state), GFP_KERNEL);
2191 if (state)
2192 __drm_atomic_helper_connector_duplicate_state(connector, state);
2193
2194 return state;
Daniel Vetterd4617012014-11-03 15:56:43 +01002195}
2196EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
2197
2198/**
Thierry Redingf5e78402015-01-28 14:54:32 +01002199 * __drm_atomic_helper_connector_destroy_state - release connector state
2200 * @connector: connector object
2201 * @state: connector state object to release
2202 *
2203 * Releases all resources stored in the connector state without actually
2204 * freeing the memory of the connector state. This is useful for drivers that
2205 * subclass the connector state.
2206 */
2207void
2208__drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2209 struct drm_connector_state *state)
2210{
2211 /*
2212 * This is currently a placeholder so that drivers that subclass the
2213 * state will automatically do the right thing if code is ever added
2214 * to this function.
2215 */
2216}
2217EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
2218
2219/**
Daniel Vetterd4617012014-11-03 15:56:43 +01002220 * drm_atomic_helper_connector_destroy_state - default state destroy hook
2221 * @connector: drm connector
2222 * @state: connector state object to release
2223 *
2224 * Default connector state destroy hook for drivers which don't have their own
2225 * subclassed connector state structure.
2226 */
2227void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2228 struct drm_connector_state *state)
2229{
Thierry Redingf5e78402015-01-28 14:54:32 +01002230 __drm_atomic_helper_connector_destroy_state(connector, state);
Daniel Vetterd4617012014-11-03 15:56:43 +01002231 kfree(state);
2232}
2233EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);