source: src/linux/universal/linux-4.4/drivers/gpu/drm/drm_atomic_helper.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 5 months ago

use new squashfs in all kernels

File size: 70.3 KB
Line 
1/*
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>
32#include <drm/drm_atomic_helper.h>
33#include <linux/fence.h>
34
35/**
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
47 * exposed 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 */
56static 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) {
64                crtc_state = state->crtc_states[drm_crtc_index(plane->state->crtc)];
65
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
83static 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        drm_for_each_connector(connector, dev) {
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;
111
112        /*
113         * We can only steal an encoder coming from a connector, which means we
114         * must already hold the connection_mutex.
115         */
116        WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
117
118        DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d], stealing it\n",
119                         encoder->base.id, encoder->name,
120                         encoder_crtc->base.id);
121
122        crtc_state = drm_atomic_get_crtc_state(state, encoder_crtc);
123        if (IS_ERR(crtc_state))
124                return PTR_ERR(crtc_state);
125
126        crtc_state->connectors_changed = true;
127
128        list_for_each_entry(connector, &config->connector_list, head) {
129                if (connector->state->best_encoder != encoder)
130                        continue;
131
132                DRM_DEBUG_ATOMIC("Stealing encoder from [CONNECTOR:%d:%s]\n",
133                                 connector->base.id,
134                                 connector->name);
135
136                connector_state = drm_atomic_get_connector_state(state,
137                                                                 connector);
138                if (IS_ERR(connector_state))
139                        return PTR_ERR(connector_state);
140
141                connector_state->best_encoder = NULL;
142        }
143
144        return 0;
145}
146
147static int
148update_connector_routing(struct drm_atomic_state *state, int conn_idx)
149{
150        const struct drm_connector_helper_funcs *funcs;
151        struct drm_encoder *new_encoder;
152        struct drm_crtc *encoder_crtc;
153        struct drm_connector *connector;
154        struct drm_connector_state *connector_state;
155        struct drm_crtc_state *crtc_state;
156        int idx, ret;
157
158        connector = state->connectors[conn_idx];
159        connector_state = state->connector_states[conn_idx];
160
161        if (!connector)
162                return 0;
163
164        DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n",
165                         connector->base.id,
166                         connector->name);
167
168        if (connector->state->crtc != connector_state->crtc) {
169                if (connector->state->crtc) {
170                        idx = drm_crtc_index(connector->state->crtc);
171
172                        crtc_state = state->crtc_states[idx];
173                        crtc_state->connectors_changed = true;
174                }
175
176                if (connector_state->crtc) {
177                        idx = drm_crtc_index(connector_state->crtc);
178
179                        crtc_state = state->crtc_states[idx];
180                        crtc_state->connectors_changed = true;
181                }
182        }
183
184        if (!connector_state->crtc) {
185                DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n",
186                                connector->base.id,
187                                connector->name);
188
189                connector_state->best_encoder = NULL;
190
191                return 0;
192        }
193
194        funcs = connector->helper_private;
195
196        if (funcs->atomic_best_encoder)
197                new_encoder = funcs->atomic_best_encoder(connector,
198                                                         connector_state);
199        else
200                new_encoder = funcs->best_encoder(connector);
201
202        if (!new_encoder) {
203                DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n",
204                                 connector->base.id,
205                                 connector->name);
206                return -EINVAL;
207        }
208
209        if (!drm_encoder_crtc_ok(new_encoder, connector_state->crtc)) {
210                DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] incompatible with [CRTC:%d]\n",
211                                 new_encoder->base.id,
212                                 new_encoder->name,
213                                 connector_state->crtc->base.id);
214                return -EINVAL;
215        }
216
217        if (new_encoder == connector_state->best_encoder) {
218                DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d]\n",
219                                 connector->base.id,
220                                 connector->name,
221                                 new_encoder->base.id,
222                                 new_encoder->name,
223                                 connector_state->crtc->base.id);
224
225                return 0;
226        }
227
228        encoder_crtc = get_current_crtc_for_encoder(state->dev,
229                                                    new_encoder);
230
231        if (encoder_crtc) {
232                ret = steal_encoder(state, new_encoder, encoder_crtc);
233                if (ret) {
234                        DRM_DEBUG_ATOMIC("Encoder stealing failed for [CONNECTOR:%d:%s]\n",
235                                         connector->base.id,
236                                         connector->name);
237                        return ret;
238                }
239        }
240
241        if (WARN_ON(!connector_state->crtc))
242                return -EINVAL;
243
244        connector_state->best_encoder = new_encoder;
245        idx = drm_crtc_index(connector_state->crtc);
246
247        crtc_state = state->crtc_states[idx];
248        crtc_state->connectors_changed = true;
249
250        DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d]\n",
251                         connector->base.id,
252                         connector->name,
253                         new_encoder->base.id,
254                         new_encoder->name,
255                         connector_state->crtc->base.id);
256
257        return 0;
258}
259
260static int
261mode_fixup(struct drm_atomic_state *state)
262{
263        struct drm_crtc *crtc;
264        struct drm_crtc_state *crtc_state;
265        struct drm_connector *connector;
266        struct drm_connector_state *conn_state;
267        int i;
268        int ret;
269
270        for_each_crtc_in_state(state, crtc, crtc_state, i) {
271                if (!crtc_state->mode_changed &&
272                    !crtc_state->connectors_changed)
273                        continue;
274
275                drm_mode_copy(&crtc_state->adjusted_mode, &crtc_state->mode);
276        }
277
278        for_each_connector_in_state(state, connector, conn_state, i) {
279                const struct drm_encoder_helper_funcs *funcs;
280                struct drm_encoder *encoder;
281
282                WARN_ON(!!conn_state->best_encoder != !!conn_state->crtc);
283
284                if (!conn_state->crtc || !conn_state->best_encoder)
285                        continue;
286
287                crtc_state =
288                        state->crtc_states[drm_crtc_index(conn_state->crtc)];
289
290                /*
291                 * Each encoder has at most one connector (since we always steal
292                 * it away), so we won't call ->mode_fixup twice.
293                 */
294                encoder = conn_state->best_encoder;
295                funcs = encoder->helper_private;
296                if (!funcs)
297                        continue;
298
299                ret = drm_bridge_mode_fixup(encoder->bridge, &crtc_state->mode,
300                                &crtc_state->adjusted_mode);
301                if (!ret) {
302                        DRM_DEBUG_ATOMIC("Bridge fixup failed\n");
303                        return -EINVAL;
304                }
305
306                if (funcs->atomic_check) {
307                        ret = funcs->atomic_check(encoder, crtc_state,
308                                                  conn_state);
309                        if (ret) {
310                                DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n",
311                                                 encoder->base.id, encoder->name);
312                                return ret;
313                        }
314                } else if (funcs->mode_fixup) {
315                        ret = funcs->mode_fixup(encoder, &crtc_state->mode,
316                                                &crtc_state->adjusted_mode);
317                        if (!ret) {
318                                DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n",
319                                                 encoder->base.id, encoder->name);
320                                return -EINVAL;
321                        }
322                }
323        }
324
325        for_each_crtc_in_state(state, crtc, crtc_state, i) {
326                const struct drm_crtc_helper_funcs *funcs;
327
328                if (!crtc_state->mode_changed &&
329                    !crtc_state->connectors_changed)
330                        continue;
331
332                funcs = crtc->helper_private;
333                if (!funcs->mode_fixup)
334                        continue;
335
336                ret = funcs->mode_fixup(crtc, &crtc_state->mode,
337                                        &crtc_state->adjusted_mode);
338                if (!ret) {
339                        DRM_DEBUG_ATOMIC("[CRTC:%d] fixup failed\n",
340                                         crtc->base.id);
341                        return -EINVAL;
342                }
343        }
344
345        return 0;
346}
347
348/**
349 * drm_atomic_helper_check_modeset - validate state object for modeset changes
350 * @dev: DRM device
351 * @state: the driver state object
352 *
353 * Check the state object to see if the requested state is physically possible.
354 * This does all the crtc and connector related computations for an atomic
355 * update and adds any additional connectors needed for full modesets and calls
356 * down into ->mode_fixup functions of the driver backend.
357 *
358 * crtc_state->mode_changed is set when the input mode is changed.
359 * crtc_state->connectors_changed is set when a connector is added or
360 * removed from the crtc.
361 * crtc_state->active_changed is set when crtc_state->active changes,
362 * which is used for dpms.
363 *
364 * IMPORTANT:
365 *
366 * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a
367 * plane update can't be done without a full modeset) _must_ call this function
368 * afterwards after that change. It is permitted to call this function multiple
369 * times for the same update, e.g. when the ->atomic_check functions depend upon
370 * the adjusted dotclock for fifo space allocation and watermark computation.
371 *
372 * RETURNS
373 * Zero for success or -errno
374 */
375int
376drm_atomic_helper_check_modeset(struct drm_device *dev,
377                                struct drm_atomic_state *state)
378{
379        struct drm_crtc *crtc;
380        struct drm_crtc_state *crtc_state;
381        struct drm_connector *connector;
382        struct drm_connector_state *connector_state;
383        int i, ret;
384
385        for_each_crtc_in_state(state, crtc, crtc_state, i) {
386                if (!drm_mode_equal(&crtc->state->mode, &crtc_state->mode)) {
387                        DRM_DEBUG_ATOMIC("[CRTC:%d] mode changed\n",
388                                         crtc->base.id);
389                        crtc_state->mode_changed = true;
390                }
391
392                if (crtc->state->enable != crtc_state->enable) {
393                        DRM_DEBUG_ATOMIC("[CRTC:%d] enable changed\n",
394                                         crtc->base.id);
395
396                        /*
397                         * For clarity this assignment is done here, but
398                         * enable == 0 is only true when there are no
399                         * connectors and a NULL mode.
400                         *
401                         * The other way around is true as well. enable != 0
402                         * iff connectors are attached and a mode is set.
403                         */
404                        crtc_state->mode_changed = true;
405                        crtc_state->connectors_changed = true;
406                }
407        }
408
409        for_each_connector_in_state(state, connector, connector_state, i) {
410                /*
411                 * This only sets crtc->mode_changed for routing changes,
412                 * drivers must set crtc->mode_changed themselves when connector
413                 * properties need to be updated.
414                 */
415                ret = update_connector_routing(state, i);
416                if (ret)
417                        return ret;
418        }
419
420        /*
421         * After all the routing has been prepared we need to add in any
422         * connector which is itself unchanged, but who's crtc changes it's
423         * configuration. This must be done before calling mode_fixup in case a
424         * crtc only changed its mode but has the same set of connectors.
425         */
426        for_each_crtc_in_state(state, crtc, crtc_state, i) {
427                int num_connectors;
428
429                /*
430                 * We must set ->active_changed after walking connectors for
431                 * otherwise an update that only changes active would result in
432                 * a full modeset because update_connector_routing force that.
433                 */
434                if (crtc->state->active != crtc_state->active) {
435                        DRM_DEBUG_ATOMIC("[CRTC:%d] active changed\n",
436                                         crtc->base.id);
437                        crtc_state->active_changed = true;
438                }
439
440                if (!drm_atomic_crtc_needs_modeset(crtc_state))
441                        continue;
442
443                DRM_DEBUG_ATOMIC("[CRTC:%d] needs all connectors, enable: %c, active: %c\n",
444                                 crtc->base.id,
445                                 crtc_state->enable ? 'y' : 'n',
446                              crtc_state->active ? 'y' : 'n');
447
448                ret = drm_atomic_add_affected_connectors(state, crtc);
449                if (ret != 0)
450                        return ret;
451
452                ret = drm_atomic_add_affected_planes(state, crtc);
453                if (ret != 0)
454                        return ret;
455
456                num_connectors = drm_atomic_connectors_for_crtc(state,
457                                                                crtc);
458
459                if (crtc_state->enable != !!num_connectors) {
460                        DRM_DEBUG_ATOMIC("[CRTC:%d] enabled/connectors mismatch\n",
461                                         crtc->base.id);
462
463                        return -EINVAL;
464                }
465        }
466
467        return mode_fixup(state);
468}
469EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
470
471/**
472 * drm_atomic_helper_check_planes - validate state object for planes changes
473 * @dev: DRM device
474 * @state: the driver state object
475 *
476 * Check the state object to see if the requested state is physically possible.
477 * This does all the plane update related checks using by calling into the
478 * ->atomic_check hooks provided by the driver.
479 *
480 * It also sets crtc_state->planes_changed to indicate that a crtc has
481 * updated planes.
482 *
483 * RETURNS
484 * Zero for success or -errno
485 */
486int
487drm_atomic_helper_check_planes(struct drm_device *dev,
488                               struct drm_atomic_state *state)
489{
490        struct drm_crtc *crtc;
491        struct drm_crtc_state *crtc_state;
492        struct drm_plane *plane;
493        struct drm_plane_state *plane_state;
494        int i, ret = 0;
495
496        for_each_plane_in_state(state, plane, plane_state, i) {
497                const struct drm_plane_helper_funcs *funcs;
498
499                funcs = plane->helper_private;
500
501                drm_atomic_helper_plane_changed(state, plane_state, plane);
502
503                if (!funcs || !funcs->atomic_check)
504                        continue;
505
506                ret = funcs->atomic_check(plane, plane_state);
507                if (ret) {
508                        DRM_DEBUG_ATOMIC("[PLANE:%d] atomic driver check failed\n",
509                                         plane->base.id);
510                        return ret;
511                }
512        }
513
514        for_each_crtc_in_state(state, crtc, crtc_state, i) {
515                const struct drm_crtc_helper_funcs *funcs;
516
517                funcs = crtc->helper_private;
518
519                if (!funcs || !funcs->atomic_check)
520                        continue;
521
522                ret = funcs->atomic_check(crtc, state->crtc_states[i]);
523                if (ret) {
524                        DRM_DEBUG_ATOMIC("[CRTC:%d] atomic driver check failed\n",
525                                         crtc->base.id);
526                        return ret;
527                }
528        }
529
530        return ret;
531}
532EXPORT_SYMBOL(drm_atomic_helper_check_planes);
533
534/**
535 * drm_atomic_helper_check - validate state object
536 * @dev: DRM device
537 * @state: the driver state object
538 *
539 * Check the state object to see if the requested state is physically possible.
540 * Only crtcs and planes have check callbacks, so for any additional (global)
541 * checking that a driver needs it can simply wrap that around this function.
542 * Drivers without such needs can directly use this as their ->atomic_check()
543 * callback.
544 *
545 * This just wraps the two parts of the state checking for planes and modeset
546 * state in the default order: First it calls drm_atomic_helper_check_modeset()
547 * and then drm_atomic_helper_check_planes(). The assumption is that the
548 * ->atomic_check functions depend upon an updated adjusted_mode.clock to
549 * e.g. properly compute watermarks.
550 *
551 * RETURNS
552 * Zero for success or -errno
553 */
554int drm_atomic_helper_check(struct drm_device *dev,
555                            struct drm_atomic_state *state)
556{
557        int ret;
558
559        ret = drm_atomic_helper_check_modeset(dev, state);
560        if (ret)
561                return ret;
562
563        ret = drm_atomic_helper_check_planes(dev, state);
564        if (ret)
565                return ret;
566
567        return ret;
568}
569EXPORT_SYMBOL(drm_atomic_helper_check);
570
571static void
572disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
573{
574        struct drm_connector *connector;
575        struct drm_connector_state *old_conn_state;
576        struct drm_crtc *crtc;
577        struct drm_crtc_state *old_crtc_state;
578        int i;
579
580        for_each_connector_in_state(old_state, connector, old_conn_state, i) {
581                const struct drm_encoder_helper_funcs *funcs;
582                struct drm_encoder *encoder;
583                struct drm_crtc_state *old_crtc_state;
584
585                /* Shut down everything that's in the changeset and currently
586                 * still on. So need to check the old, saved state. */
587                if (!old_conn_state->crtc)
588                        continue;
589
590                old_crtc_state = old_state->crtc_states[drm_crtc_index(old_conn_state->crtc)];
591
592                if (!old_crtc_state->active ||
593                    !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
594                        continue;
595
596                encoder = old_conn_state->best_encoder;
597
598                /* We shouldn't get this far if we didn't previously have
599                 * an encoder.. but WARN_ON() rather than explode.
600                 */
601                if (WARN_ON(!encoder))
602                        continue;
603
604                funcs = encoder->helper_private;
605
606                DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
607                                 encoder->base.id, encoder->name);
608
609                /*
610                 * Each encoder has at most one connector (since we always steal
611                 * it away), so we won't call disable hooks twice.
612                 */
613                drm_bridge_disable(encoder->bridge);
614
615                /* Right function depends upon target state. */
616                if (connector->state->crtc && funcs->prepare)
617                        funcs->prepare(encoder);
618                else if (funcs->disable)
619                        funcs->disable(encoder);
620                else
621                        funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
622
623                drm_bridge_post_disable(encoder->bridge);
624        }
625
626        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
627                const struct drm_crtc_helper_funcs *funcs;
628
629                /* Shut down everything that needs a full modeset. */
630                if (!drm_atomic_crtc_needs_modeset(crtc->state))
631                        continue;
632
633                if (!old_crtc_state->active)
634                        continue;
635
636                funcs = crtc->helper_private;
637
638                DRM_DEBUG_ATOMIC("disabling [CRTC:%d]\n",
639                                 crtc->base.id);
640
641
642                /* Right function depends upon target state. */
643                if (crtc->state->enable && funcs->prepare)
644                        funcs->prepare(crtc);
645                else if (funcs->disable)
646                        funcs->disable(crtc);
647                else
648                        funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
649        }
650}
651
652/**
653 * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
654 * @dev: DRM device
655 * @old_state: atomic state object with old state structures
656 *
657 * This function updates all the various legacy modeset state pointers in
658 * connectors, encoders and crtcs. It also updates the timestamping constants
659 * used for precise vblank timestamps by calling
660 * drm_calc_timestamping_constants().
661 *
662 * Drivers can use this for building their own atomic commit if they don't have
663 * a pure helper-based modeset implementation.
664 */
665void
666drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
667                                              struct drm_atomic_state *old_state)
668{
669        struct drm_connector *connector;
670        struct drm_connector_state *old_conn_state;
671        struct drm_crtc *crtc;
672        struct drm_crtc_state *old_crtc_state;
673        int i;
674
675        /* clear out existing links and update dpms */
676        for_each_connector_in_state(old_state, connector, old_conn_state, i) {
677                if (connector->encoder) {
678                        WARN_ON(!connector->encoder->crtc);
679
680                        connector->encoder->crtc = NULL;
681                        connector->encoder = NULL;
682                }
683
684                crtc = connector->state->crtc;
685                if ((!crtc && old_conn_state->crtc) ||
686                    (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
687                        struct drm_property *dpms_prop =
688                                dev->mode_config.dpms_property;
689                        int mode = DRM_MODE_DPMS_OFF;
690
691                        if (crtc && crtc->state->active)
692                                mode = DRM_MODE_DPMS_ON;
693
694                        connector->dpms = mode;
695                        drm_object_property_set_value(&connector->base,
696                                                      dpms_prop, mode);
697                }
698        }
699
700        /* set new links */
701        for_each_connector_in_state(old_state, connector, old_conn_state, i) {
702                if (!connector->state->crtc)
703                        continue;
704
705                if (WARN_ON(!connector->state->best_encoder))
706                        continue;
707
708                connector->encoder = connector->state->best_encoder;
709                connector->encoder->crtc = connector->state->crtc;
710        }
711
712        /* set legacy state in the crtc structure */
713        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
714                struct drm_plane *primary = crtc->primary;
715
716                crtc->mode = crtc->state->mode;
717                crtc->enabled = crtc->state->enable;
718
719                if (drm_atomic_get_existing_plane_state(old_state, primary) &&
720                    primary->state->crtc == crtc) {
721                        crtc->x = primary->state->src_x >> 16;
722                        crtc->y = primary->state->src_y >> 16;
723                }
724
725                if (crtc->state->enable)
726                        drm_calc_timestamping_constants(crtc,
727                                                        &crtc->state->adjusted_mode);
728        }
729}
730EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
731
732static void
733crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
734{
735        struct drm_crtc *crtc;
736        struct drm_crtc_state *old_crtc_state;
737        struct drm_connector *connector;
738        struct drm_connector_state *old_conn_state;
739        int i;
740
741        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
742                const struct drm_crtc_helper_funcs *funcs;
743
744                if (!crtc->state->mode_changed)
745                        continue;
746
747                funcs = crtc->helper_private;
748
749                if (crtc->state->enable && funcs->mode_set_nofb) {
750                        DRM_DEBUG_ATOMIC("modeset on [CRTC:%d]\n",
751                                         crtc->base.id);
752
753                        funcs->mode_set_nofb(crtc);
754                }
755        }
756
757        for_each_connector_in_state(old_state, connector, old_conn_state, i) {
758                const struct drm_encoder_helper_funcs *funcs;
759                struct drm_crtc_state *new_crtc_state;
760                struct drm_encoder *encoder;
761                struct drm_display_mode *mode, *adjusted_mode;
762
763                if (!connector->state->best_encoder)
764                        continue;
765
766                encoder = connector->state->best_encoder;
767                funcs = encoder->helper_private;
768                new_crtc_state = connector->state->crtc->state;
769                mode = &new_crtc_state->mode;
770                adjusted_mode = &new_crtc_state->adjusted_mode;
771
772                if (!new_crtc_state->mode_changed)
773                        continue;
774
775                DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
776                                 encoder->base.id, encoder->name);
777
778                /*
779                 * Each encoder has at most one connector (since we always steal
780                 * it away), so we won't call mode_set hooks twice.
781                 */
782                if (funcs->mode_set)
783                        funcs->mode_set(encoder, mode, adjusted_mode);
784
785                drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
786        }
787}
788
789/**
790 * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
791 * @dev: DRM device
792 * @old_state: atomic state object with old state structures
793 *
794 * This function shuts down all the outputs that need to be shut down and
795 * prepares them (if required) with the new mode.
796 *
797 * For compatibility with legacy crtc helpers this should be called before
798 * drm_atomic_helper_commit_planes(), which is what the default commit function
799 * does. But drivers with different needs can group the modeset commits together
800 * and do the plane commits at the end. This is useful for drivers doing runtime
801 * PM since planes updates then only happen when the CRTC is actually enabled.
802 */
803void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
804                                               struct drm_atomic_state *old_state)
805{
806        disable_outputs(dev, old_state);
807
808        drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
809
810        crtc_set_mode(dev, old_state);
811}
812EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
813
814/**
815 * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
816 * @dev: DRM device
817 * @old_state: atomic state object with old state structures
818 *
819 * This function enables all the outputs with the new configuration which had to
820 * be turned off for the update.
821 *
822 * For compatibility with legacy crtc helpers this should be called after
823 * drm_atomic_helper_commit_planes(), which is what the default commit function
824 * does. But drivers with different needs can group the modeset commits together
825 * and do the plane commits at the end. This is useful for drivers doing runtime
826 * PM since planes updates then only happen when the CRTC is actually enabled.
827 */
828void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
829                                              struct drm_atomic_state *old_state)
830{
831        struct drm_crtc *crtc;
832        struct drm_crtc_state *old_crtc_state;
833        struct drm_connector *connector;
834        struct drm_connector_state *old_conn_state;
835        int i;
836
837        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
838                const struct drm_crtc_helper_funcs *funcs;
839
840                /* Need to filter out CRTCs where only planes change. */
841                if (!drm_atomic_crtc_needs_modeset(crtc->state))
842                        continue;
843
844                if (!crtc->state->active)
845                        continue;
846
847                funcs = crtc->helper_private;
848
849                if (crtc->state->enable) {
850                        DRM_DEBUG_ATOMIC("enabling [CRTC:%d]\n",
851                                         crtc->base.id);
852
853                        if (funcs->enable)
854                                funcs->enable(crtc);
855                        else
856                                funcs->commit(crtc);
857                }
858        }
859
860        for_each_connector_in_state(old_state, connector, old_conn_state, i) {
861                const struct drm_encoder_helper_funcs *funcs;
862                struct drm_encoder *encoder;
863
864                if (!connector->state->best_encoder)
865                        continue;
866
867                if (!connector->state->crtc->state->active ||
868                    !drm_atomic_crtc_needs_modeset(connector->state->crtc->state))
869                        continue;
870
871                encoder = connector->state->best_encoder;
872                funcs = encoder->helper_private;
873
874                DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
875                                 encoder->base.id, encoder->name);
876
877                /*
878                 * Each encoder has at most one connector (since we always steal
879                 * it away), so we won't call enable hooks twice.
880                 */
881                drm_bridge_pre_enable(encoder->bridge);
882
883                if (funcs->enable)
884                        funcs->enable(encoder);
885                else
886                        funcs->commit(encoder);
887
888                drm_bridge_enable(encoder->bridge);
889        }
890}
891EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
892
893static void wait_for_fences(struct drm_device *dev,
894                            struct drm_atomic_state *state)
895{
896        struct drm_plane *plane;
897        struct drm_plane_state *plane_state;
898        int i;
899
900        for_each_plane_in_state(state, plane, plane_state, i) {
901                if (!plane->state->fence)
902                        continue;
903
904                WARN_ON(!plane->state->fb);
905
906                fence_wait(plane->state->fence, false);
907                fence_put(plane->state->fence);
908                plane->state->fence = NULL;
909        }
910}
911
912static bool framebuffer_changed(struct drm_device *dev,
913                                struct drm_atomic_state *old_state,
914                                struct drm_crtc *crtc)
915{
916        struct drm_plane *plane;
917        struct drm_plane_state *old_plane_state;
918        int i;
919
920        for_each_plane_in_state(old_state, plane, old_plane_state, i) {
921                if (plane->state->crtc != crtc &&
922                    old_plane_state->crtc != crtc)
923                        continue;
924
925                if (plane->state->fb != old_plane_state->fb)
926                        return true;
927        }
928
929        return false;
930}
931
932/**
933 * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
934 * @dev: DRM device
935 * @old_state: atomic state object with old state structures
936 *
937 * Helper to, after atomic commit, wait for vblanks on all effected
938 * crtcs (ie. before cleaning up old framebuffers using
939 * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the
940 * framebuffers have actually changed to optimize for the legacy cursor and
941 * plane update use-case.
942 */
943void
944drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
945                struct drm_atomic_state *old_state)
946{
947        struct drm_crtc *crtc;
948        struct drm_crtc_state *old_crtc_state;
949        int i, ret;
950
951        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
952                /* No one cares about the old state, so abuse it for tracking
953                 * and store whether we hold a vblank reference (and should do a
954                 * vblank wait) in the ->enable boolean. */
955                old_crtc_state->enable = false;
956
957                if (!crtc->state->enable)
958                        continue;
959
960                /* Legacy cursor ioctls are completely unsynced, and userspace
961                 * relies on that (by doing tons of cursor updates). */
962                if (old_state->legacy_cursor_update)
963                        continue;
964
965                if (!framebuffer_changed(dev, old_state, crtc))
966                        continue;
967
968                ret = drm_crtc_vblank_get(crtc);
969                if (ret != 0)
970                        continue;
971
972                old_crtc_state->enable = true;
973                old_crtc_state->last_vblank_count = drm_crtc_vblank_count(crtc);
974        }
975
976        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
977                if (!old_crtc_state->enable)
978                        continue;
979
980                ret = wait_event_timeout(dev->vblank[i].queue,
981                                old_crtc_state->last_vblank_count !=
982                                        drm_crtc_vblank_count(crtc),
983                                msecs_to_jiffies(50));
984
985                drm_crtc_vblank_put(crtc);
986        }
987}
988EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
989
990/**
991 * drm_atomic_helper_commit - commit validated state object
992 * @dev: DRM device
993 * @state: the driver state object
994 * @async: asynchronous commit
995 *
996 * This function commits a with drm_atomic_helper_check() pre-validated state
997 * object. This can still fail when e.g. the framebuffer reservation fails. For
998 * now this doesn't implement asynchronous commits.
999 *
1000 * Note that right now this function does not support async commits, and hence
1001 * driver writers must implement their own version for now. Also note that the
1002 * default ordering of how the various stages are called is to match the legacy
1003 * modeset helper library closest. One peculiarity of that is that it doesn't
1004 * mesh well with runtime PM at all.
1005 *
1006 * For drivers supporting runtime PM the recommended sequence is
1007 *
1008 *     drm_atomic_helper_commit_modeset_disables(dev, state);
1009 *
1010 *     drm_atomic_helper_commit_modeset_enables(dev, state);
1011 *
1012 *     drm_atomic_helper_commit_planes(dev, state, true);
1013 *
1014 * See the kerneldoc entries for these three functions for more details.
1015 *
1016 * RETURNS
1017 * Zero for success or -errno.
1018 */
1019int drm_atomic_helper_commit(struct drm_device *dev,
1020                             struct drm_atomic_state *state,
1021                             bool async)
1022{
1023        int ret;
1024
1025        if (async)
1026                return -EBUSY;
1027
1028        ret = drm_atomic_helper_prepare_planes(dev, state);
1029        if (ret)
1030                return ret;
1031
1032        /*
1033         * This is the point of no return - everything below never fails except
1034         * when the hw goes bonghits. Which means we can commit the new state on
1035         * the software side now.
1036         */
1037
1038        drm_atomic_helper_swap_state(dev, state);
1039
1040        /*
1041         * Everything below can be run asynchronously without the need to grab
1042         * any modeset locks at all under one condition: It must be guaranteed
1043         * that the asynchronous work has either been cancelled (if the driver
1044         * supports it, which at least requires that the framebuffers get
1045         * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
1046         * before the new state gets committed on the software side with
1047         * drm_atomic_helper_swap_state().
1048         *
1049         * This scheme allows new atomic state updates to be prepared and
1050         * checked in parallel to the asynchronous completion of the previous
1051         * update. Which is important since compositors need to figure out the
1052         * composition of the next frame right after having submitted the
1053         * current layout.
1054         */
1055
1056        wait_for_fences(dev, state);
1057
1058        drm_atomic_helper_commit_modeset_disables(dev, state);
1059
1060        drm_atomic_helper_commit_planes(dev, state, false);
1061
1062        drm_atomic_helper_commit_modeset_enables(dev, state);
1063
1064        drm_atomic_helper_wait_for_vblanks(dev, state);
1065
1066        drm_atomic_helper_cleanup_planes(dev, state);
1067
1068        drm_atomic_state_free(state);
1069
1070        return 0;
1071}
1072EXPORT_SYMBOL(drm_atomic_helper_commit);
1073
1074/**
1075 * DOC: implementing async commit
1076 *
1077 * For now the atomic helpers don't support async commit directly. If there is
1078 * real need it could be added though, using the dma-buf fence infrastructure
1079 * for generic synchronization with outstanding rendering.
1080 *
1081 * For now drivers have to implement async commit themselves, with the following
1082 * sequence being the recommended one:
1083 *
1084 * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1085 * which commit needs to call which can fail, so we want to run it first and
1086 * synchronously.
1087 *
1088 * 2. Synchronize with any outstanding asynchronous commit worker threads which
1089 * might be affected the new state update. This can be done by either cancelling
1090 * or flushing the work items, depending upon whether the driver can deal with
1091 * cancelled updates. Note that it is important to ensure that the framebuffer
1092 * cleanup is still done when cancelling.
1093 *
1094 * For sufficient parallelism it is recommended to have a work item per crtc
1095 * (for updates which don't touch global state) and a global one. Then we only
1096 * need to synchronize with the crtc work items for changed crtcs and the global
1097 * work item, which allows nice concurrent updates on disjoint sets of crtcs.
1098 *
1099 * 3. The software state is updated synchronously with
1100 * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
1101 * locks means concurrent callers never see inconsistent state. And doing this
1102 * while it's guaranteed that no relevant async worker runs means that async
1103 * workers do not need grab any locks. Actually they must not grab locks, for
1104 * otherwise the work flushing will deadlock.
1105 *
1106 * 4. Schedule a work item to do all subsequent steps, using the split-out
1107 * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1108 * then cleaning up the framebuffers after the old framebuffer is no longer
1109 * being displayed.
1110 */
1111
1112/**
1113 * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1114 * @dev: DRM device
1115 * @state: atomic state object with new state structures
1116 *
1117 * This function prepares plane state, specifically framebuffers, for the new
1118 * configuration. If any failure is encountered this function will call
1119 * ->cleanup_fb on any already successfully prepared framebuffer.
1120 *
1121 * Returns:
1122 * 0 on success, negative error code on failure.
1123 */
1124int drm_atomic_helper_prepare_planes(struct drm_device *dev,
1125                                     struct drm_atomic_state *state)
1126{
1127        int nplanes = dev->mode_config.num_total_plane;
1128        int ret, i;
1129
1130        for (i = 0; i < nplanes; i++) {
1131                const struct drm_plane_helper_funcs *funcs;
1132                struct drm_plane *plane = state->planes[i];
1133                struct drm_plane_state *plane_state = state->plane_states[i];
1134
1135                if (!plane)
1136                        continue;
1137
1138                funcs = plane->helper_private;
1139
1140                if (funcs->prepare_fb) {
1141                        ret = funcs->prepare_fb(plane, plane_state);
1142                        if (ret)
1143                                goto fail;
1144                }
1145        }
1146
1147        return 0;
1148
1149fail:
1150        for (i--; i >= 0; i--) {
1151                const struct drm_plane_helper_funcs *funcs;
1152                struct drm_plane *plane = state->planes[i];
1153                struct drm_plane_state *plane_state = state->plane_states[i];
1154
1155                if (!plane)
1156                        continue;
1157
1158                funcs = plane->helper_private;
1159
1160                if (funcs->cleanup_fb)
1161                        funcs->cleanup_fb(plane, plane_state);
1162
1163        }
1164
1165        return ret;
1166}
1167EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
1168
1169bool plane_crtc_active(struct drm_plane_state *state)
1170{
1171        return state->crtc && state->crtc->state->active;
1172}
1173
1174/**
1175 * drm_atomic_helper_commit_planes - commit plane state
1176 * @dev: DRM device
1177 * @old_state: atomic state object with old state structures
1178 * @active_only: Only commit on active CRTC if set
1179 *
1180 * This function commits the new plane state using the plane and atomic helper
1181 * functions for planes and crtcs. It assumes that the atomic state has already
1182 * been pushed into the relevant object state pointers, since this step can no
1183 * longer fail.
1184 *
1185 * It still requires the global state object @old_state to know which planes and
1186 * crtcs need to be updated though.
1187 *
1188 * Note that this function does all plane updates across all CRTCs in one step.
1189 * If the hardware can't support this approach look at
1190 * drm_atomic_helper_commit_planes_on_crtc() instead.
1191 *
1192 * Plane parameters can be updated by applications while the associated CRTC is
1193 * disabled. The DRM/KMS core will store the parameters in the plane state,
1194 * which will be available to the driver when the CRTC is turned on. As a result
1195 * most drivers don't need to be immediately notified of plane updates for a
1196 * disabled CRTC.
1197 *
1198 * Unless otherwise needed, drivers are advised to set the @active_only
1199 * parameters to true in order not to receive plane update notifications related
1200 * to a disabled CRTC. This avoids the need to manually ignore plane updates in
1201 * driver code when the driver and/or hardware can't or just don't need to deal
1202 * with updates on disabled CRTCs, for example when supporting runtime PM.
1203 *
1204 * The drm_atomic_helper_commit() default implementation only sets @active_only
1205 * to false to most closely match the behaviour of the legacy helpers. This should
1206 * not be copied blindly by drivers.
1207 */
1208void drm_atomic_helper_commit_planes(struct drm_device *dev,
1209                                     struct drm_atomic_state *old_state,
1210                                     bool active_only)
1211{
1212        struct drm_crtc *crtc;
1213        struct drm_crtc_state *old_crtc_state;
1214        struct drm_plane *plane;
1215        struct drm_plane_state *old_plane_state;
1216        int i;
1217
1218        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1219                const struct drm_crtc_helper_funcs *funcs;
1220
1221                funcs = crtc->helper_private;
1222
1223                if (!funcs || !funcs->atomic_begin)
1224                        continue;
1225
1226                if (active_only && !crtc->state->active)
1227                        continue;
1228
1229                funcs->atomic_begin(crtc, old_crtc_state);
1230        }
1231
1232        for_each_plane_in_state(old_state, plane, old_plane_state, i) {
1233                const struct drm_plane_helper_funcs *funcs;
1234                bool disabling;
1235
1236                funcs = plane->helper_private;
1237
1238                if (!funcs)
1239                        continue;
1240
1241                disabling = drm_atomic_plane_disabling(plane, old_plane_state);
1242
1243                if (active_only) {
1244                        /*
1245                         * Skip planes related to inactive CRTCs. If the plane
1246                         * is enabled use the state of the current CRTC. If the
1247                         * plane is being disabled use the state of the old
1248                         * CRTC to avoid skipping planes being disabled on an
1249                         * active CRTC.
1250                         */
1251                        if (!disabling && !plane_crtc_active(plane->state))
1252                                continue;
1253                        if (disabling && !plane_crtc_active(old_plane_state))
1254                                continue;
1255                }
1256
1257                /*
1258                 * Special-case disabling the plane if drivers support it.
1259                 */
1260                if (disabling && funcs->atomic_disable)
1261                        funcs->atomic_disable(plane, old_plane_state);
1262                else if (plane->state->crtc || disabling)
1263                        funcs->atomic_update(plane, old_plane_state);
1264        }
1265
1266        for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1267                const struct drm_crtc_helper_funcs *funcs;
1268
1269                funcs = crtc->helper_private;
1270
1271                if (!funcs || !funcs->atomic_flush)
1272                        continue;
1273
1274                if (active_only && !crtc->state->active)
1275                        continue;
1276
1277                funcs->atomic_flush(crtc, old_crtc_state);
1278        }
1279}
1280EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
1281
1282/**
1283 * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
1284 * @old_crtc_state: atomic state object with the old crtc state
1285 *
1286 * This function commits the new plane state using the plane and atomic helper
1287 * functions for planes on the specific crtc. It assumes that the atomic state
1288 * has already been pushed into the relevant object state pointers, since this
1289 * step can no longer fail.
1290 *
1291 * This function is useful when plane updates should be done crtc-by-crtc
1292 * instead of one global step like drm_atomic_helper_commit_planes() does.
1293 *
1294 * This function can only be savely used when planes are not allowed to move
1295 * between different CRTCs because this function doesn't handle inter-CRTC
1296 * depencies. Callers need to ensure that either no such depencies exist,
1297 * resolve them through ordering of commit calls or through some other means.
1298 */
1299void
1300drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
1301{
1302        const struct drm_crtc_helper_funcs *crtc_funcs;
1303        struct drm_crtc *crtc = old_crtc_state->crtc;
1304        struct drm_atomic_state *old_state = old_crtc_state->state;
1305        struct drm_plane *plane;
1306        unsigned plane_mask;
1307
1308        plane_mask = old_crtc_state->plane_mask;
1309        plane_mask |= crtc->state->plane_mask;
1310
1311        crtc_funcs = crtc->helper_private;
1312        if (crtc_funcs && crtc_funcs->atomic_begin)
1313                crtc_funcs->atomic_begin(crtc, old_crtc_state);
1314
1315        drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
1316                struct drm_plane_state *old_plane_state =
1317                        drm_atomic_get_existing_plane_state(old_state, plane);
1318                const struct drm_plane_helper_funcs *plane_funcs;
1319
1320                plane_funcs = plane->helper_private;
1321
1322                if (!old_plane_state || !plane_funcs)
1323                        continue;
1324
1325                WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
1326
1327                if (drm_atomic_plane_disabling(plane, old_plane_state) &&
1328                    plane_funcs->atomic_disable)
1329                        plane_funcs->atomic_disable(plane, old_plane_state);
1330                else if (plane->state->crtc ||
1331                         drm_atomic_plane_disabling(plane, old_plane_state))
1332                        plane_funcs->atomic_update(plane, old_plane_state);
1333        }
1334
1335        if (crtc_funcs && crtc_funcs->atomic_flush)
1336                crtc_funcs->atomic_flush(crtc, old_crtc_state);
1337}
1338EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
1339
1340/**
1341 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
1342 * @dev: DRM device
1343 * @old_state: atomic state object with old state structures
1344 *
1345 * This function cleans up plane state, specifically framebuffers, from the old
1346 * configuration. Hence the old configuration must be perserved in @old_state to
1347 * be able to call this function.
1348 *
1349 * This function must also be called on the new state when the atomic update
1350 * fails at any point after calling drm_atomic_helper_prepare_planes().
1351 */
1352void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
1353                                      struct drm_atomic_state *old_state)
1354{
1355        struct drm_plane *plane;
1356        struct drm_plane_state *plane_state;
1357        int i;
1358
1359        for_each_plane_in_state(old_state, plane, plane_state, i) {
1360                const struct drm_plane_helper_funcs *funcs;
1361
1362                funcs = plane->helper_private;
1363
1364                if (funcs->cleanup_fb)
1365                        funcs->cleanup_fb(plane, plane_state);
1366        }
1367}
1368EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
1369
1370/**
1371 * drm_atomic_helper_swap_state - store atomic state into current sw state
1372 * @dev: DRM device
1373 * @state: atomic state
1374 *
1375 * This function stores the atomic state into the current state pointers in all
1376 * driver objects. It should be called after all failing steps have been done
1377 * and succeeded, but before the actual hardware state is committed.
1378 *
1379 * For cleanup and error recovery the current state for all changed objects will
1380 * be swaped into @state.
1381 *
1382 * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
1383 *
1384 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
1385 *
1386 * 2. Do any other steps that might fail.
1387 *
1388 * 3. Put the staged state into the current state pointers with this function.
1389 *
1390 * 4. Actually commit the hardware state.
1391 *
1392 * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
1393 * contains the old state. Also do any other cleanup required with that state.
1394 */
1395void drm_atomic_helper_swap_state(struct drm_device *dev,
1396                                  struct drm_atomic_state *state)
1397{
1398        int i;
1399
1400        for (i = 0; i < dev->mode_config.num_connector; i++) {
1401                struct drm_connector *connector = state->connectors[i];
1402
1403                if (!connector)
1404                        continue;
1405
1406                connector->state->state = state;
1407                swap(state->connector_states[i], connector->state);
1408                connector->state->state = NULL;
1409        }
1410
1411        for (i = 0; i < dev->mode_config.num_crtc; i++) {
1412                struct drm_crtc *crtc = state->crtcs[i];
1413
1414                if (!crtc)
1415                        continue;
1416
1417                crtc->state->state = state;
1418                swap(state->crtc_states[i], crtc->state);
1419                crtc->state->state = NULL;
1420        }
1421
1422        for (i = 0; i < dev->mode_config.num_total_plane; i++) {
1423                struct drm_plane *plane = state->planes[i];
1424
1425                if (!plane)
1426                        continue;
1427
1428                plane->state->state = state;
1429                swap(state->plane_states[i], plane->state);
1430                plane->state->state = NULL;
1431        }
1432}
1433EXPORT_SYMBOL(drm_atomic_helper_swap_state);
1434
1435/**
1436 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
1437 * @plane: plane object to update
1438 * @crtc: owning CRTC of owning plane
1439 * @fb: framebuffer to flip onto plane
1440 * @crtc_x: x offset of primary plane on crtc
1441 * @crtc_y: y offset of primary plane on crtc
1442 * @crtc_w: width of primary plane rectangle on crtc
1443 * @crtc_h: height of primary plane rectangle on crtc
1444 * @src_x: x offset of @fb for panning
1445 * @src_y: y offset of @fb for panning
1446 * @src_w: width of source rectangle in @fb
1447 * @src_h: height of source rectangle in @fb
1448 *
1449 * Provides a default plane update handler using the atomic driver interface.
1450 *
1451 * RETURNS:
1452 * Zero on success, error code on failure
1453 */
1454int drm_atomic_helper_update_plane(struct drm_plane *plane,
1455                                   struct drm_crtc *crtc,
1456                                   struct drm_framebuffer *fb,
1457                                   int crtc_x, int crtc_y,
1458                                   unsigned int crtc_w, unsigned int crtc_h,
1459                                   uint32_t src_x, uint32_t src_y,
1460                                   uint32_t src_w, uint32_t src_h)
1461{
1462        struct drm_atomic_state *state;
1463        struct drm_plane_state *plane_state;
1464        int ret = 0;
1465
1466        state = drm_atomic_state_alloc(plane->dev);
1467        if (!state)
1468                return -ENOMEM;
1469
1470        state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1471retry:
1472        plane_state = drm_atomic_get_plane_state(state, plane);
1473        if (IS_ERR(plane_state)) {
1474                ret = PTR_ERR(plane_state);
1475                goto fail;
1476        }
1477
1478        ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
1479        if (ret != 0)
1480                goto fail;
1481        drm_atomic_set_fb_for_plane(plane_state, fb);
1482        plane_state->crtc_x = crtc_x;
1483        plane_state->crtc_y = crtc_y;
1484        plane_state->crtc_h = crtc_h;
1485        plane_state->crtc_w = crtc_w;
1486        plane_state->src_x = src_x;
1487        plane_state->src_y = src_y;
1488        plane_state->src_h = src_h;
1489        plane_state->src_w = src_w;
1490
1491        if (plane == crtc->cursor)
1492                state->legacy_cursor_update = true;
1493
1494        ret = drm_atomic_commit(state);
1495        if (ret != 0)
1496                goto fail;
1497
1498        /* Driver takes ownership of state on successful commit. */
1499        return 0;
1500fail:
1501        if (ret == -EDEADLK)
1502                goto backoff;
1503
1504        drm_atomic_state_free(state);
1505
1506        return ret;
1507backoff:
1508        drm_atomic_state_clear(state);
1509        drm_atomic_legacy_backoff(state);
1510
1511        /*
1512         * Someone might have exchanged the framebuffer while we dropped locks
1513         * in the backoff code. We need to fix up the fb refcount tracking the
1514         * core does for us.
1515         */
1516        plane->old_fb = plane->fb;
1517
1518        goto retry;
1519}
1520EXPORT_SYMBOL(drm_atomic_helper_update_plane);
1521
1522/**
1523 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
1524 * @plane: plane to disable
1525 *
1526 * Provides a default plane disable handler using the atomic driver interface.
1527 *
1528 * RETURNS:
1529 * Zero on success, error code on failure
1530 */
1531int drm_atomic_helper_disable_plane(struct drm_plane *plane)
1532{
1533        struct drm_atomic_state *state;
1534        struct drm_plane_state *plane_state;
1535        int ret = 0;
1536
1537        /*
1538         * FIXME: Without plane->crtc set we can't get at the implicit legacy
1539         * acquire context. The real fix will be to wire the acquire ctx through
1540         * everywhere we need it, but meanwhile prevent chaos by just skipping
1541         * this noop. The critical case is the cursor ioctls which a) only grab
1542         * crtc/cursor-plane locks (so we need the crtc to get at the right
1543         * acquire context) and b) can try to disable the plane multiple times.
1544         */
1545        if (!plane->crtc)
1546                return 0;
1547
1548        state = drm_atomic_state_alloc(plane->dev);
1549        if (!state)
1550                return -ENOMEM;
1551
1552        state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc);
1553retry:
1554        plane_state = drm_atomic_get_plane_state(state, plane);
1555        if (IS_ERR(plane_state)) {
1556                ret = PTR_ERR(plane_state);
1557                goto fail;
1558        }
1559
1560        if (plane_state->crtc && (plane == plane->crtc->cursor))
1561                plane_state->state->legacy_cursor_update = true;
1562
1563        ret = __drm_atomic_helper_disable_plane(plane, plane_state);
1564        if (ret != 0)
1565                goto fail;
1566
1567        ret = drm_atomic_commit(state);
1568        if (ret != 0)
1569                goto fail;
1570
1571        /* Driver takes ownership of state on successful commit. */
1572        return 0;
1573fail:
1574        if (ret == -EDEADLK)
1575                goto backoff;
1576
1577        drm_atomic_state_free(state);
1578
1579        return ret;
1580backoff:
1581        drm_atomic_state_clear(state);
1582        drm_atomic_legacy_backoff(state);
1583
1584        /*
1585         * Someone might have exchanged the framebuffer while we dropped locks
1586         * in the backoff code. We need to fix up the fb refcount tracking the
1587         * core does for us.
1588         */
1589        plane->old_fb = plane->fb;
1590
1591        goto retry;
1592}
1593EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
1594
1595/* just used from fb-helper and atomic-helper: */
1596int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
1597                struct drm_plane_state *plane_state)
1598{
1599        int ret;
1600
1601        ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
1602        if (ret != 0)
1603                return ret;
1604
1605        drm_atomic_set_fb_for_plane(plane_state, NULL);
1606        plane_state->crtc_x = 0;
1607        plane_state->crtc_y = 0;
1608        plane_state->crtc_h = 0;
1609        plane_state->crtc_w = 0;
1610        plane_state->src_x = 0;
1611        plane_state->src_y = 0;
1612        plane_state->src_h = 0;
1613        plane_state->src_w = 0;
1614
1615        return 0;
1616}
1617
1618static int update_output_state(struct drm_atomic_state *state,
1619                               struct drm_mode_set *set)
1620{
1621        struct drm_device *dev = set->crtc->dev;
1622        struct drm_crtc *crtc;
1623        struct drm_crtc_state *crtc_state;
1624        struct drm_connector *connector;
1625        struct drm_connector_state *conn_state;
1626        int ret, i, j;
1627
1628        ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
1629                               state->acquire_ctx);
1630        if (ret)
1631                return ret;
1632
1633        /* First grab all affected connector/crtc states. */
1634        for (i = 0; i < set->num_connectors; i++) {
1635                conn_state = drm_atomic_get_connector_state(state,
1636                                                            set->connectors[i]);
1637                if (IS_ERR(conn_state))
1638                        return PTR_ERR(conn_state);
1639        }
1640
1641        for_each_crtc_in_state(state, crtc, crtc_state, i) {
1642                ret = drm_atomic_add_affected_connectors(state, crtc);
1643                if (ret)
1644                        return ret;
1645        }
1646
1647        /* Then recompute connector->crtc links and crtc enabling state. */
1648        for_each_connector_in_state(state, connector, conn_state, i) {
1649                if (conn_state->crtc == set->crtc) {
1650                        ret = drm_atomic_set_crtc_for_connector(conn_state,
1651                                                                NULL);
1652                        if (ret)
1653                                return ret;
1654                }
1655
1656                for (j = 0; j < set->num_connectors; j++) {
1657                        if (set->connectors[j] == connector) {
1658                                ret = drm_atomic_set_crtc_for_connector(conn_state,
1659                                                                        set->crtc);
1660                                if (ret)
1661                                        return ret;
1662                                break;
1663                        }
1664                }
1665        }
1666
1667        for_each_crtc_in_state(state, crtc, crtc_state, i) {
1668                /* Don't update ->enable for the CRTC in the set_config request,
1669                 * since a mismatch would indicate a bug in the upper layers.
1670                 * The actual modeset code later on will catch any
1671                 * inconsistencies here. */
1672                if (crtc == set->crtc)
1673                        continue;
1674
1675                if (!drm_atomic_connectors_for_crtc(state, crtc)) {
1676                        ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
1677                                                                NULL);
1678                        if (ret < 0)
1679                                return ret;
1680
1681                        crtc_state->active = false;
1682                }
1683        }
1684
1685        return 0;
1686}
1687
1688/**
1689 * drm_atomic_helper_set_config - set a new config from userspace
1690 * @set: mode set configuration
1691 *
1692 * Provides a default crtc set_config handler using the atomic driver interface.
1693 *
1694 * Returns:
1695 * Returns 0 on success, negative errno numbers on failure.
1696 */
1697int drm_atomic_helper_set_config(struct drm_mode_set *set)
1698{
1699        struct drm_atomic_state *state;
1700        struct drm_crtc *crtc = set->crtc;
1701        int ret = 0;
1702
1703        state = drm_atomic_state_alloc(crtc->dev);
1704        if (!state)
1705                return -ENOMEM;
1706
1707        state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1708retry:
1709        ret = __drm_atomic_helper_set_config(set, state);
1710        if (ret != 0)
1711                goto fail;
1712
1713        ret = drm_atomic_commit(state);
1714        if (ret != 0)
1715                goto fail;
1716
1717        /* Driver takes ownership of state on successful commit. */
1718        return 0;
1719fail:
1720        if (ret == -EDEADLK)
1721                goto backoff;
1722
1723        drm_atomic_state_free(state);
1724
1725        return ret;
1726backoff:
1727        drm_atomic_state_clear(state);
1728        drm_atomic_legacy_backoff(state);
1729
1730        /*
1731         * Someone might have exchanged the framebuffer while we dropped locks
1732         * in the backoff code. We need to fix up the fb refcount tracking the
1733         * core does for us.
1734         */
1735        crtc->primary->old_fb = crtc->primary->fb;
1736
1737        goto retry;
1738}
1739EXPORT_SYMBOL(drm_atomic_helper_set_config);
1740
1741/* just used from fb-helper and atomic-helper: */
1742int __drm_atomic_helper_set_config(struct drm_mode_set *set,
1743                struct drm_atomic_state *state)
1744{
1745        struct drm_crtc_state *crtc_state;
1746        struct drm_plane_state *primary_state;
1747        struct drm_crtc *crtc = set->crtc;
1748        int hdisplay, vdisplay;
1749        int ret;
1750
1751        crtc_state = drm_atomic_get_crtc_state(state, crtc);
1752        if (IS_ERR(crtc_state))
1753                return PTR_ERR(crtc_state);
1754
1755        primary_state = drm_atomic_get_plane_state(state, crtc->primary);
1756        if (IS_ERR(primary_state))
1757                return PTR_ERR(primary_state);
1758
1759        if (!set->mode) {
1760                WARN_ON(set->fb);
1761                WARN_ON(set->num_connectors);
1762
1763                ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
1764                if (ret != 0)
1765                        return ret;
1766
1767                crtc_state->active = false;
1768
1769                ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
1770                if (ret != 0)
1771                        return ret;
1772
1773                drm_atomic_set_fb_for_plane(primary_state, NULL);
1774
1775                goto commit;
1776        }
1777
1778        WARN_ON(!set->fb);
1779        WARN_ON(!set->num_connectors);
1780
1781        ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
1782        if (ret != 0)
1783                return ret;
1784
1785        crtc_state->active = true;
1786
1787        ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
1788        if (ret != 0)
1789                return ret;
1790
1791        drm_crtc_get_hv_timing(set->mode, &hdisplay, &vdisplay);
1792
1793        drm_atomic_set_fb_for_plane(primary_state, set->fb);
1794        primary_state->crtc_x = 0;
1795        primary_state->crtc_y = 0;
1796        primary_state->crtc_h = vdisplay;
1797        primary_state->crtc_w = hdisplay;
1798        primary_state->src_x = set->x << 16;
1799        primary_state->src_y = set->y << 16;
1800        if (primary_state->rotation & (BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))) {
1801                primary_state->src_h = hdisplay << 16;
1802                primary_state->src_w = vdisplay << 16;
1803        } else {
1804                primary_state->src_h = vdisplay << 16;
1805                primary_state->src_w = hdisplay << 16;
1806        }
1807
1808commit:
1809        ret = update_output_state(state, set);
1810        if (ret)
1811                return ret;
1812
1813        return 0;
1814}
1815
1816/**
1817 * drm_atomic_helper_crtc_set_property - helper for crtc properties
1818 * @crtc: DRM crtc
1819 * @property: DRM property
1820 * @val: value of property
1821 *
1822 * Provides a default crtc set_property handler using the atomic driver
1823 * interface.
1824 *
1825 * RETURNS:
1826 * Zero on success, error code on failure
1827 */
1828int
1829drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc,
1830                                    struct drm_property *property,
1831                                    uint64_t val)
1832{
1833        struct drm_atomic_state *state;
1834        struct drm_crtc_state *crtc_state;
1835        int ret = 0;
1836
1837        state = drm_atomic_state_alloc(crtc->dev);
1838        if (!state)
1839                return -ENOMEM;
1840
1841        /* ->set_property is always called with all locks held. */
1842        state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
1843retry:
1844        crtc_state = drm_atomic_get_crtc_state(state, crtc);
1845        if (IS_ERR(crtc_state)) {
1846                ret = PTR_ERR(crtc_state);
1847                goto fail;
1848        }
1849
1850        ret = drm_atomic_crtc_set_property(crtc, crtc_state,
1851                        property, val);
1852        if (ret)
1853                goto fail;
1854
1855        ret = drm_atomic_commit(state);
1856        if (ret != 0)
1857                goto fail;
1858
1859        /* Driver takes ownership of state on successful commit. */
1860        return 0;
1861fail:
1862        if (ret == -EDEADLK)
1863                goto backoff;
1864
1865        drm_atomic_state_free(state);
1866
1867        return ret;
1868backoff:
1869        drm_atomic_state_clear(state);
1870        drm_atomic_legacy_backoff(state);
1871
1872        goto retry;
1873}
1874EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property);
1875
1876/**
1877 * drm_atomic_helper_plane_set_property - helper for plane properties
1878 * @plane: DRM plane
1879 * @property: DRM property
1880 * @val: value of property
1881 *
1882 * Provides a default plane set_property handler using the atomic driver
1883 * interface.
1884 *
1885 * RETURNS:
1886 * Zero on success, error code on failure
1887 */
1888int
1889drm_atomic_helper_plane_set_property(struct drm_plane *plane,
1890                                    struct drm_property *property,
1891                                    uint64_t val)
1892{
1893        struct drm_atomic_state *state;
1894        struct drm_plane_state *plane_state;
1895        int ret = 0;
1896
1897        state = drm_atomic_state_alloc(plane->dev);
1898        if (!state)
1899                return -ENOMEM;
1900
1901        /* ->set_property is always called with all locks held. */
1902        state->acquire_ctx = plane->dev->mode_config.acquire_ctx;
1903retry:
1904        plane_state = drm_atomic_get_plane_state(state, plane);
1905        if (IS_ERR(plane_state)) {
1906                ret = PTR_ERR(plane_state);
1907                goto fail;
1908        }
1909
1910        ret = drm_atomic_plane_set_property(plane, plane_state,
1911                        property, val);
1912        if (ret)
1913                goto fail;
1914
1915        ret = drm_atomic_commit(state);
1916        if (ret != 0)
1917                goto fail;
1918
1919        /* Driver takes ownership of state on successful commit. */
1920        return 0;
1921fail:
1922        if (ret == -EDEADLK)
1923                goto backoff;
1924
1925        drm_atomic_state_free(state);
1926
1927        return ret;
1928backoff:
1929        drm_atomic_state_clear(state);
1930        drm_atomic_legacy_backoff(state);
1931
1932        goto retry;
1933}
1934EXPORT_SYMBOL(drm_atomic_helper_plane_set_property);
1935
1936/**
1937 * drm_atomic_helper_connector_set_property - helper for connector properties
1938 * @connector: DRM connector
1939 * @property: DRM property
1940 * @val: value of property
1941 *
1942 * Provides a default connector set_property handler using the atomic driver
1943 * interface.
1944 *
1945 * RETURNS:
1946 * Zero on success, error code on failure
1947 */
1948int
1949drm_atomic_helper_connector_set_property(struct drm_connector *connector,
1950                                    struct drm_property *property,
1951                                    uint64_t val)
1952{
1953        struct drm_atomic_state *state;
1954        struct drm_connector_state *connector_state;
1955        int ret = 0;
1956
1957        state = drm_atomic_state_alloc(connector->dev);
1958        if (!state)
1959                return -ENOMEM;
1960
1961        /* ->set_property is always called with all locks held. */
1962        state->acquire_ctx = connector->dev->mode_config.acquire_ctx;
1963retry:
1964        connector_state = drm_atomic_get_connector_state(state, connector);
1965        if (IS_ERR(connector_state)) {
1966                ret = PTR_ERR(connector_state);
1967                goto fail;
1968        }
1969
1970        ret = drm_atomic_connector_set_property(connector, connector_state,
1971                        property, val);
1972        if (ret)
1973                goto fail;
1974
1975        ret = drm_atomic_commit(state);
1976        if (ret != 0)
1977                goto fail;
1978
1979        /* Driver takes ownership of state on successful commit. */
1980        return 0;
1981fail:
1982        if (ret == -EDEADLK)
1983                goto backoff;
1984
1985        drm_atomic_state_free(state);
1986
1987        return ret;
1988backoff:
1989        drm_atomic_state_clear(state);
1990        drm_atomic_legacy_backoff(state);
1991
1992        goto retry;
1993}
1994EXPORT_SYMBOL(drm_atomic_helper_connector_set_property);
1995
1996/**
1997 * drm_atomic_helper_page_flip - execute a legacy page flip
1998 * @crtc: DRM crtc
1999 * @fb: DRM framebuffer
2000 * @event: optional DRM event to signal upon completion
2001 * @flags: flip flags for non-vblank sync'ed updates
2002 *
2003 * Provides a default page flip implementation using the atomic driver interface.
2004 *
2005 * Note that for now so called async page flips (i.e. updates which are not
2006 * synchronized to vblank) are not supported, since the atomic interfaces have
2007 * no provisions for this yet.
2008 *
2009 * Returns:
2010 * Returns 0 on success, negative errno numbers on failure.
2011 */
2012int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
2013                                struct drm_framebuffer *fb,
2014                                struct drm_pending_vblank_event *event,
2015                                uint32_t flags)
2016{
2017        struct drm_plane *plane = crtc->primary;
2018        struct drm_atomic_state *state;
2019        struct drm_plane_state *plane_state;
2020        struct drm_crtc_state *crtc_state;
2021        int ret = 0;
2022
2023        if (flags & DRM_MODE_PAGE_FLIP_ASYNC)
2024                return -EINVAL;
2025
2026        state = drm_atomic_state_alloc(plane->dev);
2027        if (!state)
2028                return -ENOMEM;
2029
2030        state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
2031retry:
2032        crtc_state = drm_atomic_get_crtc_state(state, crtc);
2033        if (IS_ERR(crtc_state)) {
2034                ret = PTR_ERR(crtc_state);
2035                goto fail;
2036        }
2037        crtc_state->event = event;
2038
2039        plane_state = drm_atomic_get_plane_state(state, plane);
2040        if (IS_ERR(plane_state)) {
2041                ret = PTR_ERR(plane_state);
2042                goto fail;
2043        }
2044
2045        ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2046        if (ret != 0)
2047                goto fail;
2048        drm_atomic_set_fb_for_plane(plane_state, fb);
2049
2050        ret = drm_atomic_async_commit(state);
2051        if (ret != 0)
2052                goto fail;
2053
2054        /* Driver takes ownership of state on successful async commit. */
2055        return 0;
2056fail:
2057        if (ret == -EDEADLK)
2058                goto backoff;
2059
2060        drm_atomic_state_free(state);
2061
2062        return ret;
2063backoff:
2064        drm_atomic_state_clear(state);
2065        drm_atomic_legacy_backoff(state);
2066
2067        /*
2068         * Someone might have exchanged the framebuffer while we dropped locks
2069         * in the backoff code. We need to fix up the fb refcount tracking the
2070         * core does for us.
2071         */
2072        plane->old_fb = plane->fb;
2073
2074        goto retry;
2075}
2076EXPORT_SYMBOL(drm_atomic_helper_page_flip);
2077
2078/**
2079 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation
2080 * @connector: affected connector
2081 * @mode: DPMS mode
2082 *
2083 * This is the main helper function provided by the atomic helper framework for
2084 * implementing the legacy DPMS connector interface. It computes the new desired
2085 * ->active state for the corresponding CRTC (if the connector is enabled) and
2086 *  updates it.
2087 *
2088 * Returns:
2089 * Returns 0 on success, negative errno numbers on failure.
2090 */
2091int drm_atomic_helper_connector_dpms(struct drm_connector *connector,
2092                                     int mode)
2093{
2094        struct drm_mode_config *config = &connector->dev->mode_config;
2095        struct drm_atomic_state *state;
2096        struct drm_crtc_state *crtc_state;
2097        struct drm_crtc *crtc;
2098        struct drm_connector *tmp_connector;
2099        int ret;
2100        bool active = false;
2101        int old_mode = connector->dpms;
2102
2103        if (mode != DRM_MODE_DPMS_ON)
2104                mode = DRM_MODE_DPMS_OFF;
2105
2106        connector->dpms = mode;
2107        crtc = connector->state->crtc;
2108
2109        if (!crtc)
2110                return 0;
2111
2112        state = drm_atomic_state_alloc(connector->dev);
2113        if (!state)
2114                return -ENOMEM;
2115
2116        state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
2117retry:
2118        crtc_state = drm_atomic_get_crtc_state(state, crtc);
2119        if (IS_ERR(crtc_state)) {
2120                ret = PTR_ERR(crtc_state);
2121                goto fail;
2122        }
2123
2124        WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
2125
2126        drm_for_each_connector(tmp_connector, connector->dev) {
2127                if (tmp_connector->state->crtc != crtc)
2128                        continue;
2129
2130                if (tmp_connector->dpms == DRM_MODE_DPMS_ON) {
2131                        active = true;
2132                        break;
2133                }
2134        }
2135        crtc_state->active = active;
2136
2137        ret = drm_atomic_commit(state);
2138        if (ret != 0)
2139                goto fail;
2140
2141        /* Driver takes ownership of state on successful commit. */
2142        return 0;
2143fail:
2144        if (ret == -EDEADLK)
2145                goto backoff;
2146
2147        connector->dpms = old_mode;
2148        drm_atomic_state_free(state);
2149
2150        return ret;
2151backoff:
2152        drm_atomic_state_clear(state);
2153        drm_atomic_legacy_backoff(state);
2154
2155        goto retry;
2156}
2157EXPORT_SYMBOL(drm_atomic_helper_connector_dpms);
2158
2159/**
2160 * DOC: atomic state reset and initialization
2161 *
2162 * Both the drm core and the atomic helpers assume that there is always the full
2163 * and correct atomic software state for all connectors, CRTCs and planes
2164 * available. Which is a bit a problem on driver load and also after system
2165 * suspend. One way to solve this is to have a hardware state read-out
2166 * infrastructure which reconstructs the full software state (e.g. the i915
2167 * driver).
2168 *
2169 * The simpler solution is to just reset the software state to everything off,
2170 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
2171 * the atomic helpers provide default reset implementations for all hooks.
2172 */
2173
2174/**
2175 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs
2176 * @crtc: drm CRTC
2177 *
2178 * Resets the atomic state for @crtc by freeing the state pointer (which might
2179 * be NULL, e.g. at driver load time) and allocating a new empty state object.
2180 */
2181void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
2182{
2183        if (crtc->state && crtc->state->mode_blob)
2184                drm_property_unreference_blob(crtc->state->mode_blob);
2185        kfree(crtc->state);
2186        crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
2187
2188        if (crtc->state)
2189                crtc->state->crtc = crtc;
2190}
2191EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
2192
2193/**
2194 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
2195 * @crtc: CRTC object
2196 * @state: atomic CRTC state
2197 *
2198 * Copies atomic state from a CRTC's current state and resets inferred values.
2199 * This is useful for drivers that subclass the CRTC state.
2200 */
2201void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
2202                                              struct drm_crtc_state *state)
2203{
2204        memcpy(state, crtc->state, sizeof(*state));
2205
2206        if (state->mode_blob)
2207                drm_property_reference_blob(state->mode_blob);
2208        state->mode_changed = false;
2209        state->active_changed = false;
2210        state->planes_changed = false;
2211        state->connectors_changed = false;
2212        state->event = NULL;
2213}
2214EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
2215
2216/**
2217 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
2218 * @crtc: drm CRTC
2219 *
2220 * Default CRTC state duplicate hook for drivers which don't have their own
2221 * subclassed CRTC state structure.
2222 */
2223struct drm_crtc_state *
2224drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
2225{
2226        struct drm_crtc_state *state;
2227
2228        if (WARN_ON(!crtc->state))
2229                return NULL;
2230
2231        state = kmalloc(sizeof(*state), GFP_KERNEL);
2232        if (state)
2233                __drm_atomic_helper_crtc_duplicate_state(crtc, state);
2234
2235        return state;
2236}
2237EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
2238
2239/**
2240 * __drm_atomic_helper_crtc_destroy_state - release CRTC state
2241 * @crtc: CRTC object
2242 * @state: CRTC state object to release
2243 *
2244 * Releases all resources stored in the CRTC state without actually freeing
2245 * the memory of the CRTC state. This is useful for drivers that subclass the
2246 * CRTC state.
2247 */
2248void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2249                                            struct drm_crtc_state *state)
2250{
2251        if (state->mode_blob)
2252                drm_property_unreference_blob(state->mode_blob);
2253}
2254EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
2255
2256/**
2257 * drm_atomic_helper_crtc_destroy_state - default state destroy hook
2258 * @crtc: drm CRTC
2259 * @state: CRTC state object to release
2260 *
2261 * Default CRTC state destroy hook for drivers which don't have their own
2262 * subclassed CRTC state structure.
2263 */
2264void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2265                                          struct drm_crtc_state *state)
2266{
2267        __drm_atomic_helper_crtc_destroy_state(crtc, state);
2268        kfree(state);
2269}
2270EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
2271
2272/**
2273 * drm_atomic_helper_plane_reset - default ->reset hook for planes
2274 * @plane: drm plane
2275 *
2276 * Resets the atomic state for @plane by freeing the state pointer (which might
2277 * be NULL, e.g. at driver load time) and allocating a new empty state object.
2278 */
2279void drm_atomic_helper_plane_reset(struct drm_plane *plane)
2280{
2281        if (plane->state && plane->state->fb)
2282                drm_framebuffer_unreference(plane->state->fb);
2283
2284        kfree(plane->state);
2285        plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
2286
2287        if (plane->state)
2288                plane->state->plane = plane;
2289}
2290EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
2291
2292/**
2293 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
2294 * @plane: plane object
2295 * @state: atomic plane state
2296 *
2297 * Copies atomic state from a plane's current state. This is useful for
2298 * drivers that subclass the plane state.
2299 */
2300void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
2301                                               struct drm_plane_state *state)
2302{
2303        memcpy(state, plane->state, sizeof(*state));
2304
2305        if (state->fb)
2306                drm_framebuffer_reference(state->fb);
2307}
2308EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
2309
2310/**
2311 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
2312 * @plane: drm plane
2313 *
2314 * Default plane state duplicate hook for drivers which don't have their own
2315 * subclassed plane state structure.
2316 */
2317struct drm_plane_state *
2318drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
2319{
2320        struct drm_plane_state *state;
2321
2322        if (WARN_ON(!plane->state))
2323                return NULL;
2324
2325        state = kmalloc(sizeof(*state), GFP_KERNEL);
2326        if (state)
2327                __drm_atomic_helper_plane_duplicate_state(plane, state);
2328
2329        return state;
2330}
2331EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
2332
2333/**
2334 * __drm_atomic_helper_plane_destroy_state - release plane state
2335 * @plane: plane object
2336 * @state: plane state object to release
2337 *
2338 * Releases all resources stored in the plane state without actually freeing
2339 * the memory of the plane state. This is useful for drivers that subclass the
2340 * plane state.
2341 */
2342void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2343                                             struct drm_plane_state *state)
2344{
2345        if (state->fb)
2346                drm_framebuffer_unreference(state->fb);
2347}
2348EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
2349
2350/**
2351 * drm_atomic_helper_plane_destroy_state - default state destroy hook
2352 * @plane: drm plane
2353 * @state: plane state object to release
2354 *
2355 * Default plane state destroy hook for drivers which don't have their own
2356 * subclassed plane state structure.
2357 */
2358void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2359                                           struct drm_plane_state *state)
2360{
2361        __drm_atomic_helper_plane_destroy_state(plane, state);
2362        kfree(state);
2363}
2364EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
2365
2366/**
2367 * drm_atomic_helper_connector_reset - default ->reset hook for connectors
2368 * @connector: drm connector
2369 *
2370 * Resets the atomic state for @connector by freeing the state pointer (which
2371 * might be NULL, e.g. at driver load time) and allocating a new empty state
2372 * object.
2373 */
2374void drm_atomic_helper_connector_reset(struct drm_connector *connector)
2375{
2376        kfree(connector->state);
2377        connector->state = kzalloc(sizeof(*connector->state), GFP_KERNEL);
2378
2379        if (connector->state)
2380                connector->state->connector = connector;
2381}
2382EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
2383
2384/**
2385 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
2386 * @connector: connector object
2387 * @state: atomic connector state
2388 *
2389 * Copies atomic state from a connector's current state. This is useful for
2390 * drivers that subclass the connector state.
2391 */
2392void
2393__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
2394                                            struct drm_connector_state *state)
2395{
2396        memcpy(state, connector->state, sizeof(*state));
2397}
2398EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
2399
2400/**
2401 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
2402 * @connector: drm connector
2403 *
2404 * Default connector state duplicate hook for drivers which don't have their own
2405 * subclassed connector state structure.
2406 */
2407struct drm_connector_state *
2408drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
2409{
2410        struct drm_connector_state *state;
2411
2412        if (WARN_ON(!connector->state))
2413                return NULL;
2414
2415        state = kmalloc(sizeof(*state), GFP_KERNEL);
2416        if (state)
2417                __drm_atomic_helper_connector_duplicate_state(connector, state);
2418
2419        return state;
2420}
2421EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
2422
2423/**
2424 * drm_atomic_helper_duplicate_state - duplicate an atomic state object
2425 * @dev: DRM device
2426 * @ctx: lock acquisition context
2427 *
2428 * Makes a copy of the current atomic state by looping over all objects and
2429 * duplicating their respective states.
2430 *
2431 * Note that this treats atomic state as persistent between save and restore.
2432 * Drivers must make sure that this is possible and won't result in confusion
2433 * or erroneous behaviour.
2434 *
2435 * Note that if callers haven't already acquired all modeset locks this might
2436 * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2437 *
2438 * Returns:
2439 * A pointer to the copy of the atomic state object on success or an
2440 * ERR_PTR()-encoded error code on failure.
2441 */
2442struct drm_atomic_state *
2443drm_atomic_helper_duplicate_state(struct drm_device *dev,
2444                                  struct drm_modeset_acquire_ctx *ctx)
2445{
2446        struct drm_atomic_state *state;
2447        struct drm_connector *conn;
2448        struct drm_plane *plane;
2449        struct drm_crtc *crtc;
2450        int err = 0;
2451
2452        state = drm_atomic_state_alloc(dev);
2453        if (!state)
2454                return ERR_PTR(-ENOMEM);
2455
2456        state->acquire_ctx = ctx;
2457
2458        drm_for_each_crtc(crtc, dev) {
2459                struct drm_crtc_state *crtc_state;
2460
2461                crtc_state = drm_atomic_get_crtc_state(state, crtc);
2462                if (IS_ERR(crtc_state)) {
2463                        err = PTR_ERR(crtc_state);
2464                        goto free;
2465                }
2466        }
2467
2468        drm_for_each_plane(plane, dev) {
2469                struct drm_plane_state *plane_state;
2470
2471                plane_state = drm_atomic_get_plane_state(state, plane);
2472                if (IS_ERR(plane_state)) {
2473                        err = PTR_ERR(plane_state);
2474                        goto free;
2475                }
2476        }
2477
2478        drm_for_each_connector(conn, dev) {
2479                struct drm_connector_state *conn_state;
2480
2481                conn_state = drm_atomic_get_connector_state(state, conn);
2482                if (IS_ERR(conn_state)) {
2483                        err = PTR_ERR(conn_state);
2484                        goto free;
2485                }
2486        }
2487
2488        /* clear the acquire context so that it isn't accidentally reused */
2489        state->acquire_ctx = NULL;
2490
2491free:
2492        if (err < 0) {
2493                drm_atomic_state_free(state);
2494                state = ERR_PTR(err);
2495        }
2496
2497        return state;
2498}
2499EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
2500
2501/**
2502 * __drm_atomic_helper_connector_destroy_state - release connector state
2503 * @connector: connector object
2504 * @state: connector state object to release
2505 *
2506 * Releases all resources stored in the connector state without actually
2507 * freeing the memory of the connector state. This is useful for drivers that
2508 * subclass the connector state.
2509 */
2510void
2511__drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2512                                            struct drm_connector_state *state)
2513{
2514        /*
2515         * This is currently a placeholder so that drivers that subclass the
2516         * state will automatically do the right thing if code is ever added
2517         * to this function.
2518         */
2519}
2520EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
2521
2522/**
2523 * drm_atomic_helper_connector_destroy_state - default state destroy hook
2524 * @connector: drm connector
2525 * @state: connector state object to release
2526 *
2527 * Default connector state destroy hook for drivers which don't have their own
2528 * subclassed connector state structure.
2529 */
2530void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2531                                          struct drm_connector_state *state)
2532{
2533        __drm_atomic_helper_connector_destroy_state(connector, state);
2534        kfree(state);
2535}
2536EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
Note: See TracBrowser for help on using the repository browser.